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