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