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