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