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