fix the context given off by the borders in the br corner
[mikachu/openbox.git] / 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 +
381                   (!self->max_horz || !self->max_vert ||
382                    !self->client->undecorated ? self->bwidth : 0),
383                   self->cbwidth_r + (!self->max_horz ? self->bwidth : 0),
384                   self->cbwidth_b +
385                   (!self->max_horz || !self->max_vert ? self->bwidth : 0));
386
387         if (self->decorations & OB_FRAME_DECOR_TITLEBAR)
388             self->size.top += ob_rr_theme->title_height + self->bwidth;
389         if (self->decorations & OB_FRAME_DECOR_HANDLE &&
390             ob_rr_theme->handle_height > 0)
391         {
392             self->size.bottom += ob_rr_theme->handle_height + self->bwidth;
393         }
394
395         /* position/size and map/unmap all the windows */
396
397         if (!fake) {
398             gint innercornerheight =
399                 ob_rr_theme->grip_width - self->size.bottom;
400
401             if (self->cbwidth_l) {
402                 XMoveResizeWindow(ob_display, self->innerleft,
403                                   self->size.left - self->cbwidth_l,
404                                   self->size.top,
405                                   self->cbwidth_l, self->client->area.height);
406
407                 XMapWindow(ob_display, self->innerleft);
408             } else
409                 XUnmapWindow(ob_display, self->innerleft);
410
411             if (self->cbwidth_l && innercornerheight > 0) {
412                 XMoveResizeWindow(ob_display, self->innerbll,
413                                   0,
414                                   self->client->area.height - 
415                                   (ob_rr_theme->grip_width -
416                                    self->size.bottom),
417                                   self->cbwidth_l,
418                                   ob_rr_theme->grip_width - self->size.bottom);
419
420                 XMapWindow(ob_display, self->innerbll);
421             } else
422                 XUnmapWindow(ob_display, self->innerbll);
423
424             if (self->cbwidth_r) {
425                 XMoveResizeWindow(ob_display, self->innerright,
426                                   self->size.left + self->client->area.width,
427                                   self->size.top,
428                                   self->cbwidth_r, self->client->area.height);
429
430                 XMapWindow(ob_display, self->innerright);
431             } else
432                 XUnmapWindow(ob_display, self->innerright);
433
434             if (self->cbwidth_r && innercornerheight > 0) {
435                 XMoveResizeWindow(ob_display, self->innerbrr,
436                                   0,
437                                   self->client->area.height - 
438                                   (ob_rr_theme->grip_width -
439                                    self->size.bottom),
440                                   self->cbwidth_r,
441                                   ob_rr_theme->grip_width - self->size.bottom);
442
443                 XMapWindow(ob_display, self->innerbrr);
444             } else
445                 XUnmapWindow(ob_display, self->innerbrr);
446
447             if (self->cbwidth_t) {
448                 XMoveResizeWindow(ob_display, self->innertop,
449                                   self->size.left - self->cbwidth_l,
450                                   self->size.top - self->cbwidth_t,
451                                   self->client->area.width +
452                                   self->cbwidth_l + self->cbwidth_r,
453                                   self->cbwidth_t);
454
455                 XMapWindow(ob_display, self->innertop);
456             } else
457                 XUnmapWindow(ob_display, self->innertop);
458
459             if (self->cbwidth_b) {
460                 XMoveResizeWindow(ob_display, self->innerbottom,
461                                   self->size.left - self->cbwidth_l,
462                                   self->size.top + self->client->area.height,
463                                   self->client->area.width +
464                                   self->cbwidth_l + self->cbwidth_r,
465                                   self->cbwidth_b);
466
467                 XMoveResizeWindow(ob_display, self->innerblb,
468                                   0, 0,
469                                   ob_rr_theme->grip_width + self->bwidth,
470                                   self->cbwidth_b);
471                 XMoveResizeWindow(ob_display, self->innerbrb,
472                                   self->client->area.width +
473                                   self->cbwidth_l + self->cbwidth_r -
474                                   (ob_rr_theme->grip_width + self->bwidth),
475                                   0,
476                                   ob_rr_theme->grip_width + self->bwidth,
477                                   self->cbwidth_b);
478
479                 XMapWindow(ob_display, self->innerbottom);
480                 XMapWindow(ob_display, self->innerblb);
481                 XMapWindow(ob_display, self->innerbrb);
482             } else {
483                 XUnmapWindow(ob_display, self->innerbottom);
484                 XUnmapWindow(ob_display, self->innerblb);
485                 XUnmapWindow(ob_display, self->innerbrb);
486             }
487
488             if (self->bwidth) {
489                 gint titlesides;
490
491                 /* height of titleleft and titleright */
492                 titlesides = (!self->max_horz ? ob_rr_theme->grip_width : 0);
493
494                 XMoveResizeWindow(ob_display, self->titletop,
495                                   ob_rr_theme->grip_width + self->bwidth, 0,
496                                   /* width + bwidth*2 - bwidth*2 - grips*2 */
497                                   self->width - ob_rr_theme->grip_width * 2,
498                                   self->bwidth);
499                 XMoveResizeWindow(ob_display, self->titletopleft,
500                                   0, 0,
501                                   ob_rr_theme->grip_width + self->bwidth,
502                                   self->bwidth);
503                 XMoveResizeWindow(ob_display, self->titletopright,
504                                   self->client->area.width +
505                                   self->size.left + self->size.right -
506                                   ob_rr_theme->grip_width - self->bwidth,
507                                   0,
508                                   ob_rr_theme->grip_width + self->bwidth,
509                                   self->bwidth);
510
511                 if (titlesides > 0) {
512                     XMoveResizeWindow(ob_display, self->titleleft,
513                                       0, self->bwidth,
514                                       self->bwidth,
515                                       titlesides);
516                     XMoveResizeWindow(ob_display, self->titleright,
517                                       self->client->area.width +
518                                       self->size.left + self->size.right -
519                                       self->bwidth,
520                                       self->bwidth,
521                                       self->bwidth,
522                                       titlesides);
523
524                     XMapWindow(ob_display, self->titleleft);
525                     XMapWindow(ob_display, self->titleright);
526                 } else {
527                     XUnmapWindow(ob_display, self->titleleft);
528                     XUnmapWindow(ob_display, self->titleright);
529                 }
530
531                 XMapWindow(ob_display, self->titletop);
532                 XMapWindow(ob_display, self->titletopleft);
533                 XMapWindow(ob_display, self->titletopright);
534
535                 if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
536                     XMoveResizeWindow(ob_display, self->titlebottom,
537                                       (self->max_horz ? 0 : self->bwidth),
538                                       ob_rr_theme->title_height + self->bwidth,
539                                       self->width,
540                                       self->bwidth);
541
542                     XMapWindow(ob_display, self->titlebottom);
543                 } else
544                     XUnmapWindow(ob_display, self->titlebottom);
545             } else {
546                 XUnmapWindow(ob_display, self->titlebottom);
547
548                 XUnmapWindow(ob_display, self->titletop);
549                 XUnmapWindow(ob_display, self->titletopleft);
550                 XUnmapWindow(ob_display, self->titletopright);
551                 XUnmapWindow(ob_display, self->titleleft);
552                 XUnmapWindow(ob_display, self->titleright);
553             }
554
555             if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
556                 XMoveResizeWindow(ob_display, self->title,
557                                   (self->max_horz ? 0 : self->bwidth),
558                                   self->bwidth,
559                                   self->width, ob_rr_theme->title_height);
560
561                 XMapWindow(ob_display, self->title);
562
563                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {
564                     XMoveResizeWindow(ob_display, self->topresize,
565                                       ob_rr_theme->grip_width,
566                                       0,
567                                       self->width - ob_rr_theme->grip_width *2,
568                                       ob_rr_theme->paddingy + 1);
569
570                     XMoveWindow(ob_display, self->tltresize, 0, 0);
571                     XMoveWindow(ob_display, self->tllresize, 0, 0);
572                     XMoveWindow(ob_display, self->trtresize,
573                                 self->width - ob_rr_theme->grip_width, 0);
574                     XMoveWindow(ob_display, self->trrresize,
575                                 self->width - ob_rr_theme->paddingx - 1, 0);
576
577                     XMapWindow(ob_display, self->topresize);
578                     XMapWindow(ob_display, self->tltresize);
579                     XMapWindow(ob_display, self->tllresize);
580                     XMapWindow(ob_display, self->trtresize);
581                     XMapWindow(ob_display, self->trrresize);
582                 } else {
583                     XUnmapWindow(ob_display, self->topresize);
584                     XUnmapWindow(ob_display, self->tltresize);
585                     XUnmapWindow(ob_display, self->tllresize);
586                     XUnmapWindow(ob_display, self->trtresize);
587                     XUnmapWindow(ob_display, self->trrresize);
588                 }
589             } else
590                 XUnmapWindow(ob_display, self->title);
591         }
592
593         if ((self->decorations & OB_FRAME_DECOR_TITLEBAR))
594             /* layout the title bar elements */
595             layout_title(self);
596
597         if (!fake) {
598             gint sidebwidth = self->max_horz ? 0 : self->bwidth;
599
600             if (self->bwidth && self->size.bottom) {
601                 XMoveResizeWindow(ob_display, self->handlebottom,
602                                   ob_rr_theme->grip_width +
603                                   self->bwidth + sidebwidth,
604                                   self->size.top + self->client->area.height +
605                                   self->size.bottom - self->bwidth,
606                                   self->width - (ob_rr_theme->grip_width +
607                                                  sidebwidth) * 2,
608                                   self->bwidth);
609
610
611                 if (sidebwidth) {
612                     XMoveResizeWindow(ob_display, self->lgripleft,
613                                       0,
614                                       self->size.top +
615                                       self->client->area.height +
616                                       self->size.bottom -
617                                       (!self->max_horz ?
618                                        ob_rr_theme->grip_width :
619                                        self->size.bottom - self->cbwidth_b),
620                                       self->bwidth,
621                                       (!self->max_horz ?
622                                        ob_rr_theme->grip_width :
623                                        self->size.bottom - self->cbwidth_b));
624                     XMoveResizeWindow(ob_display, self->rgripright,
625                                   self->size.left +
626                                       self->client->area.width +
627                                       self->size.right - self->bwidth,
628                                       self->size.top +
629                                       self->client->area.height +
630                                       self->size.bottom -
631                                       (!self->max_horz ?
632                                        ob_rr_theme->grip_width :
633                                        self->size.bottom - self->cbwidth_b),
634                                       self->bwidth,
635                                       (!self->max_horz ?
636                                        ob_rr_theme->grip_width :
637                                        self->size.bottom - self->cbwidth_b));
638
639                     XMapWindow(ob_display, self->lgripleft);
640                     XMapWindow(ob_display, self->rgripright);
641                 } else {
642                     XUnmapWindow(ob_display, self->lgripleft);
643                     XUnmapWindow(ob_display, self->rgripright);
644                 }
645
646                 XMoveResizeWindow(ob_display, self->lgripbottom,
647                                   sidebwidth,
648                                   self->size.top + self->client->area.height +
649                                   self->size.bottom - self->bwidth,
650                                   ob_rr_theme->grip_width + self->bwidth,
651                                   self->bwidth);
652                 XMoveResizeWindow(ob_display, self->rgripbottom,
653                                   self->size.left + self->client->area.width +
654                                   self->size.right - self->bwidth - sidebwidth-
655                                   ob_rr_theme->grip_width,
656                                   self->size.top + self->client->area.height +
657                                   self->size.bottom - self->bwidth,
658                                   ob_rr_theme->grip_width + self->bwidth,
659                                   self->bwidth);
660
661                 XMapWindow(ob_display, self->handlebottom);
662                 XMapWindow(ob_display, self->lgripbottom);
663                 XMapWindow(ob_display, self->rgripbottom);
664
665                 if (self->decorations & OB_FRAME_DECOR_HANDLE &&
666                     ob_rr_theme->handle_height > 0)
667                 {
668                     XMoveResizeWindow(ob_display, self->handletop,
669                                       ob_rr_theme->grip_width +
670                                       self->bwidth + sidebwidth,
671                                       FRAME_HANDLE_Y(self),
672                                       self->width - (ob_rr_theme->grip_width +
673                                                      sidebwidth) * 2,
674                                       self->bwidth);
675                     XMapWindow(ob_display, self->handletop);
676
677                     if (self->decorations & OB_FRAME_DECOR_GRIPS) {
678                         XMoveResizeWindow(ob_display, self->handleleft,
679                                           ob_rr_theme->grip_width,
680                                           0,
681                                           self->bwidth,
682                                           ob_rr_theme->handle_height);
683                         XMoveResizeWindow(ob_display, self->handleright,
684                                           self->width -
685                                           ob_rr_theme->grip_width -
686                                           self->bwidth,
687                                           0,
688                                           self->bwidth,
689                                           ob_rr_theme->handle_height);
690
691                         XMoveResizeWindow(ob_display, self->lgriptop,
692                                           sidebwidth,
693                                           FRAME_HANDLE_Y(self),
694                                           ob_rr_theme->grip_width +
695                                           self->bwidth,
696                                           self->bwidth);
697                         XMoveResizeWindow(ob_display, self->rgriptop,
698                                           self->size.left +
699                                           self->client->area.width +
700                                           self->size.right - self->bwidth -
701                                           sidebwidth - ob_rr_theme->grip_width,
702                                           FRAME_HANDLE_Y(self),
703                                           ob_rr_theme->grip_width +
704                                           self->bwidth,
705                                           self->bwidth);
706
707                         XMapWindow(ob_display, self->handleleft);
708                         XMapWindow(ob_display, self->handleright);
709                         XMapWindow(ob_display, self->lgriptop);
710                         XMapWindow(ob_display, self->rgriptop);
711                     } else {
712                         XUnmapWindow(ob_display, self->handleleft);
713                         XUnmapWindow(ob_display, self->handleright);
714                         XUnmapWindow(ob_display, self->lgriptop);
715                         XUnmapWindow(ob_display, self->rgriptop);
716                     }
717                 } else {
718                     XUnmapWindow(ob_display, self->handleleft);
719                     XUnmapWindow(ob_display, self->handleright);
720                     XUnmapWindow(ob_display, self->lgriptop);
721                     XUnmapWindow(ob_display, self->rgriptop);
722
723                     XUnmapWindow(ob_display, self->handletop);
724                 }
725             } else {
726                 XUnmapWindow(ob_display, self->handleleft);
727                 XUnmapWindow(ob_display, self->handleright);
728                 XUnmapWindow(ob_display, self->lgriptop);
729                 XUnmapWindow(ob_display, self->rgriptop);
730
731                 XUnmapWindow(ob_display, self->handletop);
732
733                 XUnmapWindow(ob_display, self->handlebottom);
734                 XUnmapWindow(ob_display, self->lgripleft);
735                 XUnmapWindow(ob_display, self->rgripright);
736                 XUnmapWindow(ob_display, self->lgripbottom);
737                 XUnmapWindow(ob_display, self->rgripbottom);
738             }
739
740             if (self->decorations & OB_FRAME_DECOR_HANDLE &&
741                 ob_rr_theme->handle_height > 0)
742             {
743                 XMoveResizeWindow(ob_display, self->handle,
744                                   sidebwidth,
745                                   FRAME_HANDLE_Y(self) + self->bwidth,
746                                   self->width, ob_rr_theme->handle_height);
747                 XMapWindow(ob_display, self->handle);
748
749                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {
750                     XMoveResizeWindow(ob_display, self->lgrip,
751                                       0, 0,
752                                       ob_rr_theme->grip_width,
753                                       ob_rr_theme->handle_height);
754                     XMoveResizeWindow(ob_display, self->rgrip,
755                                       self->width - ob_rr_theme->grip_width,
756                                       0,
757                                       ob_rr_theme->grip_width,
758                                       ob_rr_theme->handle_height);
759
760                     XMapWindow(ob_display, self->lgrip);
761                     XMapWindow(ob_display, self->rgrip);
762                 } else {
763                     XUnmapWindow(ob_display, self->lgrip);
764                     XUnmapWindow(ob_display, self->rgrip);
765                 }
766             } else {
767                 XUnmapWindow(ob_display, self->lgrip);
768                 XUnmapWindow(ob_display, self->rgrip);
769
770                 XUnmapWindow(ob_display, self->handle);
771             }
772
773             if (self->bwidth && !self->max_horz &&
774                 (self->client->area.height + self->size.top +
775                  self->size.bottom) > ob_rr_theme->grip_width * 2)
776             {
777                 XMoveResizeWindow(ob_display, self->left,
778                                   0,
779                                   self->bwidth + ob_rr_theme->grip_width,
780                                   self->bwidth,
781                                   self->client->area.height +
782                                   self->size.top + self->size.bottom -
783                                   ob_rr_theme->grip_width * 2);
784
785                 XMapWindow(ob_display, self->left);
786             } else
787                 XUnmapWindow(ob_display, self->left);
788
789             if (self->bwidth && !self->max_horz &&
790                 (self->client->area.height + self->size.top +
791                  self->size.bottom) > ob_rr_theme->grip_width * 2)
792             {
793                 XMoveResizeWindow(ob_display, self->right,
794                                   self->client->area.width + self->cbwidth_l +
795                                   self->cbwidth_r + self->bwidth,
796                                   self->bwidth + ob_rr_theme->grip_width,
797                                   self->bwidth,
798                                   self->client->area.height +
799                                   self->size.top + self->size.bottom -
800                                   ob_rr_theme->grip_width * 2);
801
802                 XMapWindow(ob_display, self->right);
803             } else
804                 XUnmapWindow(ob_display, self->right);
805
806             XMoveResizeWindow(ob_display, self->backback,
807                               self->size.left, self->size.top,
808                               self->client->area.width,
809                               self->client->area.height);
810         }
811     }
812
813     /* shading can change without being moved or resized */
814     RECT_SET_SIZE(self->area,
815                   self->client->area.width +
816                   self->size.left + self->size.right,
817                   (self->client->shaded ?
818                    ob_rr_theme->title_height + self->bwidth * 2:
819                    self->client->area.height +
820                    self->size.top + self->size.bottom));
821
822     if ((moved || resized) && !fake) {
823         /* find the new coordinates, done after setting the frame.size, for
824            frame_client_gravity. */
825         self->area.x = self->client->area.x;
826         self->area.y = self->client->area.y;
827         frame_client_gravity(self, &self->area.x, &self->area.y);
828     }
829
830     if (!fake) {
831         if (!frame_iconify_animating(self))
832             /* move and resize the top level frame.
833                shading can change without being moved or resized.
834
835                but don't do this during an iconify animation. it will be
836                reflected afterwards.
837             */
838             XMoveResizeWindow(ob_display, self->window,
839                               self->area.x,
840                               self->area.y,
841                               self->area.width,
842                               self->area.height);
843
844         /* when the client has StaticGravity, it likes to move around.
845            also this correctly positions the client when it maps.
846            this also needs to be run when the frame's decorations sizes change!
847         */
848         XMoveWindow(ob_display, self->client->window,
849                     self->size.left, self->size.top);
850
851         if (resized) {
852             self->need_render = TRUE;
853             framerender_frame(self);
854             frame_adjust_shape(self);
855         }
856
857         if (!STRUT_EQUAL(self->size, oldsize)) {
858             gulong vals[4];
859             vals[0] = self->size.left;
860             vals[1] = self->size.right;
861             vals[2] = self->size.top;
862             vals[3] = self->size.bottom;
863             PROP_SETA32(self->client->window, net_frame_extents,
864                         cardinal, vals, 4);
865             PROP_SETA32(self->client->window, kde_net_wm_frame_strut,
866                         cardinal, vals, 4);
867         }
868
869         /* if this occurs while we are focus cycling, the indicator needs to
870            match the changes */
871         if (focus_cycle_target == self->client)
872             focus_cycle_draw_indicator(self->client);
873     }
874     if (resized && (self->decorations & OB_FRAME_DECOR_TITLEBAR))
875         XResizeWindow(ob_display, self->label, self->label_width,
876                       ob_rr_theme->label_height);
877
878 }
879
880 static void frame_adjust_cursors(ObFrame *self)
881 {
882     if ((self->functions & OB_CLIENT_FUNC_RESIZE) !=
883         (self->client->functions & OB_CLIENT_FUNC_RESIZE) ||
884         self->max_horz != self->client->max_horz ||
885         self->max_vert != self->client->max_vert ||
886         self->shaded != self->client->shaded)
887     {
888         gboolean r = (self->client->functions & OB_CLIENT_FUNC_RESIZE) &&
889             !(self->client->max_horz && self->client->max_vert);
890         gboolean topbot = !self->client->max_vert;
891         gboolean sh = self->client->shaded;
892         XSetWindowAttributes a;
893
894         /* these ones turn off when max vert, and some when shaded */
895         a.cursor = ob_cursor(r && topbot && !sh ?
896                              OB_CURSOR_NORTH : OB_CURSOR_NONE);
897         XChangeWindowAttributes(ob_display, self->topresize, CWCursor, &a);
898         XChangeWindowAttributes(ob_display, self->titletop, CWCursor, &a);
899         a.cursor = ob_cursor(r && topbot ? OB_CURSOR_SOUTH : OB_CURSOR_NONE);
900         XChangeWindowAttributes(ob_display, self->handle, CWCursor, &a);
901         XChangeWindowAttributes(ob_display, self->handletop, CWCursor, &a);
902         XChangeWindowAttributes(ob_display, self->handlebottom, CWCursor, &a);
903         XChangeWindowAttributes(ob_display, self->innerbottom, CWCursor, &a);
904
905         /* these ones change when shaded */
906         a.cursor = ob_cursor(r ? (sh ? OB_CURSOR_WEST : OB_CURSOR_NORTHWEST) :
907                              OB_CURSOR_NONE);
908         XChangeWindowAttributes(ob_display, self->titleleft, CWCursor, &a);
909         XChangeWindowAttributes(ob_display, self->tltresize, CWCursor, &a);
910         XChangeWindowAttributes(ob_display, self->tllresize, CWCursor, &a);
911         XChangeWindowAttributes(ob_display, self->titletopleft, CWCursor, &a);
912         a.cursor = ob_cursor(r ? (sh ? OB_CURSOR_EAST : OB_CURSOR_NORTHEAST) :
913                              OB_CURSOR_NONE);
914         XChangeWindowAttributes(ob_display, self->titleright, CWCursor, &a);
915         XChangeWindowAttributes(ob_display, self->trtresize, CWCursor, &a);
916         XChangeWindowAttributes(ob_display, self->trrresize, CWCursor, &a);
917         XChangeWindowAttributes(ob_display, self->titletopright, CWCursor, &a);
918
919         /* these ones are pretty static */
920         a.cursor = ob_cursor(r ? OB_CURSOR_WEST : OB_CURSOR_NONE);
921         XChangeWindowAttributes(ob_display, self->left, CWCursor, &a);
922         XChangeWindowAttributes(ob_display, self->innerleft, CWCursor, &a);
923         a.cursor = ob_cursor(r ? OB_CURSOR_EAST : OB_CURSOR_NONE);
924         XChangeWindowAttributes(ob_display, self->right, CWCursor, &a);
925         XChangeWindowAttributes(ob_display, self->innerright, CWCursor, &a);
926         a.cursor = ob_cursor(r ? OB_CURSOR_SOUTHWEST : OB_CURSOR_NONE);
927         XChangeWindowAttributes(ob_display, self->lgrip, CWCursor, &a);
928         XChangeWindowAttributes(ob_display, self->handleleft, CWCursor, &a);
929         XChangeWindowAttributes(ob_display, self->lgripleft, CWCursor, &a);
930         XChangeWindowAttributes(ob_display, self->lgriptop, CWCursor, &a);
931         XChangeWindowAttributes(ob_display, self->lgripbottom, CWCursor, &a);
932         XChangeWindowAttributes(ob_display, self->innerbll, CWCursor, &a);
933         XChangeWindowAttributes(ob_display, self->innerblb, CWCursor, &a);
934         a.cursor = ob_cursor(r ? OB_CURSOR_SOUTHEAST : OB_CURSOR_NONE);
935         XChangeWindowAttributes(ob_display, self->rgrip, CWCursor, &a);
936         XChangeWindowAttributes(ob_display, self->handleright, CWCursor, &a);
937         XChangeWindowAttributes(ob_display, self->rgripright, CWCursor, &a);
938         XChangeWindowAttributes(ob_display, self->rgriptop, CWCursor, &a);
939         XChangeWindowAttributes(ob_display, self->rgripbottom, CWCursor, &a);
940         XChangeWindowAttributes(ob_display, self->innerbrr, CWCursor, &a);
941         XChangeWindowAttributes(ob_display, self->innerbrb, CWCursor, &a);
942     }
943 }
944
945 void frame_adjust_client_area(ObFrame *self)
946 {
947     /* adjust the window which is there to prevent flashing on unmap */
948     XMoveResizeWindow(ob_display, self->backfront, 0, 0,
949                       self->client->area.width,
950                       self->client->area.height);
951 }
952
953 void frame_adjust_state(ObFrame *self)
954 {
955     self->need_render = TRUE;
956     framerender_frame(self);
957 }
958
959 void frame_adjust_focus(ObFrame *self, gboolean hilite)
960 {
961     self->focused = hilite;
962     self->need_render = TRUE;
963     framerender_frame(self);
964     XFlush(ob_display);
965 }
966
967 void frame_adjust_title(ObFrame *self)
968 {
969     self->need_render = TRUE;
970     framerender_frame(self);
971 }
972
973 void frame_adjust_icon(ObFrame *self)
974 {
975     self->need_render = TRUE;
976     framerender_frame(self);
977 }
978
979 void frame_grab_client(ObFrame *self)
980 {
981     /* DO NOT map the client window here. we used to do that, but it is bogus.
982        we need to set up the client's dimensions and everything before we
983        send a mapnotify or we create race conditions.
984     */
985
986     /* reparent the client to the frame */
987     XReparentWindow(ob_display, self->client->window, self->window, 0, 0);
988
989     /*
990       When reparenting the client window, it is usually not mapped yet, since
991       this occurs from a MapRequest. However, in the case where Openbox is
992       starting up, the window is already mapped, so we'll see an unmap event
993       for it.
994     */
995     if (ob_state() == OB_STATE_STARTING)
996         ++self->client->ignore_unmaps;
997
998     /* select the event mask on the client's parent (to receive config/map
999        req's) the ButtonPress is to catch clicks on the client border */
1000     XSelectInput(ob_display, self->window, FRAME_EVENTMASK);
1001
1002     /* set all the windows for the frame in the window_map */
1003     g_hash_table_insert(window_map, &self->window, self->client);
1004     g_hash_table_insert(window_map, &self->backback, self->client);
1005     g_hash_table_insert(window_map, &self->backfront, self->client);
1006     g_hash_table_insert(window_map, &self->innerleft, self->client);
1007     g_hash_table_insert(window_map, &self->innertop, self->client);
1008     g_hash_table_insert(window_map, &self->innerright, self->client);
1009     g_hash_table_insert(window_map, &self->innerbottom, self->client);
1010     g_hash_table_insert(window_map, &self->title, self->client);
1011     g_hash_table_insert(window_map, &self->label, self->client);
1012     g_hash_table_insert(window_map, &self->max, self->client);
1013     g_hash_table_insert(window_map, &self->close, self->client);
1014     g_hash_table_insert(window_map, &self->desk, self->client);
1015     g_hash_table_insert(window_map, &self->shade, self->client);
1016     g_hash_table_insert(window_map, &self->icon, self->client);
1017     g_hash_table_insert(window_map, &self->iconify, self->client);
1018     g_hash_table_insert(window_map, &self->handle, self->client);
1019     g_hash_table_insert(window_map, &self->lgrip, self->client);
1020     g_hash_table_insert(window_map, &self->rgrip, self->client);
1021     g_hash_table_insert(window_map, &self->topresize, self->client);
1022     g_hash_table_insert(window_map, &self->tltresize, self->client);
1023     g_hash_table_insert(window_map, &self->tllresize, self->client);
1024     g_hash_table_insert(window_map, &self->trtresize, self->client);
1025     g_hash_table_insert(window_map, &self->trrresize, self->client);
1026     g_hash_table_insert(window_map, &self->left, self->client);
1027     g_hash_table_insert(window_map, &self->right, self->client);
1028     g_hash_table_insert(window_map, &self->titleleft, self->client);
1029     g_hash_table_insert(window_map, &self->titletop, self->client);
1030     g_hash_table_insert(window_map, &self->titletopleft, self->client);
1031     g_hash_table_insert(window_map, &self->titletopright, self->client);
1032     g_hash_table_insert(window_map, &self->titleright, self->client);
1033     g_hash_table_insert(window_map, &self->titlebottom, self->client);
1034     g_hash_table_insert(window_map, &self->handleleft, self->client);
1035     g_hash_table_insert(window_map, &self->handletop, self->client);
1036     g_hash_table_insert(window_map, &self->handleright, self->client);
1037     g_hash_table_insert(window_map, &self->handlebottom, self->client);
1038     g_hash_table_insert(window_map, &self->lgripleft, self->client);
1039     g_hash_table_insert(window_map, &self->lgriptop, self->client);
1040     g_hash_table_insert(window_map, &self->lgripbottom, self->client);
1041     g_hash_table_insert(window_map, &self->rgripright, self->client);
1042     g_hash_table_insert(window_map, &self->rgriptop, self->client);
1043     g_hash_table_insert(window_map, &self->rgripbottom, self->client);
1044 }
1045
1046 void frame_release_client(ObFrame *self)
1047 {
1048     XEvent ev;
1049     gboolean reparent = TRUE;
1050
1051     /* if there was any animation going on, kill it */
1052     ob_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
1053                                      self, FALSE);
1054
1055     /* check if the app has already reparented its window away */
1056     while (XCheckTypedWindowEvent(ob_display, self->client->window,
1057                                   ReparentNotify, &ev))
1058     {
1059         /* This check makes sure we don't catch our own reparent action to
1060            our frame window. This doesn't count as the app reparenting itself
1061            away of course.
1062
1063            Reparent events that are generated by us are just discarded here.
1064            They are of no consequence to us anyhow.
1065         */
1066         if (ev.xreparent.parent != self->window) {
1067             reparent = FALSE;
1068             XPutBackEvent(ob_display, &ev);
1069             break;
1070         }
1071     }
1072
1073     if (reparent) {
1074         /* according to the ICCCM - if the client doesn't reparent itself,
1075            then we will reparent the window to root for them */
1076         XReparentWindow(ob_display, self->client->window,
1077                         RootWindow(ob_display, ob_screen),
1078                         self->client->area.x,
1079                         self->client->area.y);
1080     }
1081
1082     /* remove all the windows for the frame from the window_map */
1083     g_hash_table_remove(window_map, &self->window);
1084     g_hash_table_remove(window_map, &self->backback);
1085     g_hash_table_remove(window_map, &self->backfront);
1086     g_hash_table_remove(window_map, &self->innerleft);
1087     g_hash_table_remove(window_map, &self->innertop);
1088     g_hash_table_remove(window_map, &self->innerright);
1089     g_hash_table_remove(window_map, &self->innerbottom);
1090     g_hash_table_remove(window_map, &self->title);
1091     g_hash_table_remove(window_map, &self->label);
1092     g_hash_table_remove(window_map, &self->max);
1093     g_hash_table_remove(window_map, &self->close);
1094     g_hash_table_remove(window_map, &self->desk);
1095     g_hash_table_remove(window_map, &self->shade);
1096     g_hash_table_remove(window_map, &self->icon);
1097     g_hash_table_remove(window_map, &self->iconify);
1098     g_hash_table_remove(window_map, &self->handle);
1099     g_hash_table_remove(window_map, &self->lgrip);
1100     g_hash_table_remove(window_map, &self->rgrip);
1101     g_hash_table_remove(window_map, &self->topresize);
1102     g_hash_table_remove(window_map, &self->tltresize);
1103     g_hash_table_remove(window_map, &self->tllresize);
1104     g_hash_table_remove(window_map, &self->trtresize);
1105     g_hash_table_remove(window_map, &self->trrresize);
1106     g_hash_table_remove(window_map, &self->left);
1107     g_hash_table_remove(window_map, &self->right);
1108     g_hash_table_remove(window_map, &self->titleleft);
1109     g_hash_table_remove(window_map, &self->titletop);
1110     g_hash_table_remove(window_map, &self->titletopleft);
1111     g_hash_table_remove(window_map, &self->titletopright);
1112     g_hash_table_remove(window_map, &self->titleright);
1113     g_hash_table_remove(window_map, &self->titlebottom);
1114     g_hash_table_remove(window_map, &self->handleleft);
1115     g_hash_table_remove(window_map, &self->handletop);
1116     g_hash_table_remove(window_map, &self->handleright);
1117     g_hash_table_remove(window_map, &self->handlebottom);
1118     g_hash_table_remove(window_map, &self->lgripleft);
1119     g_hash_table_remove(window_map, &self->lgriptop);
1120     g_hash_table_remove(window_map, &self->lgripbottom);
1121     g_hash_table_remove(window_map, &self->rgripright);
1122     g_hash_table_remove(window_map, &self->rgriptop);
1123     g_hash_table_remove(window_map, &self->rgripbottom);
1124
1125     ob_main_loop_timeout_remove_data(ob_main_loop, flash_timeout, self, TRUE);
1126 }
1127
1128 /* is there anything present between us and the label? */
1129 static gboolean is_button_present(ObFrame *self, const gchar *lc, gint dir) {
1130     for (; *lc != '\0' && lc >= config_title_layout; lc += dir) {
1131         if (*lc == ' ') continue; /* it was invalid */
1132         if (*lc == 'N' && self->decorations & OB_FRAME_DECOR_ICON)
1133             return TRUE;
1134         if (*lc == 'D' && self->decorations & OB_FRAME_DECOR_ALLDESKTOPS)
1135             return TRUE;
1136         if (*lc == 'S' && self->decorations & OB_FRAME_DECOR_SHADE)
1137             return TRUE;
1138         if (*lc == 'I' && self->decorations & OB_FRAME_DECOR_ICONIFY)
1139             return TRUE;
1140         if (*lc == 'M' && self->decorations & OB_FRAME_DECOR_MAXIMIZE)
1141             return TRUE;
1142         if (*lc == 'C' && self->decorations & OB_FRAME_DECOR_CLOSE)
1143             return TRUE;
1144         if (*lc == 'L') return FALSE;
1145     }
1146     return FALSE;
1147 }
1148
1149 static void layout_title(ObFrame *self)
1150 {
1151     gchar *lc;
1152     gint i;
1153
1154     const gint bwidth = ob_rr_theme->button_size + ob_rr_theme->paddingx + 1;
1155     /* position of the left most button */
1156     const gint left = ob_rr_theme->paddingx + 1;
1157     /* position of the right most button */
1158     const gint right = self->width;
1159
1160     /* turn them all off */
1161     self->icon_on = self->desk_on = self->shade_on = self->iconify_on =
1162         self->max_on = self->close_on = self->label_on = FALSE;
1163     self->label_width = self->width - (ob_rr_theme->paddingx + 1) * 2;
1164     self->leftmost = self->rightmost = OB_FRAME_CONTEXT_NONE;
1165
1166     /* figure out what's being show, find each element's position, and the
1167        width of the label
1168
1169        do the ones before the label, then after the label,
1170        i will be +1 the first time through when working to the left,
1171        and -1 the second time through when working to the right */
1172     for (i = 1; i >= -1; i-=2) {
1173         gint x;
1174         ObFrameContext *firstcon;
1175
1176         if (i > 0) {
1177             x = left;
1178             lc = config_title_layout;
1179             firstcon = &self->leftmost;
1180         } else {
1181             x = right;
1182             lc = config_title_layout + strlen(config_title_layout)-1;
1183             firstcon = &self->rightmost;
1184         }
1185
1186         /* stop at the end of the string (or the label, which calls break) */
1187         for (; *lc != '\0' && lc >= config_title_layout; lc+=i) {
1188             if (*lc == 'L') {
1189                 if (i > 0) {
1190                     self->label_on = TRUE;
1191                     self->label_x = x;
1192                 }
1193                 break; /* break the for loop, do other side of label */
1194             } else if (*lc == 'N') {
1195                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICON;
1196                 if ((self->icon_on = is_button_present(self, lc, i))) {
1197                     /* icon is bigger than buttons */
1198                     self->label_width -= bwidth + 2;
1199                     if (i > 0) self->icon_x = x;
1200                     x += i * (bwidth + 2);
1201                     if (i < 0) self->icon_x = x;
1202                 }
1203             } else if (*lc == 'D') {
1204                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ALLDESKTOPS;
1205                 if ((self->desk_on = is_button_present(self, lc, i))) {
1206                     self->label_width -= bwidth;
1207                     if (i > 0) self->desk_x = x;
1208                     x += i * bwidth;
1209                     if (i < 0) self->desk_x = x;
1210                 }
1211             } else if (*lc == 'S') {
1212                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_SHADE;
1213                 if ((self->shade_on = is_button_present(self, lc, i))) {
1214                     self->label_width -= bwidth;
1215                     if (i > 0) self->shade_x = x;
1216                     x += i * bwidth;
1217                     if (i < 0) self->shade_x = x;
1218                 }
1219             } else if (*lc == 'I') {
1220                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICONIFY;
1221                 if ((self->iconify_on = is_button_present(self, lc, i))) {
1222                     self->label_width -= bwidth;
1223                     if (i > 0) self->iconify_x = x;
1224                     x += i * bwidth;
1225                     if (i < 0) self->iconify_x = x;
1226                 }
1227             } else if (*lc == 'M') {
1228                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_MAXIMIZE;
1229                 if ((self->max_on = is_button_present(self, lc, i))) {
1230                     self->label_width -= bwidth;
1231                     if (i > 0) self->max_x = x;
1232                     x += i * bwidth;
1233                     if (i < 0) self->max_x = x;
1234                 }
1235             } else if (*lc == 'C') {
1236                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_CLOSE;
1237                 if ((self->close_on = is_button_present(self, lc, i))) {
1238                     self->label_width -= bwidth;
1239                     if (i > 0) self->close_x = x;
1240                     x += i * bwidth;
1241                     if (i < 0) self->close_x = x;
1242                 }
1243             } else
1244                 continue; /* don't set firstcon */
1245             firstcon = NULL;
1246         }
1247     }
1248
1249     /* position and map the elements */
1250     if (self->icon_on) {
1251         XMapWindow(ob_display, self->icon);
1252         XMoveWindow(ob_display, self->icon, self->icon_x,
1253                     ob_rr_theme->paddingy);
1254     } else
1255         XUnmapWindow(ob_display, self->icon);
1256
1257     if (self->desk_on) {
1258         XMapWindow(ob_display, self->desk);
1259         XMoveWindow(ob_display, self->desk, self->desk_x,
1260                     ob_rr_theme->paddingy + 1);
1261     } else
1262         XUnmapWindow(ob_display, self->desk);
1263
1264     if (self->shade_on) {
1265         XMapWindow(ob_display, self->shade);
1266         XMoveWindow(ob_display, self->shade, self->shade_x,
1267                     ob_rr_theme->paddingy + 1);
1268     } else
1269         XUnmapWindow(ob_display, self->shade);
1270
1271     if (self->iconify_on) {
1272         XMapWindow(ob_display, self->iconify);
1273         XMoveWindow(ob_display, self->iconify, self->iconify_x,
1274                     ob_rr_theme->paddingy + 1);
1275     } else
1276         XUnmapWindow(ob_display, self->iconify);
1277
1278     if (self->max_on) {
1279         XMapWindow(ob_display, self->max);
1280         XMoveWindow(ob_display, self->max, self->max_x,
1281                     ob_rr_theme->paddingy + 1);
1282     } else
1283         XUnmapWindow(ob_display, self->max);
1284
1285     if (self->close_on) {
1286         XMapWindow(ob_display, self->close);
1287         XMoveWindow(ob_display, self->close, self->close_x,
1288                     ob_rr_theme->paddingy + 1);
1289     } else
1290         XUnmapWindow(ob_display, self->close);
1291
1292     if (self->label_on) {
1293         self->label_width = MAX(1, self->label_width); /* no lower than 1 */
1294         XMapWindow(ob_display, self->label);
1295         XMoveWindow(ob_display, self->label, self->label_x,
1296                     ob_rr_theme->paddingy);
1297     } else
1298         XUnmapWindow(ob_display, self->label);
1299 }
1300
1301 ObFrameContext frame_context_from_string(const gchar *name)
1302 {
1303     if (!g_ascii_strcasecmp("Desktop", name))
1304         return OB_FRAME_CONTEXT_DESKTOP;
1305     else if (!g_ascii_strcasecmp("Root", name))
1306         return OB_FRAME_CONTEXT_ROOT;
1307     else if (!g_ascii_strcasecmp("Client", name))
1308         return OB_FRAME_CONTEXT_CLIENT;
1309     else if (!g_ascii_strcasecmp("Titlebar", name))
1310         return OB_FRAME_CONTEXT_TITLEBAR;
1311     else if (!g_ascii_strcasecmp("Frame", name))
1312         return OB_FRAME_CONTEXT_FRAME;
1313     else if (!g_ascii_strcasecmp("TLCorner", name))
1314         return OB_FRAME_CONTEXT_TLCORNER;
1315     else if (!g_ascii_strcasecmp("TRCorner", name))
1316         return OB_FRAME_CONTEXT_TRCORNER;
1317     else if (!g_ascii_strcasecmp("BLCorner", name))
1318         return OB_FRAME_CONTEXT_BLCORNER;
1319     else if (!g_ascii_strcasecmp("BRCorner", name))
1320         return OB_FRAME_CONTEXT_BRCORNER;
1321     else if (!g_ascii_strcasecmp("Top", name))
1322         return OB_FRAME_CONTEXT_TOP;
1323     else if (!g_ascii_strcasecmp("Bottom", 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_BRCORNER;
1442     if (win == self->rgriptop)          return OB_FRAME_CONTEXT_BRCORNER;
1443     if (win == self->rgripbottom)       return OB_FRAME_CONTEXT_BRCORNER;
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 }