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