openbox/frame.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    frame.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "frame.h"
  21 #include "client.h"
  22 #include "openbox.h"
  23 #include "extensions.h"
  24 #include "prop.h"
  25 #include "config.h"
  26 #include "framerender.h"
  27 #include "mainloop.h"
  28 #include "focus_cycle.h"
  29 #include "focus_cycle_indicator.h"
  30 #include "composite.h"
  31 #include "moveresize.h"
  32 #include "screen.h"
  33 #include "render/theme.h"
  34
  35 #define FRAME_EVENTMASK (EnterWindowMask | LeaveWindowMask | \
  36                          ButtonPressMask | ButtonReleaseMask | \
  37                          SubstructureRedirectMask | FocusChangeMask)
  38 #define ELEMENT_EVENTMASK (ButtonPressMask | ButtonReleaseMask | \
  39                            ButtonMotionMask | PointerMotionMask | \
  40                            EnterWindowMask | LeaveWindowMask)
  41
  42 #define FRAME_ANIMATE_ICONIFY_TIME 150000 /* .15 seconds */
  43 #define FRAME_ANIMATE_ICONIFY_STEP_TIME (G_USEC_PER_SEC / 60) /* 60 Hz */
  44
  45 #define FRAME_HANDLE_Y(f) (f->size.top + f->client->area.height + f->cbwidth_b)
  46
  47 static void flash_done(gpointer data);
  48 static gboolean flash_timeout(gpointer data);
  49
  50 static void layout_title(ObFrame *self);
  51 static void set_theme_statics(ObFrame *self);
  52 static void free_theme_statics(ObFrame *self);
  53 static gboolean frame_animate_iconify(gpointer self);
  54 static void frame_adjust_cursors(ObFrame *self);
  55 static void frame_get_offscreen_buffer(ObFrame *self);
  56 static void frame_free_offscreen_buffer(ObFrame *self);
  57
  58 static Window createWindow(Window parent, Visual *visual,
  59                            gulong mask, XSetWindowAttributes *attrib)
  60 {
  61     return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
  62                          (visual ? 32 : RrDepth(ob_rr_inst)), InputOutput,
  63                          (visual ? visual : RrVisual(ob_rr_inst)),
  64                          mask, attrib);
  65
  66 }
  67
  68 ObFrame *frame_new(ObClient *client)
  69 {
  70     XSetWindowAttributes attrib;
  71     gulong mask;
  72     ObFrame *self;
  73     XWindowAttributes wattrib;
  74     Status ret;
  75
  76     self = g_new0(ObFrame, 1);
  77     self->client = client;
  78
  79     ret = XGetWindowAttributes(ob_display, client->window, &wattrib);
  80     g_assert(ret != BadDrawable);
  81     g_assert(ret != BadWindow);
  82     self->has_alpha = composite_window_has_alpha(wattrib.visual);
  83
  84     /* create the non-visible decor windows */
  85
  86     mask = 0;
  87     if (self->has_alpha) {
  88         /* the colormap/backpixel/borderpixel are required for supporting
  89            windows with 32bit visuals */
  90         mask = CWColormap | CWBackPixel | CWBorderPixel;
  91         /* create a colormap with the visual */
  92         self->colormap = attrib.colormap =
  93             XCreateColormap(ob_display,
  94                             RootWindow(ob_display, ob_screen),
  95                             wattrib.visual, AllocNone);
  96         attrib.background_pixel = BlackPixel(ob_display, ob_screen);
  97         attrib.border_pixel = BlackPixel(ob_display, ob_screen);
  98     }
  99
 100     self->window = createWindow(RootWindow(ob_display, ob_screen),
 101                                 (self->has_alpha ? wattrib.visual : NULL),
 102                                 mask, &attrib);
 103
 104     /* create the visible decor windows */
 105
 106     mask = 0;
 107     if (self->has_alpha) {
 108         /* client has a 32-bit visual */
 109         mask |= CWColormap | CWBackPixel | CWBorderPixel;
 110         attrib.colormap = RrColormap(ob_rr_inst);
 111     }
 112
 113     self->backback = createWindow(self->window, NULL, mask, &attrib);
 114     self->backfront = createWindow(self->backback, NULL, mask, &attrib);
 115
 116     mask |= CWEventMask;
 117     attrib.event_mask = ELEMENT_EVENTMASK;
 118     self->innerleft = createWindow(self->window, NULL, mask, &attrib);
 119     self->innertop = createWindow(self->window, NULL, mask, &attrib);
 120     self->innerright = createWindow(self->window, NULL, mask, &attrib);
 121     self->innerbottom = createWindow(self->window, NULL, mask, &attrib);
 122
 123     self->title = createWindow(self->window, NULL, mask, &attrib);
 124     self->titleleft = createWindow(self->window, NULL, mask, &attrib);
 125     self->titletop = createWindow(self->window, NULL, mask, &attrib);
 126     self->titletopleft = createWindow(self->window, NULL, mask, &attrib);
 127     self->titletopright = createWindow(self->window, NULL, mask, &attrib);
 128     self->titleright = createWindow(self->window, NULL, mask, &attrib);
 129     self->titlebottom = createWindow(self->window, NULL, mask, &attrib);
 130
 131     self->topresize = createWindow(self->title, NULL, mask, &attrib);
 132     self->tltresize = createWindow(self->title, NULL, mask, &attrib);
 133     self->tllresize = createWindow(self->title, NULL, mask, &attrib);
 134     self->trtresize = createWindow(self->title, NULL, mask, &attrib);
 135     self->trrresize = createWindow(self->title, NULL, mask, &attrib);
 136
 137     self->left = createWindow(self->window, NULL, mask, &attrib);
 138     self->right = createWindow(self->window, NULL, mask, &attrib);
 139
 140     self->label = createWindow(self->title, NULL, mask, &attrib);
 141     self->max = createWindow(self->title, NULL, mask, &attrib);
 142     self->close = createWindow(self->title, NULL, mask, &attrib);
 143     self->desk = createWindow(self->title, NULL, mask, &attrib);
 144     self->shade = createWindow(self->title, NULL, mask, &attrib);
 145     self->icon = createWindow(self->title, NULL, mask, &attrib);
 146     self->iconify = createWindow(self->title, NULL, mask, &attrib);
 147
 148     self->handle = createWindow(self->window, NULL, mask, &attrib);
 149     self->lgrip = createWindow(self->handle, NULL, mask, &attrib);
 150     self->rgrip = createWindow(self->handle, NULL, mask, &attrib);
 151
 152     self->handleleft = createWindow(self->handle, NULL, mask, &attrib);
 153     self->handleright = createWindow(self->handle, NULL, mask, &attrib);
 154
 155     self->handletop = createWindow(self->window, NULL, mask, &attrib);
 156     self->handlebottom = createWindow(self->window, NULL, mask, &attrib);
 157     self->lgripleft = createWindow(self->window, NULL, mask, &attrib);
 158     self->lgriptop = createWindow(self->window, NULL, mask, &attrib);
 159     self->lgripbottom = createWindow(self->window, NULL, mask, &attrib);
 160     self->rgripright = createWindow(self->window, NULL, mask, &attrib);
 161     self->rgriptop = createWindow(self->window, NULL, mask, &attrib);
 162     self->rgripbottom = createWindow(self->window, NULL, mask, &attrib);
 163
 164     self->focused = FALSE;
 165
 166     /* the other stuff is shown based on decor settings */
 167     XMapWindow(ob_display, self->label);
 168     XMapWindow(ob_display, self->backback);
 169     XMapWindow(ob_display, self->backfront);
 170
 171     self->max_press = self->close_press = self->desk_press =
 172         self->iconify_press = self->shade_press = FALSE;
 173     self->max_hover = self->close_hover = self->desk_hover =
 174         self->iconify_hover = self->shade_hover = FALSE;
 175
 176     set_theme_statics(self);
 177
 178     return (ObFrame*)self;
 179 }
 180
 181 static void set_theme_statics(ObFrame *self)
 182 {
 183     /* set colors/appearance/sizes for stuff that doesn't change */
 184     XResizeWindow(ob_display, self->max,
 185                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 186     XResizeWindow(ob_display, self->iconify,
 187                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 188     XResizeWindow(ob_display, self->icon,
 189                   ob_rr_theme->button_size + 2, ob_rr_theme->button_size + 2);
 190     XResizeWindow(ob_display, self->close,
 191                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 192     XResizeWindow(ob_display, self->desk,
 193                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 194     XResizeWindow(ob_display, self->shade,
 195                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 196     XResizeWindow(ob_display, self->tltresize,
 197                   ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);
 198     XResizeWindow(ob_display, self->trtresize,
 199                   ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);
 200     XResizeWindow(ob_display, self->tllresize,
 201                   ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
 202     XResizeWindow(ob_display, self->trrresize,
 203                   ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
 204
 205     /* set up the dynamic appearances */
 206     self->a_unfocused_title = RrAppearanceCopy(ob_rr_theme->a_unfocused_title);
 207     self->a_focused_title = RrAppearanceCopy(ob_rr_theme->a_focused_title);
 208     self->a_unfocused_label = RrAppearanceCopy(ob_rr_theme->a_unfocused_label);
 209     self->a_focused_label = RrAppearanceCopy(ob_rr_theme->a_focused_label);
 210     self->a_unfocused_handle =
 211         RrAppearanceCopy(ob_rr_theme->a_unfocused_handle);
 212     self->a_focused_handle = RrAppearanceCopy(ob_rr_theme->a_focused_handle);
 213     self->a_icon = RrAppearanceCopy(ob_rr_theme->a_icon);
 214 }
 215
 216 static void free_theme_statics(ObFrame *self)
 217 {
 218     RrAppearanceFree(self->a_unfocused_title);
 219     RrAppearanceFree(self->a_focused_title);
 220     RrAppearanceFree(self->a_unfocused_label);
 221     RrAppearanceFree(self->a_focused_label);
 222     RrAppearanceFree(self->a_unfocused_handle);
 223     RrAppearanceFree(self->a_focused_handle);
 224     RrAppearanceFree(self->a_icon);
 225 }
 226
 227 void frame_free(ObFrame *self)
 228 {
 229     free_theme_statics(self);
 230
 231     XDestroyWindow(ob_display, self->window);
 232     if (self->colormap)
 233         XFreeColormap(ob_display, self->colormap);
 234     frame_free_offscreen_buffer(self);
 235
 236     g_free(self);
 237 }
 238
 239 void frame_show(ObFrame *self)
 240 {
 241     if (!self->visible) {
 242         self->visible = TRUE;
 243         framerender_frame(self);
 244         XMapWindow(ob_display, self->client->window);
 245         XMapWindow(ob_display, self->window);
 246
 247         frame_get_offscreen_buffer(self);
 248     }
 249 }
 250
 251 void frame_hide(ObFrame *self)
 252 {
 253     if (self->visible) {
 254         self->visible = FALSE;
 255         if (!frame_iconify_animating(self))
 256             XUnmapWindow(ob_display, self->window);
 257
 258         /* we unmap the client itself so that we can get MapRequest
 259            events, and because the ICCCM tells us to! */
 260         XUnmapWindow(ob_display, self->client->window);
 261         self->client->ignore_unmaps += 1;
 262     }
 263 }
 264
 265 void frame_adjust_theme(ObFrame *self)
 266 {
 267     free_theme_statics(self);
 268     set_theme_statics(self);
 269 }
 270
 271 void frame_adjust_shape(ObFrame *self)
 272 {
 273 #ifdef SHAPE
 274     gint num;
 275     XRectangle xrect[2];
 276
 277     if (!self->client->shaped) {
 278         /* clear the shape on the frame window */
 279         XShapeCombineMask(ob_display, self->window, ShapeBounding,
 280                           self->size.left,
 281                           self->size.top,
 282                           None, ShapeSet);
 283     } else {
 284         /* make the frame's shape match the clients */
 285         XShapeCombineShape(ob_display, self->window, ShapeBounding,
 286                            self->size.left,
 287                            self->size.top,
 288                            self->client->window,
 289                            ShapeBounding, ShapeSet);
 290
 291         num = 0;
 292         if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
 293             xrect[0].x = 0;
 294             xrect[0].y = 0;
 295             xrect[0].width = self->area.width;
 296             xrect[0].height = self->size.top;
 297             ++num;
 298         }
 299
 300         if (self->decorations & OB_FRAME_DECOR_HANDLE &&
 301             ob_rr_theme->handle_height > 0)
 302         {
 303             xrect[1].x = 0;
 304             xrect[1].y = FRAME_HANDLE_Y(self);
 305             xrect[1].width = self->area.width;
 306             xrect[1].height = ob_rr_theme->handle_height +
 307                 self->bwidth * 2;
 308             ++num;
 309         }
 310
 311         XShapeCombineRectangles(ob_display, self->window,
 312                                 ShapeBounding, 0, 0, xrect, num,
 313                                 ShapeUnion, Unsorted);
 314     }
 315
 316     if (self->pixmap)
 317         XShapeCombineShape(ob_display, self->pixmap, ShapeBounding,
 318                            0, 0, self->window, ShapeBounding, ShapeSet);
 319
 320 #endif
 321 }
 322
 323 void frame_adjust_area(ObFrame *self, gboolean moved,
 324                        gboolean resized, gboolean fake)
 325 {
 326     Strut oldsize;
 327
 328     oldsize = self->size;
 329
 330     if (resized) {
 331         /* do this before changing the frame's status like max_horz max_vert */
 332         frame_adjust_cursors(self);
 333
 334         self->functions = self->client->functions;
 335         self->decorations = self->client->decorations;
 336         self->max_horz = self->client->max_horz;
 337         self->max_vert = self->client->max_vert;
 338         self->shaded = self->client->shaded;
 339
 340         if (self->decorations & OB_FRAME_DECOR_BORDER ||
 341             (self->client->undecorated && config_theme_keepborder))
 342             self->bwidth = ob_rr_theme->fbwidth;
 343         else
 344             self->bwidth = 0;
 345
 346         if (self->decorations & OB_FRAME_DECOR_BORDER) {
 347             self->cbwidth_l = self->cbwidth_r = ob_rr_theme->cbwidthx;
 348             self->cbwidth_t = self->cbwidth_b = ob_rr_theme->cbwidthy;
 349         } else
 350             self->cbwidth_l = self->cbwidth_t =
 351                 self->cbwidth_r = self->cbwidth_b = 0;
 352
 353         if (self->max_horz) {
 354             self->cbwidth_l = self->cbwidth_r = 0;
 355             self->width = self->client->area.width;
 356             if (self->max_vert)
 357                 self->cbwidth_b = 0;
 358         } else
 359             self->width = self->client->area.width +
 360                 self->cbwidth_l + self->cbwidth_r;
 361
 362         /* some elements are sized based of the width, so don't let them have
 363            negative values */
 364         self->width = MAX(self->width,
 365                           (ob_rr_theme->grip_width + self->bwidth) * 2 + 1);
 366
 367         STRUT_SET(self->size,
 368                   self->cbwidth_l + (!self->max_horz ? self->bwidth : 0),
 369                   self->cbwidth_t + self->bwidth,
 370                   self->cbwidth_r + (!self->max_horz ? self->bwidth : 0),
 371                   self->cbwidth_b + (!self->max_horz || !self->max_vert ? self->bwidth : 0));
 372
 373         if (self->decorations & OB_FRAME_DECOR_TITLEBAR)
 374             self->size.top += ob_rr_theme->title_height + self->bwidth;
 375         if (self->decorations & OB_FRAME_DECOR_HANDLE &&
 376             ob_rr_theme->handle_height > 0)
 377         {
 378             self->size.bottom += ob_rr_theme->handle_height + self->bwidth;
 379         }
 380
 381         /* position/size and map/unmap all the windows */
 382
 383         if (!fake) {
 384             if (self->cbwidth_l) {
 385                 XMoveResizeWindow(ob_display, self->innerleft,
 386                                   self->size.left - self->cbwidth_l,
 387                                   self->size.top,
 388                                   self->cbwidth_l, self->client->area.height);
 389
 390                 XMapWindow(ob_display, self->innerleft);
 391             } else
 392                 XUnmapWindow(ob_display, self->innerleft);
 393
 394             if (self->cbwidth_r) {
 395                 XMoveResizeWindow(ob_display, self->innerright,
 396                                   self->size.left + self->client->area.width,
 397                                   self->size.top,
 398                                   self->cbwidth_r, self->client->area.height);
 399
 400                 XMapWindow(ob_display, self->innerright);
 401             } else
 402                 XUnmapWindow(ob_display, self->innerright);
 403
 404             if (self->cbwidth_t) {
 405                 XMoveResizeWindow(ob_display, self->innertop,
 406                                   self->size.left - self->cbwidth_l,
 407                                   self->size.top - self->cbwidth_t,
 408                                   self->client->area.width +
 409                                   self->cbwidth_l + self->cbwidth_r,
 410                                   self->cbwidth_t);
 411
 412                 XMapWindow(ob_display, self->innertop);
 413             } else
 414                 XUnmapWindow(ob_display, self->innertop);
 415
 416             if (self->cbwidth_b) {
 417                 XMoveResizeWindow(ob_display, self->innerbottom,
 418                                   self->size.left - self->cbwidth_l,
 419                                   self->size.top + self->client->area.height,
 420                                   self->client->area.width +
 421                                   self->cbwidth_l + self->cbwidth_r,
 422                                   self->cbwidth_b);
 423
 424                 XMapWindow(ob_display, self->innerbottom);
 425             } else
 426                 XUnmapWindow(ob_display, self->innerbottom);
 427
 428             if (self->bwidth) {
 429                 gint titlesides;
 430
 431                 /* height of titleleft and titleright */
 432                 titlesides = (!self->max_horz ? ob_rr_theme->grip_width : 0);
 433
 434                 XMoveResizeWindow(ob_display, self->titletop,
 435                                   ob_rr_theme->grip_width + self->bwidth, 0,
 436                                   /* width + bwidth*2 - bwidth*2 - grips*2 */
 437                                   self->width - ob_rr_theme->grip_width * 2,
 438                                   self->bwidth);
 439                 XMoveResizeWindow(ob_display, self->titletopleft,
 440                                   0, 0,
 441                                   ob_rr_theme->grip_width + self->bwidth,
 442                                   self->bwidth);
 443                 XMoveResizeWindow(ob_display, self->titletopright,
 444                                   self->client->area.width +
 445                                   self->size.left + self->size.right -
 446                                   ob_rr_theme->grip_width - self->bwidth,
 447                                   0,
 448                                   ob_rr_theme->grip_width + self->bwidth,
 449                                   self->bwidth);
 450
 451                 if (titlesides > 0) {
 452                     XMoveResizeWindow(ob_display, self->titleleft,
 453                                       0, self->bwidth,
 454                                       self->bwidth,
 455                                       titlesides);
 456                     XMoveResizeWindow(ob_display, self->titleright,
 457                                       self->client->area.width +
 458                                       self->size.left + self->size.right -
 459                                       self->bwidth,
 460                                       self->bwidth,
 461                                       self->bwidth,
 462                                       titlesides);
 463
 464                     XMapWindow(ob_display, self->titleleft);
 465                     XMapWindow(ob_display, self->titleright);
 466                 } else {
 467                     XUnmapWindow(ob_display, self->titleleft);
 468                     XUnmapWindow(ob_display, self->titleright);
 469                 }
 470
 471                 XMapWindow(ob_display, self->titletop);
 472                 XMapWindow(ob_display, self->titletopleft);
 473                 XMapWindow(ob_display, self->titletopright);
 474
 475                 if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
 476                     XMoveResizeWindow(ob_display, self->titlebottom,
 477                                       (self->max_horz ? 0 : self->bwidth),
 478                                       ob_rr_theme->title_height + self->bwidth,
 479                                       self->width,
 480                                       self->bwidth);
 481
 482                     XMapWindow(ob_display, self->titlebottom);
 483                 } else
 484                     XUnmapWindow(ob_display, self->titlebottom);
 485             } else {
 486                 XUnmapWindow(ob_display, self->titlebottom);
 487
 488                 XUnmapWindow(ob_display, self->titletop);
 489                 XUnmapWindow(ob_display, self->titletopleft);
 490                 XUnmapWindow(ob_display, self->titletopright);
 491                 XUnmapWindow(ob_display, self->titleleft);
 492                 XUnmapWindow(ob_display, self->titleright);
 493             }
 494
 495             if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
 496                 XMoveResizeWindow(ob_display, self->title,
 497                                   (self->max_horz ? 0 : self->bwidth),
 498                                   self->bwidth,
 499                                   self->width, ob_rr_theme->title_height);
 500
 501                 XMapWindow(ob_display, self->title);
 502
 503                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {
 504                     XMoveResizeWindow(ob_display, self->topresize,
 505                                       ob_rr_theme->grip_width,
 506                                       0,
 507                                       self->width - ob_rr_theme->grip_width *2,
 508                                       ob_rr_theme->paddingy + 1);
 509
 510                     XMoveWindow(ob_display, self->tltresize, 0, 0);
 511                     XMoveWindow(ob_display, self->tllresize, 0, 0);
 512                     XMoveWindow(ob_display, self->trtresize,
 513                                 self->width - ob_rr_theme->grip_width, 0);
 514                     XMoveWindow(ob_display, self->trrresize,
 515                                 self->width - ob_rr_theme->paddingx - 1, 0);
 516
 517                     XMapWindow(ob_display, self->topresize);
 518                     XMapWindow(ob_display, self->tltresize);
 519                     XMapWindow(ob_display, self->tllresize);
 520                     XMapWindow(ob_display, self->trtresize);
 521                     XMapWindow(ob_display, self->trrresize);
 522                 } else {
 523                     XUnmapWindow(ob_display, self->topresize);
 524                     XUnmapWindow(ob_display, self->tltresize);
 525                     XUnmapWindow(ob_display, self->tllresize);
 526                     XUnmapWindow(ob_display, self->trtresize);
 527                     XUnmapWindow(ob_display, self->trrresize);
 528                 }
 529             } else
 530                 XUnmapWindow(ob_display, self->title);
 531         }
 532
 533         if ((self->decorations & OB_FRAME_DECOR_TITLEBAR))
 534             /* layout the title bar elements */
 535             layout_title(self);
 536
 537         if (!fake) {
 538             gint sidebwidth = self->max_horz ? 0 : self->bwidth;
 539
 540             if (self->bwidth && self->size.bottom) {
 541                 XMoveResizeWindow(ob_display, self->handlebottom,
 542                                   ob_rr_theme->grip_width +
 543                                   self->bwidth + sidebwidth,
 544                                   self->size.top + self->client->area.height +
 545                                   self->size.bottom - self->bwidth,
 546                                   self->width - (ob_rr_theme->grip_width +
 547                                                  sidebwidth) * 2,
 548                                   self->bwidth);
 549
 550
 551                 if (sidebwidth) {
 552                     XMoveResizeWindow(ob_display, self->lgripleft,
 553                                       0,
 554                                       self->size.top +
 555                                       self->client->area.height +
 556                                       self->size.bottom -
 557                                       (!self->max_horz ?
 558                                        ob_rr_theme->grip_width :
 559                                        self->size.bottom - self->cbwidth_b),
 560                                       self->bwidth,
 561                                       (!self->max_horz ?
 562                                        ob_rr_theme->grip_width :
 563                                        self->size.bottom - self->cbwidth_b));
 564                     XMoveResizeWindow(ob_display, self->rgripright,
 565                                   self->size.left +
 566                                       self->client->area.width +
 567                                       self->size.right - self->bwidth,
 568                                       self->size.top +
 569                                       self->client->area.height +
 570                                       self->size.bottom -
 571                                       (!self->max_horz ?
 572                                        ob_rr_theme->grip_width :
 573                                        self->size.bottom - self->cbwidth_b),
 574                                       self->bwidth,
 575                                       (!self->max_horz ?
 576                                        ob_rr_theme->grip_width :
 577                                        self->size.bottom - self->cbwidth_b));
 578
 579                     XMapWindow(ob_display, self->lgripleft);
 580                     XMapWindow(ob_display, self->rgripright);
 581                 } else {
 582                     XUnmapWindow(ob_display, self->lgripleft);
 583                     XUnmapWindow(ob_display, self->rgripright);
 584                 }
 585
 586                 XMoveResizeWindow(ob_display, self->lgripbottom,
 587                                   sidebwidth,
 588                                   self->size.top + self->client->area.height +
 589                                   self->size.bottom - self->bwidth,
 590                                   ob_rr_theme->grip_width + self->bwidth,
 591                                   self->bwidth);
 592                 XMoveResizeWindow(ob_display, self->rgripbottom,
 593                                   self->size.left + self->client->area.width +
 594                                   self->size.right - self->bwidth - sidebwidth -
 595                                   ob_rr_theme->grip_width,
 596                                   self->size.top + self->client->area.height +
 597                                   self->size.bottom - self->bwidth,
 598                                   ob_rr_theme->grip_width + self->bwidth,
 599                                   self->bwidth);
 600
 601                 XMapWindow(ob_display, self->handlebottom);
 602                 XMapWindow(ob_display, self->lgripbottom);
 603                 XMapWindow(ob_display, self->rgripbottom);
 604
 605                 if (self->decorations & OB_FRAME_DECOR_HANDLE &&
 606                     ob_rr_theme->handle_height > 0)
 607                 {
 608                     XMoveResizeWindow(ob_display, self->handletop,
 609                                       ob_rr_theme->grip_width +
 610                                       self->bwidth + sidebwidth,
 611                                       FRAME_HANDLE_Y(self),
 612                                       self->width - (ob_rr_theme->grip_width +
 613                                                      sidebwidth) * 2,
 614                                       self->bwidth);
 615                     XMapWindow(ob_display, self->handletop);
 616
 617                     if (self->decorations & OB_FRAME_DECOR_GRIPS) {
 618                         XMoveResizeWindow(ob_display, self->handleleft,
 619                                           ob_rr_theme->grip_width,
 620                                           0,
 621                                           self->bwidth,
 622                                           ob_rr_theme->handle_height);
 623                         XMoveResizeWindow(ob_display, self->handleright,
 624                                           self->width -
 625                                           ob_rr_theme->grip_width -
 626                                           self->bwidth,
 627                                           0,
 628                                           self->bwidth,
 629                                           ob_rr_theme->handle_height);
 630
 631                         XMoveResizeWindow(ob_display, self->lgriptop,
 632                                           sidebwidth,
 633                                           FRAME_HANDLE_Y(self),
 634                                           ob_rr_theme->grip_width +
 635                                           self->bwidth,
 636                                           self->bwidth);
 637                         XMoveResizeWindow(ob_display, self->rgriptop,
 638                                           self->size.left +
 639                                           self->client->area.width +
 640                                           self->size.right - self->bwidth -
 641                                           sidebwidth - ob_rr_theme->grip_width,
 642                                           FRAME_HANDLE_Y(self),
 643                                           ob_rr_theme->grip_width +
 644                                           self->bwidth,
 645                                           self->bwidth);
 646
 647                         XMapWindow(ob_display, self->handleleft);
 648                         XMapWindow(ob_display, self->handleright);
 649                         XMapWindow(ob_display, self->lgriptop);
 650                         XMapWindow(ob_display, self->rgriptop);
 651                     } else {
 652                         XUnmapWindow(ob_display, self->handleleft);
 653                         XUnmapWindow(ob_display, self->handleright);
 654                         XUnmapWindow(ob_display, self->lgriptop);
 655                         XUnmapWindow(ob_display, self->rgriptop);
 656                     }
 657                 } else {
 658                     XUnmapWindow(ob_display, self->handleleft);
 659                     XUnmapWindow(ob_display, self->handleright);
 660                     XUnmapWindow(ob_display, self->lgriptop);
 661                     XUnmapWindow(ob_display, self->rgriptop);
 662
 663                     XUnmapWindow(ob_display, self->handletop);
 664                 }
 665             } else {
 666                 XUnmapWindow(ob_display, self->handleleft);
 667                 XUnmapWindow(ob_display, self->handleright);
 668                 XUnmapWindow(ob_display, self->lgriptop);
 669                 XUnmapWindow(ob_display, self->rgriptop);
 670
 671                 XUnmapWindow(ob_display, self->handletop);
 672
 673                 XUnmapWindow(ob_display, self->handlebottom);
 674                 XUnmapWindow(ob_display, self->lgripleft);
 675                 XUnmapWindow(ob_display, self->rgripright);
 676                 XUnmapWindow(ob_display, self->lgripbottom);
 677                 XUnmapWindow(ob_display, self->rgripbottom);
 678             }
 679
 680             if (self->decorations & OB_FRAME_DECOR_HANDLE &&
 681                 ob_rr_theme->handle_height > 0)
 682             {
 683                 XMoveResizeWindow(ob_display, self->handle,
 684                                   sidebwidth,
 685                                   FRAME_HANDLE_Y(self) + self->bwidth,
 686                                   self->width, ob_rr_theme->handle_height);
 687                 XMapWindow(ob_display, self->handle);
 688
 689                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {
 690                     XMoveResizeWindow(ob_display, self->lgrip,
 691                                       0, 0,
 692                                       ob_rr_theme->grip_width,
 693                                       ob_rr_theme->handle_height);
 694                     XMoveResizeWindow(ob_display, self->rgrip,
 695                                       self->width - ob_rr_theme->grip_width,
 696                                       0,
 697                                       ob_rr_theme->grip_width,
 698                                       ob_rr_theme->handle_height);
 699
 700                     XMapWindow(ob_display, self->lgrip);
 701                     XMapWindow(ob_display, self->rgrip);
 702                 } else {
 703                     XUnmapWindow(ob_display, self->lgrip);
 704                     XUnmapWindow(ob_display, self->rgrip);
 705                 }
 706             } else {
 707                 XUnmapWindow(ob_display, self->lgrip);
 708                 XUnmapWindow(ob_display, self->rgrip);
 709
 710                 XUnmapWindow(ob_display, self->handle);
 711             }
 712
 713             if (self->bwidth && !self->max_horz) {
 714                 XMoveResizeWindow(ob_display, self->left,
 715                                   0,
 716                                   self->bwidth + ob_rr_theme->grip_width,
 717                                   self->bwidth,
 718                                   self->client->area.height +
 719                                   self->size.top + self->size.bottom -
 720                                   ob_rr_theme->grip_width * 2);
 721
 722                 XMapWindow(ob_display, self->left);
 723             } else
 724                 XUnmapWindow(ob_display, self->left);
 725
 726             if (self->bwidth && !self->max_horz) {
 727                 XMoveResizeWindow(ob_display, self->right,
 728                                   self->client->area.width +
 729                                   self->cbwidth_l + self->cbwidth_r + self->bwidth,
 730                                   self->bwidth + ob_rr_theme->grip_width,
 731                                   self->bwidth,
 732                                   self->client->area.height +
 733                                   self->size.top + self->size.bottom -
 734                                   ob_rr_theme->grip_width * 2);
 735
 736                 XMapWindow(ob_display, self->right);
 737             } else
 738                 XUnmapWindow(ob_display, self->right);
 739
 740             XMoveResizeWindow(ob_display, self->backback,
 741                               self->size.left, self->size.top,
 742                               self->client->area.width,
 743                               self->client->area.height);
 744         }
 745     }
 746
 747     /* shading can change without being moved or resized */
 748     RECT_SET_SIZE(self->area,
 749                   self->client->area.width +
 750                   self->size.left + self->size.right,
 751                   (self->client->shaded ?
 752                    ob_rr_theme->title_height + self->bwidth * 2:
 753                    self->client->area.height +
 754                    self->size.top + self->size.bottom));
 755
 756     if ((moved || resized) && !fake) {
 757         /* find the new coordinates, done after setting the frame.size, for
 758            frame_client_gravity. */
 759         self->area.x = self->client->area.x;
 760         self->area.y = self->client->area.y;
 761         frame_client_gravity(self, &self->area.x, &self->area.y,
 762                              self->client->area.width,
 763                              self->client->area.height);
 764     }
 765
 766     if (!fake) {
 767         if (!frame_iconify_animating(self))
 768             /* move and resize the top level frame.
 769                shading can change without being moved or resized.
 770
 771                but don't do this during an iconify animation. it will be
 772                reflected afterwards.
 773             */
 774             XMoveResizeWindow(ob_display, self->window,
 775                               self->area.x,
 776                               self->area.y,
 777                               self->area.width,
 778                               self->area.height);
 779
 780         /* when the client has StaticGravity, it likes to move around.
 781            also this correctly positions the client when it maps.
 782            this also needs to be run when the frame's decorations sizes change!
 783         */
 784         XMoveWindow(ob_display, self->client->window,
 785                     self->size.left, self->size.top);
 786
 787         if (resized) {
 788             self->need_render = TRUE;
 789             framerender_frame(self);
 790             frame_adjust_shape(self);
 791
 792             /* the offscreen buffer is invalid when the window is resized */
 793             if (self->visible)
 794                 frame_get_offscreen_buffer(self);
 795         }
 796
 797         if (!STRUT_EQUAL(self->size, oldsize)) {
 798             gulong vals[4];
 799             vals[0] = self->size.left;
 800             vals[1] = self->size.right;
 801             vals[2] = self->size.top;
 802             vals[3] = self->size.bottom;
 803             PROP_SETA32(self->client->window, net_frame_extents,
 804                         cardinal, vals, 4);
 805             PROP_SETA32(self->client->window, kde_net_wm_frame_strut,
 806                         cardinal, vals, 4);
 807         }
 808
 809         /* if this occurs while we are focus cycling, the indicator needs to
 810            match the changes */
 811         if (focus_cycle_target == self->client)
 812             focus_cycle_draw_indicator(self->client);
 813     }
 814     if (resized && (self->decorations & OB_FRAME_DECOR_TITLEBAR))
 815         XResizeWindow(ob_display, self->label, self->label_width,
 816                       ob_rr_theme->label_height);
 817
 818 }
 819
 820 static void frame_adjust_cursors(ObFrame *self)
 821 {
 822     if ((self->functions & OB_CLIENT_FUNC_RESIZE) !=
 823         (self->client->functions & OB_CLIENT_FUNC_RESIZE) ||
 824         self->max_horz != self->client->max_horz ||
 825         self->max_vert != self->client->max_vert ||
 826         self->shaded != self->client->shaded)
 827     {
 828         gboolean r = (self->client->functions & OB_CLIENT_FUNC_RESIZE) &&
 829             !(self->client->max_horz && self->client->max_vert);
 830         gboolean topbot = !self->client->max_vert;
 831         gboolean sh = self->client->shaded;
 832         XSetWindowAttributes a;
 833
 834         /* these ones turn off when max vert, and some when shaded */
 835         a.cursor = ob_cursor(r && topbot && !sh ?
 836                              OB_CURSOR_NORTH : OB_CURSOR_NONE);
 837         XChangeWindowAttributes(ob_display, self->topresize, CWCursor, &a);
 838         XChangeWindowAttributes(ob_display, self->titletop, CWCursor, &a);
 839         a.cursor = ob_cursor(r && topbot ? OB_CURSOR_SOUTH : OB_CURSOR_NONE);
 840         XChangeWindowAttributes(ob_display, self->handle, CWCursor, &a);
 841         XChangeWindowAttributes(ob_display, self->handletop, CWCursor, &a);
 842         XChangeWindowAttributes(ob_display, self->handlebottom, CWCursor, &a);
 843         XChangeWindowAttributes(ob_display, self->innerbottom, CWCursor, &a);
 844
 845         /* these ones change when shaded */
 846         a.cursor = ob_cursor(r ? (sh ? OB_CURSOR_WEST : OB_CURSOR_NORTHWEST) :
 847                              OB_CURSOR_NONE);
 848         XChangeWindowAttributes(ob_display, self->titleleft, CWCursor, &a);
 849         XChangeWindowAttributes(ob_display, self->tltresize, CWCursor, &a);
 850         XChangeWindowAttributes(ob_display, self->tllresize, CWCursor, &a);
 851         XChangeWindowAttributes(ob_display, self->titletopleft, CWCursor, &a);
 852         a.cursor = ob_cursor(r ? (sh ? OB_CURSOR_EAST : OB_CURSOR_NORTHEAST) :
 853                              OB_CURSOR_NONE);
 854         XChangeWindowAttributes(ob_display, self->titleright, CWCursor, &a);
 855         XChangeWindowAttributes(ob_display, self->trtresize, CWCursor, &a);
 856         XChangeWindowAttributes(ob_display, self->trrresize, CWCursor, &a);
 857         XChangeWindowAttributes(ob_display, self->titletopright, CWCursor, &a);
 858
 859         /* these ones are pretty static */
 860         a.cursor = ob_cursor(r ? OB_CURSOR_WEST : OB_CURSOR_NONE);
 861         XChangeWindowAttributes(ob_display, self->left, CWCursor, &a);
 862         XChangeWindowAttributes(ob_display, self->innerleft, CWCursor, &a);
 863         a.cursor = ob_cursor(r ? OB_CURSOR_EAST : OB_CURSOR_NONE);
 864         XChangeWindowAttributes(ob_display, self->right, CWCursor, &a);
 865         XChangeWindowAttributes(ob_display, self->innerright, CWCursor, &a);
 866         a.cursor = ob_cursor(r ? OB_CURSOR_SOUTHWEST : OB_CURSOR_NONE);
 867         XChangeWindowAttributes(ob_display, self->lgrip, CWCursor, &a);
 868         XChangeWindowAttributes(ob_display, self->handleleft, CWCursor, &a);
 869         XChangeWindowAttributes(ob_display, self->lgripleft, CWCursor, &a);
 870         XChangeWindowAttributes(ob_display, self->lgriptop, CWCursor, &a);
 871         XChangeWindowAttributes(ob_display, self->lgripbottom, CWCursor, &a);
 872         a.cursor = ob_cursor(r ? OB_CURSOR_SOUTHEAST : OB_CURSOR_NONE);
 873         XChangeWindowAttributes(ob_display, self->rgrip, CWCursor, &a);
 874         XChangeWindowAttributes(ob_display, self->handleright, CWCursor, &a);
 875         XChangeWindowAttributes(ob_display, self->rgripright, CWCursor, &a);
 876         XChangeWindowAttributes(ob_display, self->rgriptop, CWCursor, &a);
 877         XChangeWindowAttributes(ob_display, self->rgripbottom, CWCursor, &a);
 878     }
 879 }
 880
 881 void frame_adjust_client_area(ObFrame *self)
 882 {
 883     /* adjust the window which is there to prevent flashing on unmap */
 884     XMoveResizeWindow(ob_display, self->backfront, 0, 0,
 885                       self->client->area.width,
 886                       self->client->area.height);
 887 }
 888
 889 void frame_adjust_state(ObFrame *self)
 890 {
 891     self->need_render = TRUE;
 892     framerender_frame(self);
 893 }
 894
 895 void frame_adjust_focus(ObFrame *self, gboolean hilite)
 896 {
 897     self->focused = hilite;
 898     self->need_render = TRUE;
 899     framerender_frame(self);
 900     XFlush(ob_display);
 901 }
 902
 903 void frame_adjust_title(ObFrame *self)
 904 {
 905     self->need_render = TRUE;
 906     framerender_frame(self);
 907 }
 908
 909 void frame_adjust_icon(ObFrame *self)
 910 {
 911     self->need_render = TRUE;
 912     framerender_frame(self);
 913 }
 914
 915 void frame_grab_client(ObFrame *self)
 916 {
 917     /* DO NOT map the client window here. we used to do that, but it is bogus.
 918        we need to set up the client's dimensions and everything before we
 919        send a mapnotify or we create race conditions.
 920     */
 921
 922     /* reparent the client to the frame */
 923     XReparentWindow(ob_display, self->client->window, self->window, 0, 0);
 924
 925     /*
 926       When reparenting the client window, it is usually not mapped yet, since
 927       this occurs from a MapRequest. However, in the case where Openbox is
 928       starting up, the window is already mapped, so we'll see an unmap event
 929       for it.
 930     */
 931     if (ob_state() == OB_STATE_STARTING)
 932         ++self->client->ignore_unmaps;
 933
 934     /* select the event mask on the client's parent (to receive config/map
 935        req's) the ButtonPress is to catch clicks on the client border */
 936     XSelectInput(ob_display, self->window, FRAME_EVENTMASK);
 937
 938     /* set all the windows for the frame in the window_map */
 939     g_hash_table_insert(window_map, &self->window, self->client);
 940     g_hash_table_insert(window_map, &self->backback, self->client);
 941     g_hash_table_insert(window_map, &self->backfront, self->client);
 942     g_hash_table_insert(window_map, &self->innerleft, self->client);
 943     g_hash_table_insert(window_map, &self->innertop, self->client);
 944     g_hash_table_insert(window_map, &self->innerright, self->client);
 945     g_hash_table_insert(window_map, &self->innerbottom, self->client);
 946     g_hash_table_insert(window_map, &self->title, self->client);
 947     g_hash_table_insert(window_map, &self->label, self->client);
 948     g_hash_table_insert(window_map, &self->max, self->client);
 949     g_hash_table_insert(window_map, &self->close, self->client);
 950     g_hash_table_insert(window_map, &self->desk, self->client);
 951     g_hash_table_insert(window_map, &self->shade, self->client);
 952     g_hash_table_insert(window_map, &self->icon, self->client);
 953     g_hash_table_insert(window_map, &self->iconify, self->client);
 954     g_hash_table_insert(window_map, &self->handle, self->client);
 955     g_hash_table_insert(window_map, &self->lgrip, self->client);
 956     g_hash_table_insert(window_map, &self->rgrip, self->client);
 957     g_hash_table_insert(window_map, &self->topresize, self->client);
 958     g_hash_table_insert(window_map, &self->tltresize, self->client);
 959     g_hash_table_insert(window_map, &self->tllresize, self->client);
 960     g_hash_table_insert(window_map, &self->trtresize, self->client);
 961     g_hash_table_insert(window_map, &self->trrresize, self->client);
 962     g_hash_table_insert(window_map, &self->left, self->client);
 963     g_hash_table_insert(window_map, &self->right, self->client);
 964     g_hash_table_insert(window_map, &self->titleleft, self->client);
 965     g_hash_table_insert(window_map, &self->titletop, self->client);
 966     g_hash_table_insert(window_map, &self->titletopleft, self->client);
 967     g_hash_table_insert(window_map, &self->titletopright, self->client);
 968     g_hash_table_insert(window_map, &self->titleright, self->client);
 969     g_hash_table_insert(window_map, &self->titlebottom, self->client);
 970     g_hash_table_insert(window_map, &self->handleleft, self->client);
 971     g_hash_table_insert(window_map, &self->handletop, self->client);
 972     g_hash_table_insert(window_map, &self->handleright, self->client);
 973     g_hash_table_insert(window_map, &self->handlebottom, self->client);
 974     g_hash_table_insert(window_map, &self->lgripleft, self->client);
 975     g_hash_table_insert(window_map, &self->lgriptop, self->client);
 976     g_hash_table_insert(window_map, &self->lgripbottom, self->client);
 977     g_hash_table_insert(window_map, &self->rgripright, self->client);
 978     g_hash_table_insert(window_map, &self->rgriptop, self->client);
 979     g_hash_table_insert(window_map, &self->rgripbottom, self->client);
 980 }
 981
 982 void frame_release_client(ObFrame *self)
 983 {
 984     XEvent ev;
 985     gboolean reparent = TRUE;
 986
 987     /* if there was any animation going on, kill it */
 988     ob_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
 989                                      self, FALSE);
 990
 991     /* check if the app has already reparented its window away */
 992     while (XCheckTypedWindowEvent(ob_display, self->client->window,
 993                                   ReparentNotify, &ev))
 994     {
 995         /* This check makes sure we don't catch our own reparent action to
 996            our frame window. This doesn't count as the app reparenting itself
 997            away of course.
 998
 999            Reparent events that are generated by us are just discarded here.
1000            They are of no consequence to us anyhow.
1001         */
1002         if (ev.xreparent.parent != self->window) {
1003             reparent = FALSE;
1004             XPutBackEvent(ob_display, &ev);
1005             break;
1006         }
1007     }
1008
1009     if (reparent) {
1010         /* according to the ICCCM - if the client doesn't reparent itself,
1011            then we will reparent the window to root for them */
1012         XReparentWindow(ob_display, self->client->window,
1013                         RootWindow(ob_display, ob_screen),
1014                         self->client->area.x,
1015                         self->client->area.y);
1016     }
1017
1018     /* remove all the windows for the frame from the window_map */
1019     g_hash_table_remove(window_map, &self->window);
1020     g_hash_table_remove(window_map, &self->backback);
1021     g_hash_table_remove(window_map, &self->backfront);
1022     g_hash_table_remove(window_map, &self->innerleft);
1023     g_hash_table_remove(window_map, &self->innertop);
1024     g_hash_table_remove(window_map, &self->innerright);
1025     g_hash_table_remove(window_map, &self->innerbottom);
1026     g_hash_table_remove(window_map, &self->title);
1027     g_hash_table_remove(window_map, &self->label);
1028     g_hash_table_remove(window_map, &self->max);
1029     g_hash_table_remove(window_map, &self->close);
1030     g_hash_table_remove(window_map, &self->desk);
1031     g_hash_table_remove(window_map, &self->shade);
1032     g_hash_table_remove(window_map, &self->icon);
1033     g_hash_table_remove(window_map, &self->iconify);
1034     g_hash_table_remove(window_map, &self->handle);
1035     g_hash_table_remove(window_map, &self->lgrip);
1036     g_hash_table_remove(window_map, &self->rgrip);
1037     g_hash_table_remove(window_map, &self->topresize);
1038     g_hash_table_remove(window_map, &self->tltresize);
1039     g_hash_table_remove(window_map, &self->tllresize);
1040     g_hash_table_remove(window_map, &self->trtresize);
1041     g_hash_table_remove(window_map, &self->trrresize);
1042     g_hash_table_remove(window_map, &self->left);
1043     g_hash_table_remove(window_map, &self->right);
1044     g_hash_table_remove(window_map, &self->titleleft);
1045     g_hash_table_remove(window_map, &self->titletop);
1046     g_hash_table_remove(window_map, &self->titletopleft);
1047     g_hash_table_remove(window_map, &self->titletopright);
1048     g_hash_table_remove(window_map, &self->titleright);
1049     g_hash_table_remove(window_map, &self->titlebottom);
1050     g_hash_table_remove(window_map, &self->handleleft);
1051     g_hash_table_remove(window_map, &self->handletop);
1052     g_hash_table_remove(window_map, &self->handleright);
1053     g_hash_table_remove(window_map, &self->handlebottom);
1054     g_hash_table_remove(window_map, &self->lgripleft);
1055     g_hash_table_remove(window_map, &self->lgriptop);
1056     g_hash_table_remove(window_map, &self->lgripbottom);
1057     g_hash_table_remove(window_map, &self->rgripright);
1058     g_hash_table_remove(window_map, &self->rgriptop);
1059     g_hash_table_remove(window_map, &self->rgripbottom);
1060
1061     ob_main_loop_timeout_remove_data(ob_main_loop, flash_timeout, self, TRUE);
1062 }
1063
1064 /* is there anything present between us and the label? */
1065 static gboolean is_button_present(ObFrame *self, const gchar *lc, gint dir) {
1066     for (; *lc != '\0' && lc >= config_title_layout; lc += dir) {
1067         if (*lc == ' ') continue; /* it was invalid */
1068         if (*lc == 'N' && self->decorations & OB_FRAME_DECOR_ICON)
1069             return TRUE;
1070         if (*lc == 'D' && self->decorations & OB_FRAME_DECOR_ALLDESKTOPS)
1071             return TRUE;
1072         if (*lc == 'S' && self->decorations & OB_FRAME_DECOR_SHADE)
1073             return TRUE;
1074         if (*lc == 'I' && self->decorations & OB_FRAME_DECOR_ICONIFY)
1075             return TRUE;
1076         if (*lc == 'M' && self->decorations & OB_FRAME_DECOR_MAXIMIZE)
1077             return TRUE;
1078         if (*lc == 'C' && self->decorations & OB_FRAME_DECOR_CLOSE)
1079             return TRUE;
1080         if (*lc == 'L') return FALSE;
1081     }
1082     return FALSE;
1083 }
1084
1085 static void layout_title(ObFrame *self)
1086 {
1087     gchar *lc;
1088     gint i;
1089
1090     const gint bwidth = ob_rr_theme->button_size + ob_rr_theme->paddingx + 1;
1091     /* position of the left most button */
1092     const gint left = ob_rr_theme->paddingx + 1;
1093     /* position of the right most button */
1094     const gint right = self->width;
1095
1096     /* turn them all off */
1097     self->icon_on = self->desk_on = self->shade_on = self->iconify_on =
1098         self->max_on = self->close_on = self->label_on = FALSE;
1099     self->label_width = self->width - (ob_rr_theme->paddingx + 1) * 2;
1100     self->leftmost = self->rightmost = OB_FRAME_CONTEXT_NONE;
1101
1102     /* figure out what's being show, find each element's position, and the
1103        width of the label
1104
1105        do the ones before the label, then after the label,
1106        i will be +1 the first time through when working to the left,
1107        and -1 the second time through when working to the right */
1108     for (i = 1; i >= -1; i-=2) {
1109         gint x;
1110         ObFrameContext *firstcon;
1111
1112         if (i > 0) {
1113             x = left;
1114             lc = config_title_layout;
1115             firstcon = &self->leftmost;
1116         } else {
1117             x = right;
1118             lc = config_title_layout + strlen(config_title_layout)-1;
1119             firstcon = &self->rightmost;
1120         }
1121
1122         /* stop at the end of the string (or the label, which calls break) */
1123         for (; *lc != '\0' && lc >= config_title_layout; lc+=i) {
1124             if (*lc == 'L') {
1125                 if (i > 0) {
1126                     self->label_on = TRUE;
1127                     self->label_x = x;
1128                 }
1129                 break; /* break the for loop, do other side of label */
1130             } else if (*lc == 'N') {
1131                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICON;
1132                 if ((self->icon_on = is_button_present(self, lc, i))) {
1133                     /* icon is bigger than buttons */
1134                     self->label_width -= bwidth + 2;
1135                     if (i > 0) self->icon_x = x;
1136                     x += i * (bwidth + 2);
1137                     if (i < 0) self->icon_x = x;
1138                 }
1139             } else if (*lc == 'D') {
1140                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ALLDESKTOPS;
1141                 if ((self->desk_on = is_button_present(self, lc, i))) {
1142                     self->label_width -= bwidth;
1143                     if (i > 0) self->desk_x = x;
1144                     x += i * bwidth;
1145                     if (i < 0) self->desk_x = x;
1146                 }
1147             } else if (*lc == 'S') {
1148                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_SHADE;
1149                 if ((self->shade_on = is_button_present(self, lc, i))) {
1150                     self->label_width -= bwidth;
1151                     if (i > 0) self->shade_x = x;
1152                     x += i * bwidth;
1153                     if (i < 0) self->shade_x = x;
1154                 }
1155             } else if (*lc == 'I') {
1156                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICONIFY;
1157                 if ((self->iconify_on = is_button_present(self, lc, i))) {
1158                     self->label_width -= bwidth;
1159                     if (i > 0) self->iconify_x = x;
1160                     x += i * bwidth;
1161                     if (i < 0) self->iconify_x = x;
1162                 }
1163             } else if (*lc == 'M') {
1164                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_MAXIMIZE;
1165                 if ((self->max_on = is_button_present(self, lc, i))) {
1166                     self->label_width -= bwidth;
1167                     if (i > 0) self->max_x = x;
1168                     x += i * bwidth;
1169                     if (i < 0) self->max_x = x;
1170                 }
1171             } else if (*lc == 'C') {
1172                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_CLOSE;
1173                 if ((self->close_on = is_button_present(self, lc, i))) {
1174                     self->label_width -= bwidth;
1175                     if (i > 0) self->close_x = x;
1176                     x += i * bwidth;
1177                     if (i < 0) self->close_x = x;
1178                 }
1179             } else
1180                 continue; /* don't set firstcon */
1181             firstcon = NULL;
1182         }
1183     }
1184
1185     /* position and map the elements */
1186     if (self->icon_on) {
1187         XMapWindow(ob_display, self->icon);
1188         XMoveWindow(ob_display, self->icon, self->icon_x,
1189                     ob_rr_theme->paddingy);
1190     } else
1191         XUnmapWindow(ob_display, self->icon);
1192
1193     if (self->desk_on) {
1194         XMapWindow(ob_display, self->desk);
1195         XMoveWindow(ob_display, self->desk, self->desk_x,
1196                     ob_rr_theme->paddingy + 1);
1197     } else
1198         XUnmapWindow(ob_display, self->desk);
1199
1200     if (self->shade_on) {
1201         XMapWindow(ob_display, self->shade);
1202         XMoveWindow(ob_display, self->shade, self->shade_x,
1203                     ob_rr_theme->paddingy + 1);
1204     } else
1205         XUnmapWindow(ob_display, self->shade);
1206
1207     if (self->iconify_on) {
1208         XMapWindow(ob_display, self->iconify);
1209         XMoveWindow(ob_display, self->iconify, self->iconify_x,
1210                     ob_rr_theme->paddingy + 1);
1211     } else
1212         XUnmapWindow(ob_display, self->iconify);
1213
1214     if (self->max_on) {
1215         XMapWindow(ob_display, self->max);
1216         XMoveWindow(ob_display, self->max, self->max_x,
1217                     ob_rr_theme->paddingy + 1);
1218     } else
1219         XUnmapWindow(ob_display, self->max);
1220
1221     if (self->close_on) {
1222         XMapWindow(ob_display, self->close);
1223         XMoveWindow(ob_display, self->close, self->close_x,
1224                     ob_rr_theme->paddingy + 1);
1225     } else
1226         XUnmapWindow(ob_display, self->close);
1227
1228     if (self->label_on) {
1229         self->label_width = MAX(1, self->label_width); /* no lower than 1 */
1230         XMapWindow(ob_display, self->label);
1231         XMoveWindow(ob_display, self->label, self->label_x,
1232                     ob_rr_theme->paddingy);
1233     } else
1234         XUnmapWindow(ob_display, self->label);
1235 }
1236
1237 ObFrameContext frame_context_from_string(const gchar *name)
1238 {
1239     if (!g_ascii_strcasecmp("Desktop", name))
1240         return OB_FRAME_CONTEXT_DESKTOP;
1241     else if (!g_ascii_strcasecmp("Root", name))
1242         return OB_FRAME_CONTEXT_ROOT;
1243     else if (!g_ascii_strcasecmp("Client", name))
1244         return OB_FRAME_CONTEXT_CLIENT;
1245     else if (!g_ascii_strcasecmp("Titlebar", name))
1246         return OB_FRAME_CONTEXT_TITLEBAR;
1247     else if (!g_ascii_strcasecmp("Frame", name))
1248         return OB_FRAME_CONTEXT_FRAME;
1249     else if (!g_ascii_strcasecmp("TLCorner", name))
1250         return OB_FRAME_CONTEXT_TLCORNER;
1251     else if (!g_ascii_strcasecmp("TRCorner", name))
1252         return OB_FRAME_CONTEXT_TRCORNER;
1253     else if (!g_ascii_strcasecmp("BLCorner", name))
1254         return OB_FRAME_CONTEXT_BLCORNER;
1255     else if (!g_ascii_strcasecmp("BRCorner", name))
1256         return OB_FRAME_CONTEXT_BRCORNER;
1257     else if (!g_ascii_strcasecmp("Top", name))
1258         return OB_FRAME_CONTEXT_TOP;
1259     else if (!g_ascii_strcasecmp("Bottom", name))
1260         return OB_FRAME_CONTEXT_BOTTOM;
1261     else if (!g_ascii_strcasecmp("Left", name))
1262         return OB_FRAME_CONTEXT_LEFT;
1263     else if (!g_ascii_strcasecmp("Right", name))
1264         return OB_FRAME_CONTEXT_RIGHT;
1265     else if (!g_ascii_strcasecmp("Maximize", name))
1266         return OB_FRAME_CONTEXT_MAXIMIZE;
1267     else if (!g_ascii_strcasecmp("AllDesktops", name))
1268         return OB_FRAME_CONTEXT_ALLDESKTOPS;
1269     else if (!g_ascii_strcasecmp("Shade", name))
1270         return OB_FRAME_CONTEXT_SHADE;
1271     else if (!g_ascii_strcasecmp("Iconify", name))
1272         return OB_FRAME_CONTEXT_ICONIFY;
1273     else if (!g_ascii_strcasecmp("Icon", name))
1274         return OB_FRAME_CONTEXT_ICON;
1275     else if (!g_ascii_strcasecmp("Close", name))
1276         return OB_FRAME_CONTEXT_CLOSE;
1277     else if (!g_ascii_strcasecmp("MoveResize", name))
1278         return OB_FRAME_CONTEXT_MOVE_RESIZE;
1279     return OB_FRAME_CONTEXT_NONE;
1280 }
1281
1282 ObFrameContext frame_context(ObClient *client, Window win, gint x, gint y)
1283 {
1284     ObFrame *self;
1285
1286     if (moveresize_in_progress)
1287         return OB_FRAME_CONTEXT_MOVE_RESIZE;
1288
1289     if (win == RootWindow(ob_display, ob_screen))
1290         return OB_FRAME_CONTEXT_ROOT ;
1291     if (client == NULL) return OB_FRAME_CONTEXT_NONE;
1292     if (win == client->window) {
1293         /* conceptually, this is the desktop, as far as users are
1294            concerned */
1295         if (client->type == OB_CLIENT_TYPE_DESKTOP)
1296             return OB_FRAME_CONTEXT_DESKTOP;
1297         return OB_FRAME_CONTEXT_CLIENT;
1298     }
1299
1300     self = client->frame;
1301
1302     /* when the user clicks in the corners of the titlebar and the client
1303        is fully maximized, then treat it like they clicked in the
1304        button that is there */
1305     if (self->max_horz && self->max_vert &&
1306         (win == self->title || win == self->titletop ||
1307          win == self->titleleft || win == self->titletopleft ||
1308          win == self->titleright || win == self->titletopright))
1309     {
1310         /* get the mouse coords in reference to the whole frame */
1311         gint fx = x;
1312         gint fy = y;
1313
1314         /* these windows are down a border width from the top of the frame */
1315         if (win == self->title ||
1316             win == self->titleleft || win == self->titleright)
1317             fy += self->bwidth;
1318
1319         /* title is a border width in from the edge */
1320         if (win == self->title)
1321             fx += self->bwidth;
1322         /* titletop is a bit to the right */
1323         else if (win == self->titletop)
1324             fx += ob_rr_theme->grip_width + self->bwidth;
1325         /* titletopright is way to the right edge */
1326         else if (win == self->titletopright)
1327             fx += self->area.width - (ob_rr_theme->grip_width + self->bwidth);
1328         /* titleright is even more way to the right edge */
1329         else if (win == self->titleright)
1330             fx += self->area.width - self->bwidth;
1331
1332         /* figure out if we're over the area that should be considered a
1333            button */
1334         if (fy < self->bwidth + ob_rr_theme->paddingy + 1 +
1335             ob_rr_theme->button_size)
1336         {
1337             if (fx < (self->bwidth + ob_rr_theme->paddingx + 1 +
1338                       ob_rr_theme->button_size))
1339             {
1340                 if (self->leftmost != OB_FRAME_CONTEXT_NONE)
1341                     return self->leftmost;
1342             }
1343             else if (fx >= (self->area.width -
1344                             (self->bwidth + ob_rr_theme->paddingx + 1 +
1345                              ob_rr_theme->button_size)))
1346             {
1347                 if (self->rightmost != OB_FRAME_CONTEXT_NONE)
1348                     return self->rightmost;
1349             }
1350         }
1351
1352         /* there is no resizing maximized windows so make them the titlebar
1353            context */
1354         return OB_FRAME_CONTEXT_TITLEBAR;
1355     }
1356     else if (self->max_vert &&
1357              (win == self->titletop || win == self->topresize))
1358         /* can't resize vertically when max vert */
1359         return OB_FRAME_CONTEXT_TITLEBAR;
1360     else if (self->shaded &&
1361              (win == self->titletop || win == self->topresize))
1362         /* can't resize vertically when shaded */
1363         return OB_FRAME_CONTEXT_TITLEBAR;
1364
1365     if (win == self->window)            return OB_FRAME_CONTEXT_FRAME;
1366     if (win == self->label)             return OB_FRAME_CONTEXT_TITLEBAR;
1367     if (win == self->handle)            return OB_FRAME_CONTEXT_BOTTOM;
1368     if (win == self->handletop)         return OB_FRAME_CONTEXT_BOTTOM;
1369     if (win == self->handlebottom)      return OB_FRAME_CONTEXT_BOTTOM;
1370     if (win == self->handleleft)        return OB_FRAME_CONTEXT_BLCORNER;
1371     if (win == self->lgrip)             return OB_FRAME_CONTEXT_BLCORNER;
1372     if (win == self->lgripleft)         return OB_FRAME_CONTEXT_BLCORNER;
1373     if (win == self->lgriptop)          return OB_FRAME_CONTEXT_BLCORNER;
1374     if (win == self->lgripbottom)       return OB_FRAME_CONTEXT_BLCORNER;
1375     if (win == self->handleright)       return OB_FRAME_CONTEXT_BRCORNER;
1376     if (win == self->rgrip)             return OB_FRAME_CONTEXT_BRCORNER;
1377     if (win == self->rgripright)        return OB_FRAME_CONTEXT_BLCORNER;
1378     if (win == self->rgriptop)          return OB_FRAME_CONTEXT_BLCORNER;
1379     if (win == self->rgripbottom)       return OB_FRAME_CONTEXT_BLCORNER;
1380     if (win == self->title)             return OB_FRAME_CONTEXT_TITLEBAR;
1381     if (win == self->titlebottom)       return OB_FRAME_CONTEXT_TITLEBAR;
1382     if (win == self->titleleft)         return OB_FRAME_CONTEXT_TLCORNER;
1383     if (win == self->titletopleft)      return OB_FRAME_CONTEXT_TLCORNER;
1384     if (win == self->titleright)        return OB_FRAME_CONTEXT_TRCORNER;
1385     if (win == self->titletopright)     return OB_FRAME_CONTEXT_TRCORNER;
1386     if (win == self->titletop)          return OB_FRAME_CONTEXT_TOP;
1387     if (win == self->topresize)         return OB_FRAME_CONTEXT_TOP;
1388     if (win == self->tltresize)         return OB_FRAME_CONTEXT_TLCORNER;
1389     if (win == self->tllresize)         return OB_FRAME_CONTEXT_TLCORNER;
1390     if (win == self->trtresize)         return OB_FRAME_CONTEXT_TRCORNER;
1391     if (win == self->trrresize)         return OB_FRAME_CONTEXT_TRCORNER;
1392     if (win == self->left)              return OB_FRAME_CONTEXT_LEFT;
1393     if (win == self->right)             return OB_FRAME_CONTEXT_RIGHT;
1394     if (win == self->innertop)          return OB_FRAME_CONTEXT_TITLEBAR;
1395     if (win == self->innerleft)         return OB_FRAME_CONTEXT_LEFT;
1396     if (win == self->innerbottom)       return OB_FRAME_CONTEXT_BOTTOM;
1397     if (win == self->innerright)        return OB_FRAME_CONTEXT_RIGHT;
1398     if (win == self->max)               return OB_FRAME_CONTEXT_MAXIMIZE;
1399     if (win == self->iconify)           return OB_FRAME_CONTEXT_ICONIFY;
1400     if (win == self->close)             return OB_FRAME_CONTEXT_CLOSE;
1401     if (win == self->icon)              return OB_FRAME_CONTEXT_ICON;
1402     if (win == self->desk)              return OB_FRAME_CONTEXT_ALLDESKTOPS;
1403     if (win == self->shade)             return OB_FRAME_CONTEXT_SHADE;
1404
1405     return OB_FRAME_CONTEXT_NONE;
1406 }
1407
1408 void frame_client_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
1409 {
1410     /* horizontal */
1411     switch (self->client->gravity) {
1412     default:
1413     case NorthWestGravity:
1414     case SouthWestGravity:
1415     case WestGravity:
1416         break;
1417
1418     case NorthGravity:
1419     case SouthGravity:
1420     case CenterGravity:
1421         /* the middle of the client will be the middle of the frame */
1422         *x -= (self->size.right - self->size.left) / 2;
1423         break;
1424
1425     case NorthEastGravity:
1426     case SouthEastGravity:
1427     case EastGravity:
1428         /* the right side of the client will be the right side of the frame */
1429         *x -= self->size.right + self->size.left -
1430             self->client->border_width * 2;
1431         break;
1432
1433     case ForgetGravity:
1434     case StaticGravity:
1435         /* the client's position won't move */
1436         *x -= self->size.left - self->client->border_width;
1437         break;
1438     }
1439
1440     /* vertical */
1441     switch (self->client->gravity) {
1442     default:
1443     case NorthWestGravity:
1444     case NorthEastGravity:
1445     case NorthGravity:
1446         break;
1447
1448     case CenterGravity:
1449     case EastGravity:
1450     case WestGravity:
1451         /* the middle of the client will be the middle of the frame */
1452         *y -= (self->size.bottom - self->size.top) / 2;
1453         break;
1454
1455     case SouthWestGravity:
1456     case SouthEastGravity:
1457     case SouthGravity:
1458         /* the bottom of the client will be the bottom of the frame */
1459         *y -= self->size.bottom + self->size.top -
1460             self->client->border_width * 2;
1461         break;
1462
1463     case ForgetGravity:
1464     case StaticGravity:
1465         /* the client's position won't move */
1466         *y -= self->size.top - self->client->border_width;
1467         break;
1468     }
1469 }
1470
1471 void frame_frame_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
1472 {
1473     /* horizontal */
1474     switch (self->client->gravity) {
1475     default:
1476     case NorthWestGravity:
1477     case WestGravity:
1478     case SouthWestGravity:
1479         break;
1480     case NorthGravity:
1481     case CenterGravity:
1482     case SouthGravity:
1483         /* the middle of the client will be the middle of the frame */
1484         *x += (self->size.right - self->size.left) / 2;
1485         break;
1486     case NorthEastGravity:
1487     case EastGravity:
1488     case SouthEastGravity:
1489         /* the right side of the client will be the right side of the frame */
1490         *x += self->size.right + self->size.left -
1491             self->client->border_width * 2;
1492         break;
1493     case StaticGravity:
1494     case ForgetGravity:
1495         /* the client's position won't move */
1496         *x += self->size.left - self->client->border_width;
1497         break;
1498     }
1499
1500     /* vertical */
1501     switch (self->client->gravity) {
1502     default:
1503     case NorthWestGravity:
1504     case NorthGravity:
1505     case NorthEastGravity:
1506         break;
1507     case WestGravity:
1508     case CenterGravity:
1509     case EastGravity:
1510         /* the middle of the client will be the middle of the frame */
1511         *y += (self->size.bottom - self->size.top) / 2;
1512         break;
1513     case SouthWestGravity:
1514     case SouthGravity:
1515     case SouthEastGravity:
1516         /* the bottom of the client will be the bottom of the frame */
1517         *y += self->size.bottom + self->size.top -
1518             self->client->border_width * 2;
1519         break;
1520     case StaticGravity:
1521     case ForgetGravity:
1522         /* the client's position won't move */
1523         *y += self->size.top - self->client->border_width;
1524         break;
1525     }
1526 }
1527
1528 void frame_rect_to_frame(ObFrame *self, Rect *r)
1529 {
1530     r->width += self->size.left + self->size.right;
1531     r->height += self->size.top + self->size.bottom;
1532     frame_client_gravity(self, &r->x, &r->y, r->width, r->height);
1533 }
1534
1535 static void flash_done(gpointer data)
1536 {
1537     ObFrame *self = data;
1538
1539     if (self->focused != self->flash_on)
1540         frame_adjust_focus(self, self->focused);
1541 }
1542
1543 static gboolean flash_timeout(gpointer data)
1544 {
1545     ObFrame *self = data;
1546     GTimeVal now;
1547
1548     g_get_current_time(&now);
1549     if (now.tv_sec > self->flash_end.tv_sec ||
1550         (now.tv_sec == self->flash_end.tv_sec &&
1551          now.tv_usec >= self->flash_end.tv_usec))
1552         self->flashing = FALSE;
1553
1554     if (!self->flashing)
1555         return FALSE; /* we are done */
1556
1557     self->flash_on = !self->flash_on;
1558     if (!self->focused) {
1559         frame_adjust_focus(self, self->flash_on);
1560         self->focused = FALSE;
1561     }
1562
1563     return TRUE; /* go again */
1564 }
1565
1566 void frame_flash_start(ObFrame *self)
1567 {
1568     self->flash_on = self->focused;
1569
1570     if (!self->flashing)
1571         ob_main_loop_timeout_add(ob_main_loop,
1572                                  G_USEC_PER_SEC * 0.6,
1573                                  flash_timeout,
1574                                  self,
1575                                  g_direct_equal,
1576                                  flash_done);
1577     g_get_current_time(&self->flash_end);
1578     g_time_val_add(&self->flash_end, G_USEC_PER_SEC * 5);
1579
1580     self->flashing = TRUE;
1581 }
1582
1583 void frame_flash_stop(ObFrame *self)
1584 {
1585     self->flashing = FALSE;
1586 }
1587
1588 static gulong frame_animate_iconify_time_left(ObFrame *self,
1589                                               const GTimeVal *now)
1590 {
1591     glong sec, usec;
1592     sec = self->iconify_animation_end.tv_sec - now->tv_sec;
1593     usec = self->iconify_animation_end.tv_usec - now->tv_usec;
1594     if (usec < 0) {
1595         usec += G_USEC_PER_SEC;
1596         sec--;
1597     }
1598     /* no negative values */
1599     return MAX(sec * G_USEC_PER_SEC + usec, 0);
1600 }
1601
1602 static gboolean frame_animate_iconify(gpointer p)
1603 {
1604     ObFrame *self = p;
1605     gint x, y, w, h;
1606     gint iconx, icony, iconw;
1607     GTimeVal now;
1608     gulong time;
1609     gboolean iconifying;
1610
1611     if (self->client->icon_geometry.width == 0) {
1612         /* there is no icon geometry set so just go straight down */
1613         Rect *a = screen_physical_area_monitor
1614             (screen_find_monitor(&self->area));
1615         iconx = self->area.x + self->area.width / 2 + 32;
1616         icony = a->y + a->width;
1617         iconw = 64;
1618         g_free(a);
1619     } else {
1620         iconx = self->client->icon_geometry.x;
1621         icony = self->client->icon_geometry.y;
1622         iconw = self->client->icon_geometry.width;
1623     }
1624
1625     iconifying = self->iconify_animation_going > 0;
1626
1627     /* how far do we have left to go ? */
1628     g_get_current_time(&now);
1629     time = frame_animate_iconify_time_left(self, &now);
1630
1631     if (time == 0 || iconifying) {
1632         /* start where the frame is supposed to be */
1633         x = self->area.x;
1634         y = self->area.y;
1635         w = self->area.width;
1636         h = self->area.height;
1637     } else {
1638         /* start at the icon */
1639         x = iconx;
1640         y = icony;
1641         w = iconw;
1642         h = self->size.top; /* just the titlebar */
1643     }
1644
1645     if (time > 0) {
1646         glong dx, dy, dw;
1647         glong elapsed;
1648
1649         dx = self->area.x - iconx;
1650         dy = self->area.y - icony;
1651         dw = self->area.width - self->bwidth * 2 - iconw;
1652          /* if restoring, we move in the opposite direction */
1653         if (!iconifying) { dx = -dx; dy = -dy; dw = -dw; }
1654
1655         elapsed = FRAME_ANIMATE_ICONIFY_TIME - time;
1656         x = x - (dx * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
1657         y = y - (dy * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
1658         w = w - (dw * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
1659         h = self->size.top; /* just the titlebar */
1660     }
1661
1662     if (time == 0)
1663         frame_end_iconify_animation(self);
1664     else {
1665         XMoveResizeWindow(ob_display, self->window, x, y, w, h);
1666         XFlush(ob_display);
1667     }
1668
1669     return time > 0; /* repeat until we're out of time */
1670 }
1671
1672 void frame_end_iconify_animation(ObFrame *self)
1673 {
1674     /* see if there is an animation going */
1675     if (self->iconify_animation_going == 0) return;
1676
1677     if (!self->visible)
1678         XUnmapWindow(ob_display, self->window);
1679     else {
1680         /* Send a ConfigureNotify when the animation is done, this fixes
1681            KDE's pager showing the window in the wrong place. */
1682         client_reconfigure(self->client, TRUE);
1683
1684         /* the offscreen buffer is invalid when the window is resized */
1685         frame_get_offscreen_buffer(self);
1686     }
1687
1688     /* we're not animating any more ! */
1689     self->iconify_animation_going = 0;
1690
1691     XMoveResizeWindow(ob_display, self->window,
1692                       self->area.x, self->area.y,
1693                       self->area.width, self->area.height);
1694     /* we delay re-rendering until after we're done animating */
1695     framerender_frame(self);
1696     XFlush(ob_display);
1697 }
1698
1699 void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying)
1700 {
1701     gulong time;
1702     gboolean new_anim = FALSE;
1703     gboolean set_end = TRUE;
1704     GTimeVal now;
1705
1706     /* if there is no titlebar, just don't animate for now
1707        XXX it would be nice tho.. */
1708     if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1709         return;
1710
1711     /* get the current time */
1712     g_get_current_time(&now);
1713
1714     /* get how long until the end */
1715     time = FRAME_ANIMATE_ICONIFY_TIME;
1716     if (self->iconify_animation_going) {
1717         if (!!iconifying != (self->iconify_animation_going > 0)) {
1718             /* animation was already going on in the opposite direction */
1719             time = time - frame_animate_iconify_time_left(self, &now);
1720         } else
1721             /* animation was already going in the same direction */
1722             set_end = FALSE;
1723     } else
1724         new_anim = TRUE;
1725     self->iconify_animation_going = iconifying ? 1 : -1;
1726
1727     /* set the ending time */
1728     if (set_end) {
1729         self->iconify_animation_end.tv_sec = now.tv_sec;
1730         self->iconify_animation_end.tv_usec = now.tv_usec;
1731         g_time_val_add(&self->iconify_animation_end, time);
1732     }
1733
1734     if (new_anim) {
1735         ob_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
1736                                          self, FALSE);
1737         ob_main_loop_timeout_add(ob_main_loop,
1738                                  FRAME_ANIMATE_ICONIFY_STEP_TIME,
1739                                  frame_animate_iconify, self,
1740                                  g_direct_equal, NULL);
1741
1742         /* do the first step */
1743         frame_animate_iconify(self);
1744
1745         /* show it during the animation even if it is not "visible" */
1746         if (!self->visible)
1747             XMapWindow(ob_display, self->window);
1748     }
1749 }
1750
1751 static void frame_get_offscreen_buffer(ObFrame *self)
1752 {
1753     frame_free_offscreen_buffer(self);
1754
1755     if (self->visible || frame_iconify_animating(self)) {
1756         self->pixmap = composite_get_window_pixmap(self->window);
1757         /*
1758           self->picture = composite_create_picture(self->window,
1759           wattrib.visual,
1760           &self->has_alpha);
1761         */
1762     }
1763
1764 }
1765
1766 static void frame_free_offscreen_buffer(ObFrame *self)
1767 {
1768     if (self->pixmap) {
1769         XFreePixmap(ob_display, self->pixmap);
1770         self->pixmap = None;
1771     }
1772 }