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.h"
  29 #include "moveresize.h"
  30 #include "screen.h"
  31 #include "render/theme.h"
  32
  33 #define PLATE_EVENTMASK (SubstructureRedirectMask | FocusChangeMask)
  34 #define FRAME_EVENTMASK (EnterWindowMask | LeaveWindowMask | \
  35                          ButtonPressMask | ButtonReleaseMask)
  36 #define ELEMENT_EVENTMASK (ButtonPressMask | ButtonReleaseMask | \
  37                            ButtonMotionMask | PointerMotionMask | \
  38                            EnterWindowMask | LeaveWindowMask)
  39 /* The inner window does not need enter/leave events.
  40    If it does get them, then it needs its own context for enter events
  41    because sloppy focus will focus the window when you enter the inner window
  42    from the frame. */
  43 #define INNER_EVENTMASK (ButtonPressMask)
  44
  45 #define FRAME_ANIMATE_ICONIFY_TIME 150000 /* .15 seconds */
  46 #define FRAME_ANIMATE_ICONIFY_STEP_TIME (G_USEC_PER_SEC / 60) /* 60 Hz */
  47
  48 #define FRAME_HANDLE_Y(f) (f->innersize.top + f->client->area.height + \
  49                            f->cbwidth_y)
  50
  51 /* the offsets for the titlebar elements from the edge of the titlebar.
  52    negative means from the right edge. */
  53 gint icon_off;
  54 gint label_off;
  55 gint iconify_off;
  56 gint desk_off;
  57 gint shade_off;
  58 gint max_off;
  59 gint close_off;
  60
  61
  62 static void flash_done(gpointer data);
  63 static gboolean flash_timeout(gpointer data);
  64
  65 static void layout_title(ObFrame *self);
  66 static void set_theme_statics(ObFrame *self);
  67 static void free_theme_statics(ObFrame *self);
  68 static gboolean frame_animate_iconify(gpointer self);
  69
  70 static Window createWindow(Window parent, Visual *visual,
  71                            gulong mask, XSetWindowAttributes *attrib)
  72 {
  73     return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
  74                          (visual ? 32 : RrDepth(ob_rr_inst)), InputOutput,
  75                          (visual ? visual : RrVisual(ob_rr_inst)),
  76                          mask, attrib);
  77
  78 }
  79
  80 static Visual *check_32bit_client(ObClient *c)
  81 {
  82     XWindowAttributes wattrib;
  83     Status ret;
  84
  85     ret = XGetWindowAttributes(ob_display, c->window, &wattrib);
  86     g_assert(ret != BadDrawable);
  87     g_assert(ret != BadWindow);
  88
  89     if (wattrib.depth == 32)
  90         return wattrib.visual;
  91     return NULL;
  92 }
  93
  94 ObFrame *frame_new(ObClient *client)
  95 {
  96     XSetWindowAttributes attrib;
  97     gulong mask;
  98     ObFrame *self;
  99     Visual *visual;
 100
 101     self = g_new0(ObFrame, 1);
 102     self->client = client;
 103
 104     visual = check_32bit_client(client);
 105
 106     /* create the non-visible decor windows */
 107
 108     mask = CWEventMask;
 109     if (visual) {
 110         /* client has a 32-bit visual */
 111         mask |= CWColormap | CWBackPixel | CWBorderPixel;
 112         /* create a colormap with the visual */
 113         self->colormap = attrib.colormap =
 114             XCreateColormap(ob_display,
 115                             RootWindow(ob_display, ob_screen),
 116                             visual, AllocNone);
 117         attrib.background_pixel = BlackPixel(ob_display, 0);
 118         attrib.border_pixel = BlackPixel(ob_display, 0);
 119     }
 120     attrib.event_mask = FRAME_EVENTMASK;
 121     self->window = createWindow(RootWindow(ob_display, ob_screen), visual,
 122                                 mask, &attrib);
 123
 124     attrib.event_mask = INNER_EVENTMASK;
 125     self->inner = createWindow(self->window, visual, mask, &attrib);
 126
 127     mask &= ~CWEventMask;
 128     self->plate = createWindow(self->inner, visual, mask, &attrib);
 129
 130     /* create the visible decor windows */
 131
 132     mask = CWEventMask;
 133     if (visual) {
 134         /* client has a 32-bit visual */
 135         mask |= CWColormap | CWBackPixel | CWBorderPixel;
 136         attrib.colormap = RrColormap(ob_rr_inst);
 137     }
 138     attrib.event_mask = ELEMENT_EVENTMASK;
 139     self->title = createWindow(self->window, NULL, mask, &attrib);
 140
 141     mask |= CWCursor;
 142     attrib.cursor = ob_cursor(OB_CURSOR_NORTHWEST);
 143     self->tltresize = createWindow(self->title, NULL, mask, &attrib);
 144     self->tllresize = createWindow(self->title, NULL, mask, &attrib);
 145     attrib.cursor = ob_cursor(OB_CURSOR_NORTHEAST);
 146     self->trtresize = createWindow(self->title, NULL, mask, &attrib);
 147     self->trrresize = createWindow(self->title, NULL, mask, &attrib);
 148
 149     mask &= ~CWCursor;
 150     self->label = createWindow(self->title, NULL, mask, &attrib);
 151     self->max = createWindow(self->title, NULL, mask, &attrib);
 152     self->close = createWindow(self->title, NULL, mask, &attrib);
 153     self->desk = createWindow(self->title, NULL, mask, &attrib);
 154     self->shade = createWindow(self->title, NULL, mask, &attrib);
 155     self->icon = createWindow(self->title, NULL, mask, &attrib);
 156     self->iconify = createWindow(self->title, NULL, mask, &attrib);
 157     self->handle = createWindow(self->window, NULL, mask, &attrib);
 158
 159     mask |= CWCursor;
 160     attrib.cursor = ob_cursor(OB_CURSOR_SOUTHWEST);
 161     self->lgrip = createWindow(self->handle, NULL, mask, &attrib);
 162     attrib.cursor = ob_cursor(OB_CURSOR_SOUTHEAST);
 163     self->rgrip = createWindow(self->handle, NULL, mask, &attrib);
 164
 165     self->focused = FALSE;
 166
 167     /* the other stuff is shown based on decor settings */
 168     XMapWindow(ob_display, self->plate);
 169     XMapWindow(ob_display, self->inner);
 170     XMapWindow(ob_display, self->lgrip);
 171     XMapWindow(ob_display, self->rgrip);
 172     XMapWindow(ob_display, self->label);
 173
 174     self->max_press = self->close_press = self->desk_press =
 175         self->iconify_press = self->shade_press = FALSE;
 176     self->max_hover = self->close_hover = self->desk_hover =
 177         self->iconify_hover = self->shade_hover = FALSE;
 178
 179     set_theme_statics(self);
 180
 181     return (ObFrame*)self;
 182 }
 183
 184 static void set_theme_statics(ObFrame *self)
 185 {
 186     /* set colors/appearance/sizes for stuff that doesn't change */
 187     XSetWindowBorder(ob_display, self->window,
 188                      RrColorPixel(ob_rr_theme->frame_b_color));
 189     XSetWindowBorder(ob_display, self->inner,
 190                      RrColorPixel(ob_rr_theme->frame_b_color));
 191     XSetWindowBorder(ob_display, self->title,
 192                      RrColorPixel(ob_rr_theme->frame_b_color));
 193     XSetWindowBorder(ob_display, self->handle,
 194                      RrColorPixel(ob_rr_theme->frame_b_color));
 195     XSetWindowBorder(ob_display, self->rgrip,
 196                      RrColorPixel(ob_rr_theme->frame_b_color));
 197     XSetWindowBorder(ob_display, self->lgrip,
 198                      RrColorPixel(ob_rr_theme->frame_b_color));
 199
 200     XResizeWindow(ob_display, self->max,
 201                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 202     XResizeWindow(ob_display, self->iconify,
 203                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 204     XResizeWindow(ob_display, self->icon,
 205                   ob_rr_theme->button_size + 2, ob_rr_theme->button_size + 2);
 206     XResizeWindow(ob_display, self->close,
 207                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 208     XResizeWindow(ob_display, self->desk,
 209                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 210     XResizeWindow(ob_display, self->shade,
 211                   ob_rr_theme->button_size, ob_rr_theme->button_size);
 212     if (ob_rr_theme->handle_height > 0) {
 213         XResizeWindow(ob_display, self->lgrip,
 214                       ob_rr_theme->grip_width, ob_rr_theme->handle_height);
 215         XResizeWindow(ob_display, self->rgrip,
 216                       ob_rr_theme->grip_width, ob_rr_theme->handle_height);
 217     }
 218     XResizeWindow(ob_display, self->tltresize,
 219                   ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);
 220     XResizeWindow(ob_display, self->trtresize,
 221                   ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);
 222     XResizeWindow(ob_display, self->tllresize,
 223                   ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
 224     XResizeWindow(ob_display, self->trrresize,
 225                   ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
 226
 227     /* set up the dynamic appearances */
 228     self->a_unfocused_title = RrAppearanceCopy(ob_rr_theme->a_unfocused_title);
 229     self->a_focused_title = RrAppearanceCopy(ob_rr_theme->a_focused_title);
 230     self->a_unfocused_label = RrAppearanceCopy(ob_rr_theme->a_unfocused_label);
 231     self->a_focused_label = RrAppearanceCopy(ob_rr_theme->a_focused_label);
 232     self->a_unfocused_handle =
 233         RrAppearanceCopy(ob_rr_theme->a_unfocused_handle);
 234     self->a_focused_handle = RrAppearanceCopy(ob_rr_theme->a_focused_handle);
 235     self->a_icon = RrAppearanceCopy(ob_rr_theme->a_icon);
 236 }
 237
 238 static void free_theme_statics(ObFrame *self)
 239 {
 240     RrAppearanceFree(self->a_unfocused_title);
 241     RrAppearanceFree(self->a_focused_title);
 242     RrAppearanceFree(self->a_unfocused_label);
 243     RrAppearanceFree(self->a_focused_label);
 244     RrAppearanceFree(self->a_unfocused_handle);
 245     RrAppearanceFree(self->a_focused_handle);
 246     RrAppearanceFree(self->a_icon);
 247 }
 248
 249 void frame_free(ObFrame *self)
 250 {
 251     free_theme_statics(self);
 252
 253     XDestroyWindow(ob_display, self->window);
 254     if (self->colormap)
 255         XFreeColormap(ob_display, self->colormap);
 256
 257     g_free(self);
 258 }
 259
 260 void frame_show(ObFrame *self)
 261 {
 262     if (!self->visible) {
 263         self->visible = TRUE;
 264         XMapWindow(ob_display, self->client->window);
 265         XMapWindow(ob_display, self->window);
 266     }
 267 }
 268
 269 void frame_hide(ObFrame *self)
 270 {
 271     if (self->visible) {
 272         self->visible = FALSE;
 273         if (!frame_iconify_animating(self))
 274             XUnmapWindow(ob_display, self->window);
 275         /* we unmap the client itself so that we can get MapRequest
 276            events, and because the ICCCM tells us to! */
 277         XUnmapWindow(ob_display, self->client->window);
 278         self->client->ignore_unmaps += 1;
 279     }
 280 }
 281
 282 void frame_adjust_theme(ObFrame *self)
 283 {
 284     free_theme_statics(self);
 285     set_theme_statics(self);
 286 }
 287
 288 void frame_adjust_shape(ObFrame *self)
 289 {
 290 #ifdef SHAPE
 291     gint num;
 292     XRectangle xrect[2];
 293
 294     if (!self->client->shaped) {
 295         /* clear the shape on the frame window */
 296         XShapeCombineMask(ob_display, self->window, ShapeBounding,
 297                           self->innersize.left,
 298                           self->innersize.top,
 299                           None, ShapeSet);
 300     } else {
 301         /* make the frame's shape match the clients */
 302         XShapeCombineShape(ob_display, self->window, ShapeBounding,
 303                            self->innersize.left,
 304                            self->innersize.top,
 305                            self->client->window,
 306                            ShapeBounding, ShapeSet);
 307
 308         num = 0;
 309         if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
 310             xrect[0].x = -ob_rr_theme->fbwidth;
 311             xrect[0].y = -ob_rr_theme->fbwidth;
 312             xrect[0].width = self->width + self->rbwidth * 2;
 313             xrect[0].height = ob_rr_theme->title_height +
 314                 self->bwidth * 2;
 315             ++num;
 316         }
 317
 318         if (self->decorations & OB_FRAME_DECOR_HANDLE) {
 319             xrect[1].x = -ob_rr_theme->fbwidth;
 320             xrect[1].y = FRAME_HANDLE_Y(self);
 321             xrect[1].width = self->width + self->rbwidth * 2;
 322             xrect[1].height = ob_rr_theme->handle_height +
 323                 self->bwidth * 2;
 324             ++num;
 325         }
 326
 327         XShapeCombineRectangles(ob_display, self->window,
 328                                 ShapeBounding, 0, 0, xrect, num,
 329                                 ShapeUnion, Unsorted);
 330     }
 331 #endif
 332 }
 333
 334 void frame_adjust_area(ObFrame *self, gboolean moved,
 335                        gboolean resized, gboolean fake)
 336 {
 337     Strut oldsize;
 338
 339     oldsize = self->size;
 340
 341     if (resized) {
 342         self->decorations = self->client->decorations;
 343         self->max_horz = self->client->max_horz;
 344
 345         if (self->decorations & OB_FRAME_DECOR_BORDER) {
 346             self->bwidth = ob_rr_theme->fbwidth;
 347             self->cbwidth_x = ob_rr_theme->cbwidthx;
 348             self->cbwidth_y = ob_rr_theme->cbwidthy;
 349         } else {
 350             self->bwidth = self->cbwidth_x = self->cbwidth_y = 0;
 351         }
 352         self->rbwidth = self->bwidth;
 353
 354         if (self->max_horz)
 355             self->bwidth = self->cbwidth_x = 0;
 356
 357         STRUT_SET(self->innersize,
 358                   self->cbwidth_x,
 359                   self->cbwidth_y,
 360                   self->cbwidth_x,
 361                   self->cbwidth_y);
 362         self->width = self->client->area.width + self->cbwidth_x * 2 -
 363             (self->max_horz ? self->rbwidth * 2 : 0);
 364         self->width = MAX(self->width, 1); /* no lower than 1 */
 365
 366         /* set border widths */
 367         if (!fake) {
 368             XSetWindowBorderWidth(ob_display, self->window, self->bwidth);
 369             XSetWindowBorderWidth(ob_display, self->inner, self->bwidth);
 370             XSetWindowBorderWidth(ob_display, self->title,  self->rbwidth);
 371             XSetWindowBorderWidth(ob_display, self->handle, self->rbwidth);
 372             XSetWindowBorderWidth(ob_display, self->lgrip,  self->rbwidth);
 373             XSetWindowBorderWidth(ob_display, self->rgrip,  self->rbwidth);
 374         }
 375
 376         if (self->decorations & OB_FRAME_DECOR_TITLEBAR)
 377             self->innersize.top += ob_rr_theme->title_height + self->rbwidth +
 378                 (self->rbwidth - self->bwidth);
 379         if (self->decorations & OB_FRAME_DECOR_HANDLE &&
 380             ob_rr_theme->handle_height > 0)
 381             self->innersize.bottom += ob_rr_theme->handle_height +
 382                 self->rbwidth + (self->rbwidth - self->bwidth);
 383
 384         /* position/size and map/unmap all the windows */
 385
 386         if (!fake) {
 387             if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
 388                 XMoveResizeWindow(ob_display, self->title,
 389                                   -self->bwidth, -self->bwidth,
 390                                   self->width, ob_rr_theme->title_height);
 391                 XMapWindow(ob_display, self->title);
 392
 393                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {
 394                     XMoveWindow(ob_display, self->tltresize, 0, 0);
 395                     XMoveWindow(ob_display, self->tllresize, 0, 0);
 396                     XMoveWindow(ob_display, self->trtresize,
 397                                 self->width - ob_rr_theme->grip_width, 0);
 398                     XMoveWindow(ob_display, self->trrresize,
 399                                 self->width - ob_rr_theme->paddingx - 1, 0);
 400                     XMapWindow(ob_display, self->tltresize);
 401                     XMapWindow(ob_display, self->tllresize);
 402                     XMapWindow(ob_display, self->trtresize);
 403                     XMapWindow(ob_display, self->trrresize);
 404                 } else {
 405                     XUnmapWindow(ob_display, self->tltresize);
 406                     XUnmapWindow(ob_display, self->tllresize);
 407                     XUnmapWindow(ob_display, self->trtresize);
 408                     XUnmapWindow(ob_display, self->trrresize);
 409                 }
 410             } else
 411                 XUnmapWindow(ob_display, self->title);
 412         }
 413
 414         if ((self->decorations & OB_FRAME_DECOR_TITLEBAR))
 415             /* layout the title bar elements */
 416             layout_title(self);
 417
 418         if (!fake) {
 419             if (self->decorations & OB_FRAME_DECOR_HANDLE &&
 420                 ob_rr_theme->handle_height > 0)
 421             {
 422                 XMoveResizeWindow(ob_display, self->handle,
 423                                   -self->bwidth, FRAME_HANDLE_Y(self),
 424                                   self->width, ob_rr_theme->handle_height);
 425                 XMapWindow(ob_display, self->handle);
 426
 427                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {
 428                     XMoveWindow(ob_display, self->lgrip,
 429                                 -self->rbwidth, -self->rbwidth);
 430                     XMoveWindow(ob_display, self->rgrip,
 431                                 -self->rbwidth + self->width -
 432                                 ob_rr_theme->grip_width, -self->rbwidth);
 433                     XMapWindow(ob_display, self->lgrip);
 434                     XMapWindow(ob_display, self->rgrip);
 435                 } else {
 436                     XUnmapWindow(ob_display, self->lgrip);
 437                     XUnmapWindow(ob_display, self->rgrip);
 438                 }
 439             } else
 440                 XUnmapWindow(ob_display, self->handle);
 441
 442             /* move and resize the inner border window which contains the plate
 443              */
 444             XMoveResizeWindow(ob_display, self->inner,
 445                               self->innersize.left - self->cbwidth_x -
 446                               self->bwidth,
 447                               self->innersize.top - self->cbwidth_y -
 448                               self->bwidth,
 449                               self->client->area.width +
 450                               self->cbwidth_x * 2,
 451                               self->client->area.height +
 452                               self->cbwidth_y * 2);
 453
 454             /* move the plate */
 455             XMoveWindow(ob_display, self->plate,
 456                         self->cbwidth_x, self->cbwidth_y);
 457
 458             /* when the client has StaticGravity, it likes to move around. */
 459             XMoveWindow(ob_display, self->client->window, 0, 0);
 460         }
 461
 462         STRUT_SET(self->size,
 463                   self->innersize.left + self->bwidth,
 464                   self->innersize.top + self->bwidth,
 465                   self->innersize.right + self->bwidth,
 466                   self->innersize.bottom + self->bwidth);
 467     }
 468
 469     /* shading can change without being moved or resized */
 470     RECT_SET_SIZE(self->area,
 471                   self->client->area.width +
 472                   self->size.left + self->size.right,
 473                   (self->client->shaded ?
 474                    ob_rr_theme->title_height + self->rbwidth * 2:
 475                    self->client->area.height +
 476                    self->size.top + self->size.bottom));
 477
 478     if (moved || resized) {
 479         /* find the new coordinates, done after setting the frame.size, for
 480            frame_client_gravity. */
 481         self->area.x = self->client->area.x;
 482         self->area.y = self->client->area.y;
 483         frame_client_gravity(self, &self->area.x, &self->area.y,
 484                              self->client->area.width,
 485                              self->client->area.height);
 486     }
 487
 488     if (!fake) {
 489         if (!frame_iconify_animating(self))
 490             /* move and resize the top level frame.
 491                shading can change without being moved or resized.
 492
 493                but don't do this during an iconify animation. it will be
 494                reflected afterwards.
 495             */
 496             XMoveResizeWindow(ob_display, self->window,
 497                               self->area.x, self->area.y,
 498                               self->area.width - self->bwidth * 2,
 499                               self->area.height - self->bwidth * 2);
 500
 501         if (resized) {
 502             framerender_frame(self);
 503             frame_adjust_shape(self);
 504         }
 505
 506         if (!STRUT_EQUAL(self->size, oldsize)) {
 507             gulong vals[4];
 508             vals[0] = self->size.left;
 509             vals[1] = self->size.right;
 510             vals[2] = self->size.top;
 511             vals[3] = self->size.bottom;
 512             PROP_SETA32(self->client->window, net_frame_extents,
 513                         cardinal, vals, 4);
 514             PROP_SETA32(self->client->window, kde_net_wm_frame_strut,
 515                         cardinal, vals, 4);
 516         }
 517
 518         /* if this occurs while we are focus cycling, the indicator needs to
 519            match the changes */
 520         if (focus_cycle_target == self->client)
 521             focus_cycle_draw_indicator();
 522     }
 523     if (resized && (self->decorations & OB_FRAME_DECOR_TITLEBAR))
 524         XResizeWindow(ob_display, self->label, self->label_width,
 525                       ob_rr_theme->label_height);
 526 }
 527
 528 void frame_adjust_client_area(ObFrame *self)
 529 {
 530     /* resize the plate */
 531     XResizeWindow(ob_display, self->plate,
 532                   self->client->area.width, self->client->area.height);
 533 }
 534
 535 void frame_adjust_state(ObFrame *self)
 536 {
 537     framerender_frame(self);
 538 }
 539
 540 void frame_adjust_focus(ObFrame *self, gboolean hilite)
 541 {
 542     self->focused = hilite;
 543     framerender_frame(self);
 544     XFlush(ob_display);
 545 }
 546
 547 void frame_adjust_title(ObFrame *self)
 548 {
 549     framerender_frame(self);
 550 }
 551
 552 void frame_adjust_icon(ObFrame *self)
 553 {
 554     framerender_frame(self);
 555 }
 556
 557 void frame_grab_client(ObFrame *self)
 558 {
 559     /* reparent the client to the frame */
 560     XReparentWindow(ob_display, self->client->window, self->plate, 0, 0);
 561     /*
 562       When reparenting the client window, it is usually not mapped yet, since
 563       this occurs from a MapRequest. However, in the case where Openbox is
 564       starting up, the window is already mapped, so we'll see unmap events for
 565       it. There are 2 unmap events generated that we see, one with the 'event'
 566       member set the root window, and one set to the client, but both get
 567       handled and need to be ignored.
 568     */
 569     if (ob_state() == OB_STATE_STARTING)
 570         self->client->ignore_unmaps += 2;
 571
 572     /* select the event mask on the client's parent (to receive config/map
 573        req's) the ButtonPress is to catch clicks on the client border */
 574     XSelectInput(ob_display, self->plate, PLATE_EVENTMASK);
 575
 576     /* map the client so it maps when the frame does */
 577     XMapWindow(ob_display, self->client->window);
 578
 579     /* adjust the frame to the client's size */
 580     frame_adjust_area(self, FALSE, TRUE, FALSE);
 581
 582     /* set all the windows for the frame in the window_map */
 583     g_hash_table_insert(window_map, &self->window, self->client);
 584     g_hash_table_insert(window_map, &self->plate, self->client);
 585     g_hash_table_insert(window_map, &self->inner, self->client);
 586     g_hash_table_insert(window_map, &self->title, self->client);
 587     g_hash_table_insert(window_map, &self->label, self->client);
 588     g_hash_table_insert(window_map, &self->max, self->client);
 589     g_hash_table_insert(window_map, &self->close, self->client);
 590     g_hash_table_insert(window_map, &self->desk, self->client);
 591     g_hash_table_insert(window_map, &self->shade, self->client);
 592     g_hash_table_insert(window_map, &self->icon, self->client);
 593     g_hash_table_insert(window_map, &self->iconify, self->client);
 594     g_hash_table_insert(window_map, &self->handle, self->client);
 595     g_hash_table_insert(window_map, &self->lgrip, self->client);
 596     g_hash_table_insert(window_map, &self->rgrip, self->client);
 597     g_hash_table_insert(window_map, &self->tltresize, self->client);
 598     g_hash_table_insert(window_map, &self->tllresize, self->client);
 599     g_hash_table_insert(window_map, &self->trtresize, self->client);
 600     g_hash_table_insert(window_map, &self->trrresize, self->client);
 601 }
 602
 603 void frame_release_client(ObFrame *self)
 604 {
 605     XEvent ev;
 606     gboolean reparent = TRUE;
 607
 608     /* if there was any animation going on, kill it */
 609     ob_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
 610                                      self, FALSE);
 611
 612     /* check if the app has already reparented its window away */
 613     while (XCheckTypedWindowEvent(ob_display, self->client->window,
 614                                   ReparentNotify, &ev))
 615     {
 616         /* This check makes sure we don't catch our own reparent action to
 617            our frame window. This doesn't count as the app reparenting itself
 618            away of course.
 619
 620            Reparent events that are generated by us are just discarded here.
 621            They are of no consequence to us anyhow.
 622         */
 623         if (ev.xreparent.parent != self->plate) {
 624             reparent = FALSE;
 625             XPutBackEvent(ob_display, &ev);
 626             break;
 627         }
 628     }
 629
 630     if (reparent) {
 631         /* according to the ICCCM - if the client doesn't reparent itself,
 632            then we will reparent the window to root for them */
 633         XReparentWindow(ob_display, self->client->window,
 634                         RootWindow(ob_display, ob_screen),
 635                         self->client->area.x,
 636                         self->client->area.y);
 637     }
 638
 639     /* remove all the windows for the frame from the window_map */
 640     g_hash_table_remove(window_map, &self->window);
 641     g_hash_table_remove(window_map, &self->plate);
 642     g_hash_table_remove(window_map, &self->inner);
 643     g_hash_table_remove(window_map, &self->title);
 644     g_hash_table_remove(window_map, &self->label);
 645     g_hash_table_remove(window_map, &self->max);
 646     g_hash_table_remove(window_map, &self->close);
 647     g_hash_table_remove(window_map, &self->desk);
 648     g_hash_table_remove(window_map, &self->shade);
 649     g_hash_table_remove(window_map, &self->icon);
 650     g_hash_table_remove(window_map, &self->iconify);
 651     g_hash_table_remove(window_map, &self->handle);
 652     g_hash_table_remove(window_map, &self->lgrip);
 653     g_hash_table_remove(window_map, &self->rgrip);
 654     g_hash_table_remove(window_map, &self->tltresize);
 655     g_hash_table_remove(window_map, &self->tllresize);
 656     g_hash_table_remove(window_map, &self->trtresize);
 657     g_hash_table_remove(window_map, &self->trrresize);
 658
 659     ob_main_loop_timeout_remove_data(ob_main_loop, flash_timeout, self, TRUE);
 660 }
 661
 662 /* is there anything present between us and the label? */
 663 static gboolean is_button_present(ObFrame *self, const gchar *lc, gint dir) {
 664     for (; *lc != '\0' && lc >= config_title_layout; lc += dir) {
 665         if (*lc == ' ') continue; /* it was invalid */
 666         if (*lc == 'N' && self->decorations & OB_FRAME_DECOR_ICON)
 667             return TRUE;
 668         if (*lc == 'D' && self->decorations & OB_FRAME_DECOR_ALLDESKTOPS)
 669             return TRUE;
 670         if (*lc == 'S' && self->decorations & OB_FRAME_DECOR_SHADE)
 671             return TRUE;
 672         if (*lc == 'I' && self->decorations & OB_FRAME_DECOR_ICONIFY)
 673             return TRUE;
 674         if (*lc == 'M' && self->decorations & OB_FRAME_DECOR_MAXIMIZE)
 675             return TRUE;
 676         if (*lc == 'C' && self->decorations & OB_FRAME_DECOR_CLOSE)
 677             return TRUE;
 678         if (*lc == 'L') return FALSE;
 679     }
 680     return FALSE;
 681 }
 682
 683 static void layout_title(ObFrame *self)
 684 {
 685     gchar *lc;
 686     gint i;
 687
 688     const gint bwidth = ob_rr_theme->button_size + ob_rr_theme->paddingx + 1;
 689     /* position of the left most button */
 690     const gint left = ob_rr_theme->paddingx + 1;
 691     /* position of the right most button */
 692     const gint right = self->width - bwidth;
 693
 694     /* turn them all off */
 695     self->icon_on = self->desk_on = self->shade_on = self->iconify_on =
 696         self->max_on = self->close_on = self->label_on = FALSE;
 697     self->label_width = self->width - (ob_rr_theme->paddingx + 1) * 2;
 698     self->leftmost = self->rightmost = OB_FRAME_CONTEXT_NONE;
 699
 700     /* figure out what's being show, find each element's position, and the
 701        width of the label
 702
 703        do the ones before the label, then after the label,
 704        i will be +1 the first time through when working to the left,
 705        and -1 the second time through when working to the right */
 706     for (i = 1; i >= -1; i-=2) {
 707         gint x;
 708         ObFrameContext *firstcon;
 709
 710         if (i > 0) {
 711             x = left;
 712             lc = config_title_layout;
 713             firstcon = &self->leftmost;
 714         } else {
 715             x = right;
 716             lc = config_title_layout + strlen(config_title_layout)-1;
 717             firstcon = &self->rightmost;
 718         }
 719
 720         /* stop at the end of the string (or the label, which calls break) */
 721         for (; *lc != '\0' && lc >= config_title_layout; lc+=i) {
 722             if (*lc == 'L') {
 723                 if (i > 0) {
 724                     self->label_on = TRUE;
 725                     self->label_x = x;
 726                 }
 727                 break; /* break the for loop, do other side of label */
 728             } else if (*lc == 'N') {
 729                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICON;
 730                 if ((self->icon_on = is_button_present(self, lc, i))) {
 731                     /* icon gets extra padding */
 732                     self->label_width -= bwidth + 2;
 733                     self->icon_x = x + (i * 1);
 734                     x += i * (bwidth + 2);
 735                 }
 736             } else if (*lc == 'D') {
 737                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ALLDESKTOPS;
 738                 if ((self->desk_on = is_button_present(self, lc, i))) {
 739                     self->label_width -= bwidth;
 740                     self->desk_x = x;
 741                     x += i * bwidth;
 742                 }
 743             } else if (*lc == 'S') {
 744                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_SHADE;
 745                 if ((self->shade_on = is_button_present(self, lc, i))) {
 746                     self->label_width -= bwidth;
 747                     self->shade_x = x;
 748                     x += i * bwidth;
 749                 }
 750             } else if (*lc == 'I') {
 751                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICONIFY;
 752                 if ((self->iconify_on = is_button_present(self, lc, i))) {
 753                     self->label_width -= bwidth;
 754                     self->iconify_x = x;
 755                     x += i * bwidth;
 756                 }
 757             } else if (*lc == 'M') {
 758                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_MAXIMIZE;
 759                 if ((self->max_on = is_button_present(self, lc, i))) {
 760                     self->label_width -= bwidth;
 761                     self->max_x = x;
 762                     x += i * bwidth;
 763                 }
 764             } else if (*lc == 'C') {
 765                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_CLOSE;
 766                 if ((self->close_on = is_button_present(self, lc, i))) {
 767                     self->label_width -= bwidth;
 768                     self->close_x = x;
 769                     x += i * bwidth;
 770                 }
 771             } else
 772                 continue; /* don't set firstcon */
 773             firstcon = NULL;
 774         }
 775     }
 776
 777     /* position and map the elements */
 778     if (self->icon_on) {
 779         XMapWindow(ob_display, self->icon);
 780         XMoveWindow(ob_display, self->icon, self->icon_x,
 781                     ob_rr_theme->paddingy);
 782     } else
 783         XUnmapWindow(ob_display, self->icon);
 784
 785     if (self->desk_on) {
 786         XMapWindow(ob_display, self->desk);
 787         XMoveWindow(ob_display, self->desk, self->desk_x,
 788                     ob_rr_theme->paddingy + 1);
 789     } else
 790         XUnmapWindow(ob_display, self->desk);
 791
 792     if (self->shade_on) {
 793         XMapWindow(ob_display, self->shade);
 794         XMoveWindow(ob_display, self->shade, self->shade_x,
 795                     ob_rr_theme->paddingy + 1);
 796     } else
 797         XUnmapWindow(ob_display, self->shade);
 798
 799     if (self->iconify_on) {
 800         XMapWindow(ob_display, self->iconify);
 801         XMoveWindow(ob_display, self->iconify, self->iconify_x,
 802                     ob_rr_theme->paddingy + 1);
 803     } else
 804         XUnmapWindow(ob_display, self->iconify);
 805
 806     if (self->max_on) {
 807         XMapWindow(ob_display, self->max);
 808         XMoveWindow(ob_display, self->max, self->max_x,
 809                     ob_rr_theme->paddingy + 1);
 810     } else
 811         XUnmapWindow(ob_display, self->max);
 812
 813     if (self->close_on) {
 814         XMapWindow(ob_display, self->close);
 815         XMoveWindow(ob_display, self->close, self->close_x,
 816                     ob_rr_theme->paddingy + 1);
 817     } else
 818         XUnmapWindow(ob_display, self->close);
 819
 820     if (self->label_on) {
 821         self->label_width = MAX(1, self->label_width); /* no lower than 1 */
 822         XMapWindow(ob_display, self->label);
 823         XMoveWindow(ob_display, self->label, self->label_x,
 824                     ob_rr_theme->paddingy);
 825     } else
 826         XUnmapWindow(ob_display, self->label);
 827 }
 828
 829 ObFrameContext frame_context_from_string(const gchar *name)
 830 {
 831     if (!g_ascii_strcasecmp("Desktop", name))
 832         return OB_FRAME_CONTEXT_DESKTOP;
 833     else if (!g_ascii_strcasecmp("Client", name))
 834         return OB_FRAME_CONTEXT_CLIENT;
 835     else if (!g_ascii_strcasecmp("Titlebar", name))
 836         return OB_FRAME_CONTEXT_TITLEBAR;
 837     else if (!g_ascii_strcasecmp("Handle", name))
 838         return OB_FRAME_CONTEXT_HANDLE;
 839     else if (!g_ascii_strcasecmp("Frame", name))
 840         return OB_FRAME_CONTEXT_FRAME;
 841     else if (!g_ascii_strcasecmp("TLCorner", name))
 842         return OB_FRAME_CONTEXT_TLCORNER;
 843     else if (!g_ascii_strcasecmp("TRCorner", name))
 844         return OB_FRAME_CONTEXT_TRCORNER;
 845     else if (!g_ascii_strcasecmp("BLCorner", name))
 846         return OB_FRAME_CONTEXT_BLCORNER;
 847     else if (!g_ascii_strcasecmp("BRCorner", name))
 848         return OB_FRAME_CONTEXT_BRCORNER;
 849     else if (!g_ascii_strcasecmp("Maximize", name))
 850         return OB_FRAME_CONTEXT_MAXIMIZE;
 851     else if (!g_ascii_strcasecmp("AllDesktops", name))
 852         return OB_FRAME_CONTEXT_ALLDESKTOPS;
 853     else if (!g_ascii_strcasecmp("Shade", name))
 854         return OB_FRAME_CONTEXT_SHADE;
 855     else if (!g_ascii_strcasecmp("Iconify", name))
 856         return OB_FRAME_CONTEXT_ICONIFY;
 857     else if (!g_ascii_strcasecmp("Icon", name))
 858         return OB_FRAME_CONTEXT_ICON;
 859     else if (!g_ascii_strcasecmp("Close", name))
 860         return OB_FRAME_CONTEXT_CLOSE;
 861     else if (!g_ascii_strcasecmp("MoveResize", name))
 862         return OB_FRAME_CONTEXT_MOVE_RESIZE;
 863     return OB_FRAME_CONTEXT_NONE;
 864 }
 865
 866 ObFrameContext frame_context(ObClient *client, Window win, gint x, gint y)
 867 {
 868     ObFrame *self;
 869
 870     if (moveresize_in_progress)
 871         return OB_FRAME_CONTEXT_MOVE_RESIZE;
 872
 873     if (win == RootWindow(ob_display, ob_screen))
 874         return OB_FRAME_CONTEXT_DESKTOP;
 875     if (client == NULL) return OB_FRAME_CONTEXT_NONE;
 876     if (win == client->window) {
 877         /* conceptually, this is the desktop, as far as users are
 878            concerned */
 879         if (client->type == OB_CLIENT_TYPE_DESKTOP)
 880             return OB_FRAME_CONTEXT_DESKTOP;
 881         return OB_FRAME_CONTEXT_CLIENT;
 882     }
 883
 884     self = client->frame;
 885     if (win == self->inner || win == self->plate) {
 886         /* conceptually, this is the desktop, as far as users are
 887            concerned */
 888         if (client->type == OB_CLIENT_TYPE_DESKTOP)
 889             return OB_FRAME_CONTEXT_DESKTOP;
 890         return OB_FRAME_CONTEXT_CLIENT;
 891     }
 892
 893     if (win == self->title) {
 894         /* when the user clicks in the corners of the titlebar and the client
 895            is fully maximized, then treat it like they clicked in the
 896            button that is there */
 897         if (self->client->max_horz && self->client->max_vert &&
 898             y < ob_rr_theme->paddingy + 1 + ob_rr_theme->button_size)
 899         {
 900             if (x < ((ob_rr_theme->paddingx + 1) * 2 +
 901                      ob_rr_theme->button_size)) {
 902                 if (self->leftmost != OB_FRAME_CONTEXT_NONE)
 903                     return self->leftmost;
 904             }
 905             else if (x > (self->width -
 906                           (ob_rr_theme->paddingx + 1 +
 907                            ob_rr_theme->button_size)))
 908             {
 909                 if (self->rightmost != OB_FRAME_CONTEXT_NONE)
 910                     return self->rightmost;
 911             }
 912         }
 913         return OB_FRAME_CONTEXT_TITLEBAR;
 914     }
 915
 916     if (win == self->window)    return OB_FRAME_CONTEXT_FRAME;
 917     if (win == self->label)     return OB_FRAME_CONTEXT_TITLEBAR;
 918     if (win == self->handle)    return OB_FRAME_CONTEXT_HANDLE;
 919     if (win == self->lgrip)     return OB_FRAME_CONTEXT_BLCORNER;
 920     if (win == self->rgrip)     return OB_FRAME_CONTEXT_BRCORNER;
 921     if (win == self->tltresize) return OB_FRAME_CONTEXT_TLCORNER;
 922     if (win == self->tllresize) return OB_FRAME_CONTEXT_TLCORNER;
 923     if (win == self->trtresize) return OB_FRAME_CONTEXT_TRCORNER;
 924     if (win == self->trrresize) return OB_FRAME_CONTEXT_TRCORNER;
 925     if (win == self->max)       return OB_FRAME_CONTEXT_MAXIMIZE;
 926     if (win == self->iconify)   return OB_FRAME_CONTEXT_ICONIFY;
 927     if (win == self->close)     return OB_FRAME_CONTEXT_CLOSE;
 928     if (win == self->icon)      return OB_FRAME_CONTEXT_ICON;
 929     if (win == self->desk)      return OB_FRAME_CONTEXT_ALLDESKTOPS;
 930     if (win == self->shade)     return OB_FRAME_CONTEXT_SHADE;
 931
 932     return OB_FRAME_CONTEXT_NONE;
 933 }
 934
 935 void frame_client_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
 936 {
 937     /* horizontal */
 938     switch (self->client->gravity) {
 939     default:
 940     case NorthWestGravity:
 941     case SouthWestGravity:
 942     case WestGravity:
 943         break;
 944
 945     case NorthGravity:
 946     case SouthGravity:
 947     case CenterGravity:
 948         *x -= (self->size.left + w) / 2;
 949         break;
 950
 951     case NorthEastGravity:
 952     case SouthEastGravity:
 953     case EastGravity:
 954         *x -= (self->size.left + self->size.right + w) - 1;
 955         break;
 956
 957     case ForgetGravity:
 958     case StaticGravity:
 959         *x -= self->size.left;
 960         break;
 961     }
 962
 963     /* vertical */
 964     switch (self->client->gravity) {
 965     default:
 966     case NorthWestGravity:
 967     case NorthEastGravity:
 968     case NorthGravity:
 969         break;
 970
 971     case CenterGravity:
 972     case EastGravity:
 973     case WestGravity:
 974         *y -= (self->size.top + h) / 2;
 975         break;
 976
 977     case SouthWestGravity:
 978     case SouthEastGravity:
 979     case SouthGravity:
 980         *y -= (self->size.top + self->size.bottom + h) - 1;
 981         break;
 982
 983     case ForgetGravity:
 984     case StaticGravity:
 985         *y -= self->size.top;
 986         break;
 987     }
 988 }
 989
 990 void frame_frame_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
 991 {
 992     /* horizontal */
 993     switch (self->client->gravity) {
 994     default:
 995     case NorthWestGravity:
 996     case WestGravity:
 997     case SouthWestGravity:
 998         break;
 999     case NorthGravity:
1000     case CenterGravity:
1001     case SouthGravity:
1002         *x += (self->size.left + w) / 2;
1003         break;
1004     case NorthEastGravity:
1005     case EastGravity:
1006     case SouthEastGravity:
1007         *x += (self->size.left + self->size.right + w) - 1;
1008         break;
1009     case StaticGravity:
1010     case ForgetGravity:
1011         *x += self->size.left;
1012         break;
1013     }
1014
1015     /* vertical */
1016     switch (self->client->gravity) {
1017     default:
1018     case NorthWestGravity:
1019     case NorthGravity:
1020     case NorthEastGravity:
1021         break;
1022     case WestGravity:
1023     case CenterGravity:
1024     case EastGravity:
1025         *y += (self->size.top + h) / 2;
1026         break;
1027     case SouthWestGravity:
1028     case SouthGravity:
1029     case SouthEastGravity:
1030         *y += (self->size.top + self->size.bottom + h) - 1;
1031         break;
1032     case StaticGravity:
1033     case ForgetGravity:
1034         *y += self->size.top;
1035         break;
1036     }
1037 }
1038
1039 static void flash_done(gpointer data)
1040 {
1041     ObFrame *self = data;
1042
1043     if (self->focused != self->flash_on)
1044         frame_adjust_focus(self, self->focused);
1045 }
1046
1047 static gboolean flash_timeout(gpointer data)
1048 {
1049     ObFrame *self = data;
1050     GTimeVal now;
1051
1052     g_get_current_time(&now);
1053     if (now.tv_sec > self->flash_end.tv_sec ||
1054         (now.tv_sec == self->flash_end.tv_sec &&
1055          now.tv_usec >= self->flash_end.tv_usec))
1056         self->flashing = FALSE;
1057
1058     if (!self->flashing)
1059         return FALSE; /* we are done */
1060
1061     self->flash_on = !self->flash_on;
1062     if (!self->focused) {
1063         frame_adjust_focus(self, self->flash_on);
1064         self->focused = FALSE;
1065     }
1066
1067     return TRUE; /* go again */
1068 }
1069
1070 void frame_flash_start(ObFrame *self)
1071 {
1072     self->flash_on = self->focused;
1073
1074     if (!self->flashing)
1075         ob_main_loop_timeout_add(ob_main_loop,
1076                                  G_USEC_PER_SEC * 0.6,
1077                                  flash_timeout,
1078                                  self,
1079                                  g_direct_equal,
1080                                  flash_done);
1081     g_get_current_time(&self->flash_end);
1082     g_time_val_add(&self->flash_end, G_USEC_PER_SEC * 5);
1083
1084     self->flashing = TRUE;
1085 }
1086
1087 void frame_flash_stop(ObFrame *self)
1088 {
1089     self->flashing = FALSE;
1090 }
1091
1092 static gulong frame_animate_iconify_time_left(ObFrame *self,
1093                                               const GTimeVal *now)
1094 {
1095     glong sec, usec;
1096     sec = self->iconify_animation_end.tv_sec - now->tv_sec;
1097     usec = self->iconify_animation_end.tv_usec - now->tv_usec;
1098     if (usec < 0) {
1099         usec += G_USEC_PER_SEC;
1100         sec--;
1101     }
1102     /* no negative values */
1103     return MAX(sec * G_USEC_PER_SEC + usec, 0);
1104 }
1105
1106 static gboolean frame_animate_iconify(gpointer p)
1107 {
1108     ObFrame *self = p;
1109     gint x, y, w, h;
1110     gint iconx, icony, iconw;
1111     GTimeVal now;
1112     gulong time;
1113     gboolean iconifying;
1114
1115     if (self->client->icon_geometry.width == 0) {
1116         /* there is no icon geometry set so just go straight down */
1117         Rect *a = screen_physical_area();
1118         iconx = self->area.x + self->area.width / 2 + 32;
1119         icony = a->y + a->width;
1120         iconw = 64;
1121     } else {
1122         iconx = self->client->icon_geometry.x;
1123         icony = self->client->icon_geometry.y;
1124         iconw = self->client->icon_geometry.width;
1125     }
1126
1127     iconifying = self->iconify_animation_going > 0;
1128
1129     /* how far do we have left to go ? */
1130     g_get_current_time(&now);
1131     time = frame_animate_iconify_time_left(self, &now);
1132
1133     if (time == 0 || iconifying) {
1134         /* start where the frame is supposed to be */
1135         x = self->area.x;
1136         y = self->area.y;
1137         w = self->area.width - self->bwidth * 2;
1138         h = self->area.height - self->bwidth * 2;
1139     } else {
1140         /* start at the icon */
1141         x = iconx;
1142         y = icony;
1143         w = iconw;
1144         h = self->innersize.top; /* just the titlebar */
1145     }
1146
1147     if (time > 0) {
1148         glong dx, dy, dw;
1149         glong elapsed;
1150
1151         dx = self->area.x - iconx;
1152         dy = self->area.y - icony;
1153         dw = self->area.width - self->bwidth * 2 - iconw;
1154          /* if restoring, we move in the opposite direction */
1155         if (!iconifying) { dx = -dx; dy = -dy; dw = -dw; }
1156
1157         elapsed = FRAME_ANIMATE_ICONIFY_TIME - time;
1158         x = x - (dx * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
1159         y = y - (dy * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
1160         w = w - (dw * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
1161         h = self->innersize.top; /* just the titlebar */
1162     }
1163
1164     if (time == 0)
1165         frame_end_iconify_animation(self);
1166     else {
1167         XMoveResizeWindow(ob_display, self->window, x, y, w, h);
1168         XFlush(ob_display);
1169     }
1170
1171     return time > 0; /* repeat until we're out of time */
1172 }
1173
1174 void frame_end_iconify_animation(ObFrame *self)
1175 {
1176     /* see if there is an animation going */
1177     if (self->iconify_animation_going == 0) return;
1178
1179     if (!self->visible)
1180         XUnmapWindow(ob_display, self->window);
1181
1182     /* we're not animating any more ! */
1183     self->iconify_animation_going = 0;
1184
1185     XMoveResizeWindow(ob_display, self->window,
1186                       self->area.x, self->area.y,
1187                       self->area.width - self->bwidth * 2,
1188                       self->area.height - self->bwidth * 2);
1189     XFlush(ob_display);
1190 }
1191
1192 void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying)
1193 {
1194     gulong time;
1195     gboolean new_anim = FALSE;
1196     gboolean set_end = TRUE;
1197     GTimeVal now;
1198
1199     /* if there is no titlebar, just don't animate for now
1200        XXX it would be nice tho.. */
1201     if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1202         return;
1203
1204     /* get the current time */
1205     g_get_current_time(&now);
1206
1207     /* get how long until the end */
1208     time = FRAME_ANIMATE_ICONIFY_TIME;
1209     if (self->iconify_animation_going) {
1210         if (!!iconifying != (self->iconify_animation_going > 0)) {
1211             /* animation was already going on in the opposite direction */
1212             time = time - frame_animate_iconify_time_left(self, &now);
1213         } else
1214             /* animation was already going in the same direction */
1215             set_end = FALSE;
1216     } else
1217         new_anim = TRUE;
1218     self->iconify_animation_going = iconifying ? 1 : -1;
1219
1220     /* set the ending time */
1221     if (set_end) {
1222         self->iconify_animation_end.tv_sec = now.tv_sec;
1223         self->iconify_animation_end.tv_usec = now.tv_usec;
1224         g_time_val_add(&self->iconify_animation_end, time);
1225     }
1226
1227     if (new_anim) {
1228         ob_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
1229                                          self, FALSE);
1230         ob_main_loop_timeout_add(ob_main_loop,
1231                                  FRAME_ANIMATE_ICONIFY_STEP_TIME,
1232                                  frame_animate_iconify, self,
1233                                  g_direct_equal, NULL);
1234
1235         /* do the first step */
1236         frame_animate_iconify(self);
1237
1238         /* show it during the animation even if it is not "visible" */
1239         if (!self->visible)
1240             XMapWindow(ob_display, self->window);
1241     }
1242 }