]> Dogcows Code - chaz/openbox/blob - src/bbwindow.cc
ea0bb55c7cdece4bc97d5ff459cc16dcbfac0331
[chaz/openbox] / src / bbwindow.cc
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2
3 #ifdef HAVE_CONFIG_H
4 # include "../config.h"
5 #endif // HAVE_CONFIG_H
6
7 extern "C" {
8 #include <X11/Xatom.h>
9 #include <X11/keysym.h>
10
11 #ifdef HAVE_STRING_H
12 # include <string.h>
13 #endif // HAVE_STRING_H
14
15 #ifdef DEBUG
16 # ifdef HAVE_STDIO_H
17 # include <stdio.h>
18 # endif // HAVE_STDIO_H
19 #endif // DEBUG
20
21 #ifdef HAVE_STDLIB_H
22 # include <stdlib.h>
23 #endif // HAVE_STDLIB_H
24 }
25
26 #include "blackbox.hh"
27 #include "font.hh"
28 #include "gccache.hh"
29 #include "image.hh"
30 #include "bbscreen.hh"
31 #include "bbwindow.hh"
32 #include "workspace.hh"
33
34 #include "otk/util.hh"
35 #include "otk/style.hh"
36
37 using std::string;
38 using std::abs;
39
40 namespace ob {
41
42 /*
43 * Initializes the class with default values/the window's set initial values.
44 */
45 BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
46 // fprintf(stderr, "BlackboxWindow size: %d bytes\n",
47 // sizeof(BlackboxWindow));
48
49 #ifdef DEBUG
50 fprintf(stderr, "BlackboxWindow::BlackboxWindow(): creating 0x%lx\n", w);
51 #endif // DEBUG
52
53 /*
54 set timer to zero... it is initialized properly later, so we check
55 if timer is zero in the destructor, and assume that the window is not
56 fully constructed if timer is zero...
57 */
58 timer = 0;
59 blackbox = b;
60 client.window = w;
61 screen = s;
62 xatom = blackbox->getXAtom();
63
64 if (! validateClient()) {
65 delete this;
66 return;
67 }
68
69 // fetch client size and placement
70 XWindowAttributes wattrib;
71 if (! XGetWindowAttributes(otk::OBDisplay::display,
72 client.window, &wattrib) ||
73 ! wattrib.screen || wattrib.override_redirect) {
74 #ifdef DEBUG
75 fprintf(stderr,
76 "BlackboxWindow::BlackboxWindow(): XGetWindowAttributes failed\n");
77 #endif // DEBUG
78
79 delete this;
80 return;
81 }
82
83 // set the eventmask early in the game so that we make sure we get
84 // all the events we are interested in
85 XSetWindowAttributes attrib_set;
86 attrib_set.event_mask = PropertyChangeMask | FocusChangeMask |
87 StructureNotifyMask;
88 attrib_set.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask |
89 ButtonMotionMask;
90 XChangeWindowAttributes(otk::OBDisplay::display, client.window,
91 CWEventMask|CWDontPropagate, &attrib_set);
92
93 flags.moving = flags.resizing = flags.shaded = flags.visible =
94 flags.iconic = flags.focused = flags.stuck = flags.modal =
95 flags.send_focus_message = flags.shaped = flags.skip_taskbar =
96 flags.skip_pager = flags.fullscreen = False;
97 flags.maximized = 0;
98
99 blackbox_attrib.workspace = window_number = otk::BSENTINEL;
100
101 blackbox_attrib.flags = blackbox_attrib.attrib = blackbox_attrib.stack = 0l;
102 blackbox_attrib.decoration = DecorNormal;
103 blackbox_attrib.premax_x = blackbox_attrib.premax_y = 0;
104 blackbox_attrib.premax_w = blackbox_attrib.premax_h = 0;
105
106 frame.border_w = 1;
107 frame.window = frame.plate = frame.title = frame.handle = None;
108 frame.close_button = frame.iconify_button = frame.maximize_button =
109 frame.stick_button = None;
110 frame.right_grip = frame.left_grip = None;
111
112 frame.ulabel_pixel = frame.flabel_pixel = frame.utitle_pixel =
113 frame.ftitle_pixel = frame.uhandle_pixel = frame.fhandle_pixel =
114 frame.ubutton_pixel = frame.fbutton_pixel = frame.uborder_pixel =
115 frame.fborder_pixel = frame.ugrip_pixel = frame.fgrip_pixel = 0;
116 frame.utitle = frame.ftitle = frame.uhandle = frame.fhandle = None;
117 frame.ulabel = frame.flabel = frame.ubutton = frame.fbutton = None;
118 frame.ugrip = frame.fgrip = None;
119
120 functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
121 mwm_decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
122 Decor_Iconify | Decor_Maximize;
123
124 client.normal_hint_flags = 0;
125 client.window_group = None;
126 client.transient_for = 0;
127
128 current_state = NormalState;
129
130 /*
131 set the initial size and location of client window (relative to the
132 _root window_). This position is the reference point used with the
133 window's gravity to find the window's initial position.
134 */
135 client.rect.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
136 client.old_bw = wattrib.border_width;
137
138 lastButtonPressTime = 0;
139
140 timer = new otk::OBTimer(Openbox::instance->timerManager(),
141 (otk::OBTimeoutHandler)timeout,
142 this);
143 timer->setTimeout(blackbox->getAutoRaiseDelay());
144
145 // get size, aspect, minimum/maximum size and other hints set by the
146 // client
147
148 if (! getBlackboxHints())
149 getNetWMHints();
150
151 getWMProtocols();
152 getWMHints();
153 getWMNormalHints();
154
155 frame.window = createToplevelWindow();
156
157 blackbox->saveWindowSearch(frame.window, this);
158
159 frame.plate = createChildWindow(frame.window, ExposureMask);
160 blackbox->saveWindowSearch(frame.plate, this);
161
162 // determine if this is a transient window
163 getTransientInfo();
164
165 // determine the window's type, so we can decide its decorations and
166 // functionality, or if we should not manage it at all
167 if (getWindowType()) {
168 // adjust the window decorations/behavior based on the window type
169 switch (window_type) {
170 case Type_Desktop:
171 case Type_Dock:
172 case Type_Menu:
173 blackbox_attrib.workspace = 0; // we do need to belong to a workspace
174 flags.stuck = True; // we show up on all workspaces
175 case Type_Splash:
176 // none of these windows are manipulated by the window manager
177 functions = 0;
178 break;
179
180 case Type_Toolbar:
181 case Type_Utility:
182 // these windows get less functionality
183 functions &= ~(Func_Maximize | Func_Resize | Func_Iconify);
184 break;
185
186 case Type_Dialog:
187 // dialogs cannot be maximized
188 functions &= ~Func_Maximize;
189 break;
190
191 case Type_Normal:
192 // normal windows retain all of the possible decorations and
193 // functionality
194 break;
195 }
196 } else {
197 getMWMHints();
198 }
199
200 // further adjeust the window's decorations/behavior based on window sizes
201 if ((client.normal_hint_flags & PMinSize) &&
202 (client.normal_hint_flags & PMaxSize) &&
203 client.max_width <= client.min_width &&
204 client.max_height <= client.min_height) {
205 functions &= ~(Func_Resize | Func_Maximize);
206 }
207
208 setAllowedActions();
209
210 setupDecor();
211
212 if (decorations & Decor_Titlebar)
213 createTitlebar();
214
215 if (decorations & Decor_Handle)
216 createHandle();
217
218 // apply the size and gravity hint to the frame
219
220 upsize();
221
222 bool place_window = True;
223 if (blackbox->state() == Openbox::State_Starting || isTransient() ||
224 client.normal_hint_flags & (PPosition|USPosition)) {
225 applyGravity(frame.rect);
226
227 if (blackbox->state() == Openbox::State_Starting ||
228 client.rect.intersects(screen->getRect()))
229 place_window = False;
230 }
231
232 // add the window's strut. note this is done *after* placing the window.
233 screen->addStrut(&client.strut);
234 updateStrut();
235
236 /*
237 the server needs to be grabbed here to prevent client's from sending
238 events while we are in the process of configuring their window.
239 We hold the grab until after we are done moving the window around.
240 */
241
242 XGrabServer(otk::OBDisplay::display);
243
244 associateClientWindow();
245
246 blackbox->saveWindowSearch(client.window, this);
247
248 if (blackbox_attrib.workspace >= screen->getWorkspaceCount())
249 screen->getCurrentWorkspace()->addWindow(this, place_window);
250 else
251 screen->getWorkspace(blackbox_attrib.workspace)->
252 addWindow(this, place_window);
253
254 if (! place_window) {
255 // don't need to call configure if we are letting the workspace
256 // place the window
257 configure(frame.rect.x(), frame.rect.y(),
258 frame.rect.width(), frame.rect.height());
259
260 }
261
262 positionWindows();
263
264 XUngrabServer(otk::OBDisplay::display);
265
266 #ifdef SHAPE
267 if (otk::OBDisplay::shape() && flags.shaped)
268 configureShape();
269 #endif // SHAPE
270
271 // now that we know where to put the window and what it should look like
272 // we apply the decorations
273 decorate();
274
275 grabButtons();
276
277 XMapSubwindows(otk::OBDisplay::display, frame.window);
278
279 // this ensures the title, buttons, and other decor are properly displayed
280 redrawWindowFrame();
281
282 // preserve the window's initial state on first map, and its current state
283 // across a restart
284 unsigned long initial_state = current_state;
285 if (! getState())
286 current_state = initial_state;
287
288 // get sticky state from our parent window if we've got one
289 if (isTransient() && client.transient_for != (BlackboxWindow *) ~0ul &&
290 client.transient_for->isStuck() != flags.stuck)
291 flags.stuck = True;
292
293 if (flags.shaded) {
294 flags.shaded = False;
295 initial_state = current_state;
296 shade();
297
298 /*
299 At this point in the life of a window, current_state should only be set
300 to IconicState if the window was an *icon*, not if it was shaded.
301 */
302 if (initial_state != IconicState)
303 current_state = NormalState;
304 }
305
306 if (flags.stuck) {
307 flags.stuck = False;
308 stick();
309 }
310
311 if (flags.maximized && (functions & Func_Maximize))
312 remaximize();
313 }
314
315
316 BlackboxWindow::~BlackboxWindow(void) {
317 #ifdef DEBUG
318 fprintf(stderr, "BlackboxWindow::~BlackboxWindow: destroying 0x%lx\n",
319 client.window);
320 #endif // DEBUG
321
322 if (! timer) // window not managed...
323 return;
324
325 if (flags.moving)
326 endMove();
327
328 screen->removeStrut(&client.strut);
329 screen->updateAvailableArea();
330
331 // We don't need to worry about resizing because resizing always grabs the X
332 // server. This should only ever happen if using opaque moving.
333 if (flags.moving)
334 endMove();
335
336 delete timer;
337
338 if (client.window_group) {
339 BWindowGroup *group = blackbox->searchGroup(client.window_group);
340 if (group) group->removeWindow(this);
341 }
342
343 // remove ourselves from our transient_for
344 if (isTransient()) {
345 if (client.transient_for != (BlackboxWindow *) ~0ul)
346 client.transient_for->client.transientList.remove(this);
347 client.transient_for = (BlackboxWindow*) 0;
348 }
349
350 if (client.transientList.size() > 0) {
351 // reset transient_for for all transients
352 BlackboxWindowList::iterator it, end = client.transientList.end();
353 for (it = client.transientList.begin(); it != end; ++it)
354 (*it)->client.transient_for = (BlackboxWindow*) 0;
355 }
356
357 if (frame.title)
358 destroyTitlebar();
359
360 if (frame.handle)
361 destroyHandle();
362
363 if (frame.plate) {
364 blackbox->removeWindowSearch(frame.plate);
365 XDestroyWindow(otk::OBDisplay::display, frame.plate);
366 }
367
368 if (frame.window) {
369 blackbox->removeWindowSearch(frame.window);
370 XDestroyWindow(otk::OBDisplay::display, frame.window);
371 }
372
373 blackbox->removeWindowSearch(client.window);
374 }
375
376
377 void BlackboxWindow::enableDecor(bool enable) {
378 blackbox_attrib.flags |= AttribDecoration;
379 blackbox_attrib.decoration = enable ? DecorNormal : DecorNone;
380 setupDecor();
381
382 // we can not be shaded if we lack a titlebar
383 if (! (decorations & Decor_Titlebar) && flags.shaded)
384 shade();
385
386 if (flags.visible && frame.window) {
387 XMapSubwindows(otk::OBDisplay::display, frame.window);
388 XMapWindow(otk::OBDisplay::display, frame.window);
389 }
390
391 reconfigure();
392 setState(current_state);
393 }
394
395
396 void BlackboxWindow::setupDecor() {
397 if (blackbox_attrib.decoration != DecorNone) {
398 // start with everything on
399 decorations = Decor_Close |
400 (mwm_decorations & Decor_Titlebar ? Decor_Titlebar : 0) |
401 (mwm_decorations & Decor_Border ? Decor_Border : 0) |
402 (mwm_decorations & Decor_Handle ? Decor_Handle : 0) |
403 (mwm_decorations & Decor_Iconify ? Decor_Iconify : 0) |
404 (mwm_decorations & Decor_Maximize ? Decor_Maximize : 0);
405
406 if (! (functions & Func_Close)) decorations &= ~Decor_Close;
407 if (! (functions & Func_Maximize)) decorations &= ~Decor_Maximize;
408 if (! (functions & Func_Iconify)) decorations &= ~Decor_Iconify;
409 if (! (functions & Func_Resize)) decorations &= ~Decor_Handle;
410
411 switch (window_type) {
412 case Type_Desktop:
413 case Type_Dock:
414 case Type_Menu:
415 case Type_Splash:
416 // none of these windows are decorated by the window manager at all
417 decorations = 0;
418 break;
419
420 case Type_Toolbar:
421 case Type_Utility:
422 decorations &= ~(Decor_Border);
423 break;
424
425 case Type_Dialog:
426 decorations &= ~Decor_Handle;
427 break;
428
429 case Type_Normal:
430 break;
431 }
432 } else {
433 decorations = 0;
434 }
435 }
436
437 /*
438 * Creates a new top level window, with a given location, size, and border
439 * width.
440 * Returns: the newly created window
441 */
442 Window BlackboxWindow::createToplevelWindow(void) {
443 XSetWindowAttributes attrib_create;
444 unsigned long create_mask = CWBackPixmap | CWBorderPixel | CWColormap |
445 CWOverrideRedirect | CWEventMask;
446
447 attrib_create.background_pixmap = None;
448 attrib_create.colormap = screen->getColormap();
449 attrib_create.override_redirect = True;
450 attrib_create.event_mask = EnterWindowMask | LeaveWindowMask |
451 ButtonPress;
452 /*
453 We catch button presses because other wise they get passed down to the
454 root window, which will then cause root menus to show when you click the
455 window's frame.
456 */
457
458 return XCreateWindow(otk::OBDisplay::display, screen->getRootWindow(),
459 0, 0, 1, 1, frame.border_w, screen->getDepth(),
460 InputOutput, screen->getVisual(), create_mask,
461 &attrib_create);
462 }
463
464
465 /*
466 * Creates a child window, and optionally associates a given cursor with
467 * the new window.
468 */
469 Window BlackboxWindow::createChildWindow(Window parent,
470 unsigned long event_mask,
471 Cursor cursor) {
472 XSetWindowAttributes attrib_create;
473 unsigned long create_mask = CWBackPixmap | CWBorderPixel |
474 CWEventMask;
475
476 attrib_create.background_pixmap = None;
477 attrib_create.event_mask = event_mask;
478
479 if (cursor) {
480 create_mask |= CWCursor;
481 attrib_create.cursor = cursor;
482 }
483
484 return XCreateWindow(otk::OBDisplay::display, parent, 0, 0, 1, 1, 0,
485 screen->getDepth(), InputOutput, screen->getVisual(),
486 create_mask, &attrib_create);
487 }
488
489
490 void BlackboxWindow::associateClientWindow(void) {
491 XSetWindowBorderWidth(otk::OBDisplay::display, client.window, 0);
492 getWMName();
493 getWMIconName();
494
495 XChangeSaveSet(otk::OBDisplay::display, client.window, SetModeInsert);
496
497 XSelectInput(otk::OBDisplay::display, frame.plate, SubstructureRedirectMask);
498
499 /*
500 note we used to grab around this call to XReparentWindow however the
501 server is now grabbed before this method is called
502 */
503 unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
504 StructureNotifyMask;
505 XSelectInput(otk::OBDisplay::display, client.window,
506 event_mask & ~StructureNotifyMask);
507 XReparentWindow(otk::OBDisplay::display, client.window, frame.plate, 0, 0);
508 XSelectInput(otk::OBDisplay::display, client.window, event_mask);
509
510 XRaiseWindow(otk::OBDisplay::display, frame.plate);
511 XMapSubwindows(otk::OBDisplay::display, frame.plate);
512
513 #ifdef SHAPE
514 if (otk::OBDisplay::shape()) {
515 XShapeSelectInput(otk::OBDisplay::display, client.window,
516 ShapeNotifyMask);
517
518 Bool shaped = False;
519 int foo;
520 unsigned int ufoo;
521
522 XShapeQueryExtents(otk::OBDisplay::display, client.window, &shaped,
523 &foo, &foo, &ufoo, &ufoo, &foo, &foo, &foo,
524 &ufoo, &ufoo);
525 flags.shaped = shaped;
526 }
527 #endif // SHAPE
528 }
529
530
531 void BlackboxWindow::decorate(void) {
532 otk::BTexture* texture;
533
534 texture = &(screen->getWindowStyle()->b_focus);
535 frame.fbutton = texture->render(frame.button_w, frame.button_w,
536 frame.fbutton);
537 if (! frame.fbutton)
538 frame.fbutton_pixel = texture->color().pixel();
539
540 texture = &(screen->getWindowStyle()->b_unfocus);
541 frame.ubutton = texture->render(frame.button_w, frame.button_w,
542 frame.ubutton);
543 if (! frame.ubutton)
544 frame.ubutton_pixel = texture->color().pixel();
545
546 unsigned char needsPressed = 0;
547
548 texture = &(screen->getWindowStyle()->b_pressed_focus);
549
550 if (texture->texture() != otk::BTexture::NoTexture) {
551 frame.pfbutton = texture->render(frame.button_w, frame.button_w,
552 frame.pfbutton);
553 if (! frame.pfbutton)
554 frame.pfbutton_pixel = texture->color().pixel();
555 } else {
556 needsPressed = 0x1;
557 }
558
559 texture = &(screen->getWindowStyle()->b_pressed_unfocus);
560
561 if (texture->texture() != otk::BTexture::NoTexture) {
562 frame.pubutton = texture->render(frame.button_w, frame.button_w,
563 frame.pubutton);
564 if (! frame.pubutton)
565 frame.pubutton = texture->color().pixel();
566 } else {
567 needsPressed |= 0x2;
568 }
569
570 // if we either pressed unfocused, or pressed focused were undefined,
571 // make them inherit from the old resource. It's a hack for sure, but
572 // it allows for some backwards and forwards compatibility.
573 if (needsPressed) {
574 texture = &(screen->getWindowStyle()->b_pressed);
575
576 if (needsPressed & 0x1) {
577 frame.pfbutton = texture->render(frame.button_w, frame.button_w,
578 frame.pfbutton);
579 if (! frame.pfbutton)
580 frame.pfbutton_pixel = texture->color().pixel();
581 }
582 if (needsPressed & 0x2) {
583 frame.pubutton = texture->render(frame.button_w, frame.button_w,
584 frame.pubutton);
585 if (! frame.pubutton)
586 frame.pubutton = texture->color().pixel();
587 }
588
589 }
590
591 if (decorations & Decor_Titlebar) {
592 texture = &(screen->getWindowStyle()->t_focus);
593 frame.ftitle = texture->render(frame.inside_w, frame.title_h,
594 frame.ftitle);
595 if (! frame.ftitle)
596 frame.ftitle_pixel = texture->color().pixel();
597
598 texture = &(screen->getWindowStyle()->t_unfocus);
599 frame.utitle = texture->render(frame.inside_w, frame.title_h,
600 frame.utitle);
601 if (! frame.utitle)
602 frame.utitle_pixel = texture->color().pixel();
603
604 XSetWindowBorder(otk::OBDisplay::display, frame.title,
605 screen->getBorderColor()->pixel());
606
607 decorateLabel();
608 }
609
610 if (decorations & Decor_Border) {
611 frame.fborder_pixel = screen->getWindowStyle()->f_focus.color().pixel();
612 frame.uborder_pixel = screen->getWindowStyle()->f_unfocus.color().pixel();
613 }
614
615 if (decorations & Decor_Handle) {
616 texture = &(screen->getWindowStyle()->h_focus);
617 frame.fhandle = texture->render(frame.inside_w, frame.handle_h,
618 frame.fhandle);
619 if (! frame.fhandle)
620 frame.fhandle_pixel = texture->color().pixel();
621
622 texture = &(screen->getWindowStyle()->h_unfocus);
623 frame.uhandle = texture->render(frame.inside_w, frame.handle_h,
624 frame.uhandle);
625 if (! frame.uhandle)
626 frame.uhandle_pixel = texture->color().pixel();
627
628 texture = &(screen->getWindowStyle()->g_focus);
629 frame.fgrip = texture->render(frame.grip_w, frame.handle_h, frame.fgrip);
630 if (! frame.fgrip)
631 frame.fgrip_pixel = texture->color().pixel();
632
633 texture = &(screen->getWindowStyle()->g_unfocus);
634 frame.ugrip = texture->render(frame.grip_w, frame.handle_h, frame.ugrip);
635 if (! frame.ugrip)
636 frame.ugrip_pixel = texture->color().pixel();
637
638 XSetWindowBorder(otk::OBDisplay::display, frame.handle,
639 screen->getBorderColor()->pixel());
640 XSetWindowBorder(otk::OBDisplay::display, frame.left_grip,
641 screen->getBorderColor()->pixel());
642 XSetWindowBorder(otk::OBDisplay::display, frame.right_grip,
643 screen->getBorderColor()->pixel());
644 }
645
646 XSetWindowBorder(otk::OBDisplay::display, frame.window,
647 screen->getBorderColor()->pixel());
648 }
649
650
651 void BlackboxWindow::decorateLabel(void) {
652 otk::BTexture *texture;
653
654 texture = &(screen->getWindowStyle()->l_focus);
655 frame.flabel = texture->render(frame.label_w, frame.label_h, frame.flabel);
656 if (! frame.flabel)
657 frame.flabel_pixel = texture->color().pixel();
658
659 texture = &(screen->getWindowStyle()->l_unfocus);
660 frame.ulabel = texture->render(frame.label_w, frame.label_h, frame.ulabel);
661 if (! frame.ulabel)
662 frame.ulabel_pixel = texture->color().pixel();
663 }
664
665
666 void BlackboxWindow::createHandle(void) {
667 frame.handle = createChildWindow(frame.window,
668 ButtonPressMask | ButtonReleaseMask |
669 ButtonMotionMask | ExposureMask);
670 blackbox->saveWindowSearch(frame.handle, this);
671
672 frame.left_grip =
673 createChildWindow(frame.handle,
674 ButtonPressMask | ButtonReleaseMask |
675 ButtonMotionMask | ExposureMask,
676 blackbox->getLowerLeftAngleCursor());
677 blackbox->saveWindowSearch(frame.left_grip, this);
678
679 frame.right_grip =
680 createChildWindow(frame.handle,
681 ButtonPressMask | ButtonReleaseMask |
682 ButtonMotionMask | ExposureMask,
683 blackbox->getLowerRightAngleCursor());
684 blackbox->saveWindowSearch(frame.right_grip, this);
685 }
686
687
688 void BlackboxWindow::destroyHandle(void) {
689 if (frame.fhandle)
690 screen->getImageControl()->removeImage(frame.fhandle);
691
692 if (frame.uhandle)
693 screen->getImageControl()->removeImage(frame.uhandle);
694
695 if (frame.fgrip)
696 screen->getImageControl()->removeImage(frame.fgrip);
697
698 if (frame.ugrip)
699 screen->getImageControl()->removeImage(frame.ugrip);
700
701 blackbox->removeWindowSearch(frame.left_grip);
702 blackbox->removeWindowSearch(frame.right_grip);
703
704 XDestroyWindow(otk::OBDisplay::display, frame.left_grip);
705 XDestroyWindow(otk::OBDisplay::display, frame.right_grip);
706 frame.left_grip = frame.right_grip = None;
707
708 blackbox->removeWindowSearch(frame.handle);
709 XDestroyWindow(otk::OBDisplay::display, frame.handle);
710 frame.handle = None;
711 }
712
713
714 void BlackboxWindow::createTitlebar(void) {
715 frame.title = createChildWindow(frame.window,
716 ButtonPressMask | ButtonReleaseMask |
717 ButtonMotionMask | ExposureMask);
718 frame.label = createChildWindow(frame.title,
719 ButtonPressMask | ButtonReleaseMask |
720 ButtonMotionMask | ExposureMask);
721 blackbox->saveWindowSearch(frame.title, this);
722 blackbox->saveWindowSearch(frame.label, this);
723
724 if (decorations & Decor_Iconify) createIconifyButton();
725 if (decorations & Decor_Maximize) createMaximizeButton();
726 if (decorations & Decor_Close) createCloseButton();
727 }
728
729
730 void BlackboxWindow::destroyTitlebar(void) {
731 if (frame.close_button)
732 destroyCloseButton();
733
734 if (frame.iconify_button)
735 destroyIconifyButton();
736
737 if (frame.maximize_button)
738 destroyMaximizeButton();
739
740 if (frame.stick_button)
741 destroyStickyButton();
742
743 if (frame.ftitle)
744 screen->getImageControl()->removeImage(frame.ftitle);
745
746 if (frame.utitle)
747 screen->getImageControl()->removeImage(frame.utitle);
748
749 if (frame.flabel)
750 screen->getImageControl()->removeImage(frame.flabel);
751
752 if( frame.ulabel)
753 screen->getImageControl()->removeImage(frame.ulabel);
754
755 if (frame.fbutton)
756 screen->getImageControl()->removeImage(frame.fbutton);
757
758 if (frame.ubutton)
759 screen->getImageControl()->removeImage(frame.ubutton);
760
761 blackbox->removeWindowSearch(frame.title);
762 blackbox->removeWindowSearch(frame.label);
763
764 XDestroyWindow(otk::OBDisplay::display, frame.label);
765 XDestroyWindow(otk::OBDisplay::display, frame.title);
766 frame.title = frame.label = None;
767 }
768
769
770 void BlackboxWindow::createCloseButton(void) {
771 if (frame.title != None) {
772 frame.close_button = createChildWindow(frame.title,
773 ButtonPressMask |
774 ButtonReleaseMask |
775 ButtonMotionMask | ExposureMask);
776 blackbox->saveWindowSearch(frame.close_button, this);
777 }
778 }
779
780
781 void BlackboxWindow::destroyCloseButton(void) {
782 blackbox->removeWindowSearch(frame.close_button);
783 XDestroyWindow(otk::OBDisplay::display, frame.close_button);
784 frame.close_button = None;
785 }
786
787
788 void BlackboxWindow::createIconifyButton(void) {
789 if (frame.title != None) {
790 frame.iconify_button = createChildWindow(frame.title,
791 ButtonPressMask |
792 ButtonReleaseMask |
793 ButtonMotionMask | ExposureMask);
794 blackbox->saveWindowSearch(frame.iconify_button, this);
795 }
796 }
797
798
799 void BlackboxWindow::destroyIconifyButton(void) {
800 blackbox->removeWindowSearch(frame.iconify_button);
801 XDestroyWindow(otk::OBDisplay::display, frame.iconify_button);
802 frame.iconify_button = None;
803 }
804
805
806 void BlackboxWindow::createMaximizeButton(void) {
807 if (frame.title != None) {
808 frame.maximize_button = createChildWindow(frame.title,
809 ButtonPressMask |
810 ButtonReleaseMask |
811 ButtonMotionMask | ExposureMask);
812 blackbox->saveWindowSearch(frame.maximize_button, this);
813 }
814 }
815
816
817 void BlackboxWindow::destroyMaximizeButton(void) {
818 blackbox->removeWindowSearch(frame.maximize_button);
819 XDestroyWindow(otk::OBDisplay::display, frame.maximize_button);
820 frame.maximize_button = None;
821 }
822
823 void BlackboxWindow::createStickyButton(void) {
824 if (frame.title != None) {
825 frame.stick_button = createChildWindow(frame.title,
826 ButtonPressMask |
827 ButtonReleaseMask |
828 ButtonMotionMask | ExposureMask);
829 blackbox->saveWindowSearch(frame.stick_button, this);
830 }
831 }
832
833 void BlackboxWindow::destroyStickyButton(void) {
834 blackbox->removeWindowSearch(frame.stick_button);
835 XDestroyWindow(otk::OBDisplay::display, frame.stick_button);
836 frame.stick_button = None;
837 }
838
839 void BlackboxWindow::positionButtons(bool redecorate_label) {
840 string layout = blackbox->getTitlebarLayout();
841 string parsed;
842
843 bool hasclose, hasiconify, hasmaximize, haslabel, hasstick;
844 hasclose = hasiconify = hasmaximize = haslabel = hasstick = false;
845
846 string::const_iterator it, end;
847 for (it = layout.begin(), end = layout.end(); it != end; ++it) {
848 switch(*it) {
849 case 'C':
850 if (! hasclose && (decorations & Decor_Close)) {
851 hasclose = true;
852 parsed += *it;
853 }
854 break;
855 case 'I':
856 if (! hasiconify && (decorations & Decor_Iconify)) {
857 hasiconify = true;
858 parsed += *it;
859 }
860 break;
861 case 'S':
862 if (!hasstick) {
863 hasstick = true;
864 parsed += *it;
865 }
866 break;
867 case 'M':
868 if (! hasmaximize && (decorations & Decor_Maximize)) {
869 hasmaximize = true;
870 parsed += *it;
871 }
872 break;
873 case 'L':
874 if (! haslabel) {
875 haslabel = true;
876 parsed += *it;
877 }
878 break;
879 }
880 }
881
882 if (! hasclose && frame.close_button)
883 destroyCloseButton();
884 if (! hasiconify && frame.iconify_button)
885 destroyIconifyButton();
886 if (! hasmaximize && frame.maximize_button)
887 destroyMaximizeButton();
888 if (! hasstick && frame.stick_button)
889 destroyStickyButton();
890 if (! haslabel)
891 parsed += 'L'; // require that the label be in the layout
892
893 const unsigned int bsep = frame.bevel_w + 1; // separation between elements
894 const unsigned int by = frame.bevel_w + 1;
895 const unsigned int ty = frame.bevel_w;
896
897 frame.label_w = frame.inside_w - bsep * 2 -
898 (frame.button_w + bsep) * (parsed.size() - 1);
899
900 unsigned int x = bsep;
901 for (it = parsed.begin(), end = parsed.end(); it != end; ++it) {
902 switch(*it) {
903 case 'C':
904 if (! frame.close_button) createCloseButton();
905 XMoveResizeWindow(otk::OBDisplay::display, frame.close_button, x, by,
906 frame.button_w, frame.button_w);
907 x += frame.button_w + bsep;
908 break;
909 case 'I':
910 if (! frame.iconify_button) createIconifyButton();
911 XMoveResizeWindow(otk::OBDisplay::display, frame.iconify_button, x, by,
912 frame.button_w, frame.button_w);
913 x += frame.button_w + bsep;
914 break;
915 case 'S':
916 if (! frame.stick_button) createStickyButton();
917 XMoveResizeWindow(otk::OBDisplay::display, frame.stick_button, x, by,
918 frame.button_w, frame.button_w);
919 x += frame.button_w + bsep;
920 break;
921 case 'M':
922 if (! frame.maximize_button) createMaximizeButton();
923 XMoveResizeWindow(otk::OBDisplay::display, frame.maximize_button, x, by,
924 frame.button_w, frame.button_w);
925 x += frame.button_w + bsep;
926 break;
927 case 'L':
928 XMoveResizeWindow(otk::OBDisplay::display, frame.label, x, ty,
929 frame.label_w, frame.label_h);
930 x += frame.label_w + bsep;
931 break;
932 }
933 }
934
935 if (redecorate_label) decorateLabel();
936 redrawLabel();
937 redrawAllButtons();
938 }
939
940
941 void BlackboxWindow::reconfigure(void) {
942 restoreGravity(client.rect);
943 upsize();
944 applyGravity(frame.rect);
945 positionWindows();
946 decorate();
947 redrawWindowFrame();
948
949 ungrabButtons();
950 grabButtons();
951 }
952
953
954 void BlackboxWindow::grabButtons(void) {
955 mod_mask = blackbox->getMouseModMask();
956
957 if (! screen->isSloppyFocus() || screen->doClickRaise())
958 // grab button 1 for changing focus/raising
959 otk::OBDisplay::grabButton(Button1, 0, frame.plate, True, ButtonPressMask,
960 GrabModeSync, GrabModeSync, frame.plate, None,
961 screen->allowScrollLock());
962
963 if (functions & Func_Move)
964 otk::OBDisplay::grabButton(Button1, mod_mask, frame.window, True,
965 ButtonReleaseMask | ButtonMotionMask, GrabModeAsync,
966 GrabModeAsync, frame.window, None,
967 screen->allowScrollLock());
968 if (functions & Func_Resize)
969 otk::OBDisplay::grabButton(Button3, mod_mask, frame.window, True,
970 ButtonReleaseMask | ButtonMotionMask, GrabModeAsync,
971 GrabModeAsync, frame.window, None,
972 screen->allowScrollLock());
973 // alt+middle lowers the window
974 otk::OBDisplay::grabButton(Button2, mod_mask, frame.window, True,
975 ButtonReleaseMask, GrabModeAsync, GrabModeAsync,
976 frame.window, None, screen->allowScrollLock());
977 }
978
979
980 void BlackboxWindow::ungrabButtons(void) {
981 otk::OBDisplay::ungrabButton(Button1, 0, frame.plate);
982 otk::OBDisplay::ungrabButton(Button1, mod_mask, frame.window);
983 otk::OBDisplay::ungrabButton(Button2, mod_mask, frame.window);
984 otk::OBDisplay::ungrabButton(Button3, mod_mask, frame.window);
985 }
986
987
988 void BlackboxWindow::positionWindows(void) {
989 XMoveResizeWindow(otk::OBDisplay::display, frame.window,
990 frame.rect.x(), frame.rect.y(), frame.inside_w,
991 (flags.shaded) ? frame.title_h : frame.inside_h);
992 XSetWindowBorderWidth(otk::OBDisplay::display, frame.window,
993 frame.border_w);
994 XSetWindowBorderWidth(otk::OBDisplay::display, frame.plate,
995 frame.mwm_border_w);
996 XMoveResizeWindow(otk::OBDisplay::display, frame.plate,
997 frame.margin.left - frame.mwm_border_w - frame.border_w,
998 frame.margin.top - frame.mwm_border_w - frame.border_w,
999 client.rect.width(), client.rect.height());
1000 XMoveResizeWindow(otk::OBDisplay::display, client.window,
1001 0, 0, client.rect.width(), client.rect.height());
1002 // ensure client.rect contains the real location
1003 client.rect.setPos(frame.rect.left() + frame.margin.left,
1004 frame.rect.top() + frame.margin.top);
1005
1006 if (decorations & Decor_Titlebar) {
1007 if (frame.title == None) createTitlebar();
1008
1009 XSetWindowBorderWidth(otk::OBDisplay::display, frame.title,
1010 frame.border_w);
1011 XMoveResizeWindow(otk::OBDisplay::display, frame.title, -frame.border_w,
1012 -frame.border_w, frame.inside_w, frame.title_h);
1013
1014 positionButtons();
1015 XMapSubwindows(otk::OBDisplay::display, frame.title);
1016 XMapWindow(otk::OBDisplay::display, frame.title);
1017 } else if (frame.title) {
1018 destroyTitlebar();
1019 }
1020 if (decorations & Decor_Handle) {
1021 if (frame.handle == None) createHandle();
1022 XSetWindowBorderWidth(otk::OBDisplay::display, frame.handle,
1023 frame.border_w);
1024 XSetWindowBorderWidth(otk::OBDisplay::display, frame.left_grip,
1025 frame.border_w);
1026 XSetWindowBorderWidth(otk::OBDisplay::display, frame.right_grip,
1027 frame.border_w);
1028
1029 // use client.rect here so the value is correct even if shaded
1030 XMoveResizeWindow(otk::OBDisplay::display, frame.handle,
1031 -frame.border_w,
1032 client.rect.height() + frame.margin.top +
1033 frame.mwm_border_w - frame.border_w,
1034 frame.inside_w, frame.handle_h);
1035 XMoveResizeWindow(otk::OBDisplay::display, frame.left_grip,
1036 -frame.border_w, -frame.border_w,
1037 frame.grip_w, frame.handle_h);
1038 XMoveResizeWindow(otk::OBDisplay::display, frame.right_grip,
1039 frame.inside_w - frame.grip_w - frame.border_w,
1040 -frame.border_w, frame.grip_w, frame.handle_h);
1041
1042 XMapSubwindows(otk::OBDisplay::display, frame.handle);
1043 XMapWindow(otk::OBDisplay::display, frame.handle);
1044 } else if (frame.handle) {
1045 destroyHandle();
1046 }
1047 XSync(otk::OBDisplay::display, False);
1048 }
1049
1050
1051 void BlackboxWindow::updateStrut(void) {
1052 unsigned long num = 4;
1053 unsigned long *data;
1054 if (! xatom->get(client.window, otk::OBProperty::net_wm_strut,
1055 otk::OBProperty::Atom_Cardinal,
1056 &num, &data))
1057 return;
1058
1059 if (num == 4) {
1060 client.strut.left = data[0];
1061 client.strut.right = data[1];
1062 client.strut.top = data[2];
1063 client.strut.bottom = data[3];
1064
1065 screen->updateAvailableArea();
1066 }
1067
1068 delete [] data;
1069 }
1070
1071
1072 bool BlackboxWindow::getWindowType(void) {
1073 window_type = (WindowType) -1;
1074
1075 unsigned long *val;
1076 unsigned long num = (unsigned) -1;
1077 if (xatom->get(client.window, otk::OBProperty::net_wm_window_type,
1078 otk::OBProperty::Atom_Atom,
1079 &num, &val)) {
1080 for (unsigned long i = 0; i < num; ++i) {
1081 if (val[i] == xatom->atom(otk::OBProperty::net_wm_window_type_desktop))
1082 window_type = Type_Desktop;
1083 else if (val[i] == xatom->atom(otk::OBProperty::net_wm_window_type_dock))
1084 window_type = Type_Dock;
1085 else if (val[i] == xatom->atom(otk::OBProperty::net_wm_window_type_toolbar))
1086 window_type = Type_Toolbar;
1087 else if (val[i] == xatom->atom(otk::OBProperty::net_wm_window_type_menu))
1088 window_type = Type_Menu;
1089 else if (val[i] == xatom->atom(otk::OBProperty::net_wm_window_type_utility))
1090 window_type = Type_Utility;
1091 else if (val[i] == xatom->atom(otk::OBProperty::net_wm_window_type_splash))
1092 window_type = Type_Splash;
1093 else if (val[i] == xatom->atom(otk::OBProperty::net_wm_window_type_dialog))
1094 window_type = Type_Dialog;
1095 else if (val[i] == xatom->atom(otk::OBProperty::net_wm_window_type_normal))
1096 window_type = Type_Normal;
1097 else if (val[i] ==
1098 xatom->atom(otk::OBProperty::kde_net_wm_window_type_override))
1099 mwm_decorations = 0; // prevent this window from getting any decor
1100 }
1101 delete val;
1102 }
1103
1104 if (window_type == (WindowType) -1) {
1105 /*
1106 * the window type hint was not set, which means we either classify ourself
1107 * as a normal window or a dialog, depending on if we are a transient.
1108 */
1109 if (isTransient())
1110 window_type = Type_Dialog;
1111 else
1112 window_type = Type_Normal;
1113
1114 return False;
1115 }
1116
1117 return True;
1118 }
1119
1120
1121 void BlackboxWindow::getWMName(void) {
1122 if (xatom->get(client.window, otk::OBProperty::net_wm_name,
1123 otk::OBProperty::utf8, &client.title) &&
1124 !client.title.empty()) {
1125 xatom->erase(client.window, otk::OBProperty::net_wm_visible_name);
1126 return;
1127 }
1128 //fall through to using WM_NAME
1129 if (xatom->get(client.window, otk::OBProperty::wm_name,
1130 otk::OBProperty::ascii, &client.title)
1131 && !client.title.empty()) {
1132 xatom->erase(client.window, otk::OBProperty::net_wm_visible_name);
1133 return;
1134 }
1135 // fall back to an internal default
1136 client.title = "Unnamed";
1137 xatom->set(client.window, otk::OBProperty::net_wm_visible_name,
1138 otk::OBProperty::utf8, client.title);
1139
1140 #ifdef DEBUG_WITH_ID
1141 // the 16 is the 8 chars of the debug text plus the number
1142 char *tmp = new char[client.title.length() + 16];
1143 sprintf(tmp, "%s; id: 0x%lx", client.title.c_str(), client.window);
1144 client.title = tmp;
1145 delete tmp;
1146 #endif
1147 }
1148
1149
1150 void BlackboxWindow::getWMIconName(void) {
1151 if (xatom->get(client.window, otk::OBProperty::net_wm_icon_name,
1152 otk::OBProperty::utf8, &client.icon_title) &&
1153 !client.icon_title.empty()) {
1154 xatom->erase(client.window, otk::OBProperty::net_wm_visible_icon_name);
1155 return;
1156 }
1157 //fall through to using WM_ICON_NAME
1158 if (xatom->get(client.window, otk::OBProperty::wm_icon_name,
1159 otk::OBProperty::ascii,
1160 &client.icon_title) &&
1161 !client.icon_title.empty()) {
1162 xatom->erase(client.window, otk::OBProperty::net_wm_visible_icon_name);
1163 return;
1164 }
1165 // fall back to using the main name
1166 client.icon_title = client.title;
1167 xatom->set(client.window, otk::OBProperty::net_wm_visible_icon_name,
1168 otk::OBProperty::utf8,
1169 client.icon_title);
1170 }
1171
1172
1173 /*
1174 * Retrieve which WM Protocols are supported by the client window.
1175 * If the WM_DELETE_WINDOW protocol is supported, add the close button to the
1176 * window's decorations and allow the close behavior.
1177 * If the WM_TAKE_FOCUS protocol is supported, save a value that indicates
1178 * this.
1179 */
1180 void BlackboxWindow::getWMProtocols(void) {
1181 Atom *proto;
1182 int num_return = 0;
1183
1184 if (XGetWMProtocols(otk::OBDisplay::display, client.window,
1185 &proto, &num_return)) {
1186 for (int i = 0; i < num_return; ++i) {
1187 if (proto[i] == xatom->atom(otk::OBProperty::wm_delete_window)) {
1188 decorations |= Decor_Close;
1189 functions |= Func_Close;
1190 } else if (proto[i] == xatom->atom(otk::OBProperty::wm_take_focus))
1191 flags.send_focus_message = True;
1192 }
1193
1194 XFree(proto);
1195 }
1196 }
1197
1198
1199 /*
1200 * Gets the value of the WM_HINTS property.
1201 * If the property is not set, then use a set of default values.
1202 */
1203 void BlackboxWindow::getWMHints(void) {
1204 focus_mode = F_Passive;
1205
1206 // remove from current window group
1207 if (client.window_group) {
1208 BWindowGroup *group = blackbox->searchGroup(client.window_group);
1209 if (group) group->removeWindow(this);
1210 }
1211 client.window_group = None;
1212
1213 XWMHints *wmhint = XGetWMHints(otk::OBDisplay::display, client.window);
1214 if (! wmhint) {
1215 return;
1216 }
1217
1218 if (wmhint->flags & InputHint) {
1219 if (wmhint->input == True) {
1220 if (flags.send_focus_message)
1221 focus_mode = F_LocallyActive;
1222 } else {
1223 if (flags.send_focus_message)
1224 focus_mode = F_GloballyActive;
1225 else
1226 focus_mode = F_NoInput;
1227 }
1228 }
1229
1230 if (wmhint->flags & StateHint)
1231 current_state = wmhint->initial_state;
1232
1233 if (wmhint->flags & WindowGroupHint) {
1234 client.window_group = wmhint->window_group;
1235
1236 // add window to the appropriate group
1237 BWindowGroup *group = blackbox->searchGroup(client.window_group);
1238 if (! group) { // no group found, create it!
1239 new BWindowGroup(blackbox, client.window_group);
1240 group = blackbox->searchGroup(client.window_group);
1241 }
1242 if (group)
1243 group->addWindow(this);
1244 }
1245
1246 XFree(wmhint);
1247 }
1248
1249
1250 /*
1251 * Gets the value of the WM_NORMAL_HINTS property.
1252 * If the property is not set, then use a set of default values.
1253 */
1254 void BlackboxWindow::getWMNormalHints(void) {
1255 long icccm_mask;
1256 XSizeHints sizehint;
1257
1258 client.min_width = client.min_height =
1259 client.width_inc = client.height_inc = 1;
1260 client.base_width = client.base_height = 0;
1261 client.win_gravity = NorthWestGravity;
1262 #if 0
1263 client.min_aspect_x = client.min_aspect_y =
1264 client.max_aspect_x = client.max_aspect_y = 1;
1265 #endif
1266
1267 // don't limit the size of a window, the default max width is the biggest
1268 // possible
1269 client.max_width = (unsigned) -1;
1270 client.max_height = (unsigned) -1;
1271
1272
1273 if (! XGetWMNormalHints(otk::OBDisplay::display, client.window,
1274 &sizehint, &icccm_mask))
1275 return;
1276
1277 client.normal_hint_flags = sizehint.flags;
1278
1279 if (sizehint.flags & PMinSize) {
1280 if (sizehint.min_width >= 0)
1281 client.min_width = sizehint.min_width;
1282 if (sizehint.min_height >= 0)
1283 client.min_height = sizehint.min_height;
1284 }
1285
1286 if (sizehint.flags & PMaxSize) {
1287 if (sizehint.max_width > static_cast<signed>(client.min_width))
1288 client.max_width = sizehint.max_width;
1289 else
1290 client.max_width = client.min_width;
1291
1292 if (sizehint.max_height > static_cast<signed>(client.min_height))
1293 client.max_height = sizehint.max_height;
1294 else
1295 client.max_height = client.min_height;
1296 }
1297
1298 if (sizehint.flags & PResizeInc) {
1299 client.width_inc = sizehint.width_inc;
1300 client.height_inc = sizehint.height_inc;
1301 }
1302
1303 #if 0 // we do not support this at the moment
1304 if (sizehint.flags & PAspect) {
1305 client.min_aspect_x = sizehint.min_aspect.x;
1306 client.min_aspect_y = sizehint.min_aspect.y;
1307 client.max_aspect_x = sizehint.max_aspect.x;
1308 client.max_aspect_y = sizehint.max_aspect.y;
1309 }
1310 #endif
1311
1312 if (sizehint.flags & PBaseSize) {
1313 client.base_width = sizehint.base_width;
1314 client.base_height = sizehint.base_height;
1315 }
1316
1317 if (sizehint.flags & PWinGravity)
1318 client.win_gravity = sizehint.win_gravity;
1319 }
1320
1321
1322 /*
1323 * Gets the NETWM hints for the class' contained window.
1324 */
1325 void BlackboxWindow::getNetWMHints(void) {
1326 unsigned long workspace;
1327
1328 if (xatom->get(client.window, otk::OBProperty::net_wm_desktop,
1329 otk::OBProperty::Atom_Cardinal,
1330 &workspace)) {
1331 if (workspace == 0xffffffff)
1332 flags.stuck = True;
1333 else
1334 blackbox_attrib.workspace = workspace;
1335 }
1336
1337 unsigned long *state;
1338 unsigned long num = (unsigned) -1;
1339 if (xatom->get(client.window, otk::OBProperty::net_wm_state,
1340 otk::OBProperty::Atom_Atom,
1341 &num, &state)) {
1342 bool vert = False,
1343 horz = False;
1344 for (unsigned long i = 0; i < num; ++i) {
1345 if (state[i] == xatom->atom(otk::OBProperty::net_wm_state_modal))
1346 flags.modal = True;
1347 else if (state[i] == xatom->atom(otk::OBProperty::net_wm_state_shaded))
1348 flags.shaded = True;
1349 else if (state[i] == xatom->atom(otk::OBProperty::net_wm_state_skip_taskbar))
1350 flags.skip_taskbar = True;
1351 else if (state[i] == xatom->atom(otk::OBProperty::net_wm_state_skip_pager))
1352 flags.skip_pager = True;
1353 else if (state[i] == xatom->atom(otk::OBProperty::net_wm_state_fullscreen))
1354 flags.fullscreen = True;
1355 else if (state[i] == xatom->atom(otk::OBProperty::net_wm_state_hidden))
1356 setState(IconicState);
1357 else if (state[i] == xatom->atom(otk::OBProperty::net_wm_state_maximized_vert))
1358 vert = True;
1359 else if (state[i] == xatom->atom(otk::OBProperty::net_wm_state_maximized_horz))
1360 horz = True;
1361 }
1362 if (vert && horz)
1363 flags.maximized = 1;
1364 else if (vert)
1365 flags.maximized = 2;
1366 else if (horz)
1367 flags.maximized = 3;
1368
1369 delete [] state;
1370 }
1371 }
1372
1373
1374 /*
1375 * Gets the MWM hints for the class' contained window.
1376 * This is used while initializing the window to its first state, and not
1377 * thereafter.
1378 * Returns: true if the MWM hints are successfully retreived and applied;
1379 * false if they are not.
1380 */
1381 void BlackboxWindow::getMWMHints(void) {
1382 unsigned long num;
1383 MwmHints *mwm_hint;
1384
1385 num = PropMwmHintsElements;
1386 if (! xatom->get(client.window, otk::OBProperty::motif_wm_hints,
1387 otk::OBProperty::motif_wm_hints, &num,
1388 (unsigned long **)&mwm_hint))
1389 return;
1390 if (num < PropMwmHintsElements) {
1391 delete [] mwm_hint;
1392 return;
1393 }
1394
1395 if (mwm_hint->flags & MwmHintsDecorations) {
1396 if (mwm_hint->decorations & MwmDecorAll) {
1397 mwm_decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
1398 Decor_Iconify | Decor_Maximize;
1399 } else {
1400 mwm_decorations = 0;
1401
1402 if (mwm_hint->decorations & MwmDecorBorder)
1403 mwm_decorations |= Decor_Border;
1404 if (mwm_hint->decorations & MwmDecorHandle)
1405 mwm_decorations |= Decor_Handle;
1406 if (mwm_hint->decorations & MwmDecorTitle)
1407 mwm_decorations |= Decor_Titlebar;
1408 if (mwm_hint->decorations & MwmDecorIconify)
1409 mwm_decorations |= Decor_Iconify;
1410 if (mwm_hint->decorations & MwmDecorMaximize)
1411 mwm_decorations |= Decor_Maximize;
1412 }
1413 }
1414
1415 if (mwm_hint->flags & MwmHintsFunctions) {
1416 if (mwm_hint->functions & MwmFuncAll) {
1417 functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
1418 Func_Close;
1419 } else {
1420 functions = 0;
1421
1422 if (mwm_hint->functions & MwmFuncResize)
1423 functions |= Func_Resize;
1424 if (mwm_hint->functions & MwmFuncMove)
1425 functions |= Func_Move;
1426 if (mwm_hint->functions & MwmFuncIconify)
1427 functions |= Func_Iconify;
1428 if (mwm_hint->functions & MwmFuncMaximize)
1429 functions |= Func_Maximize;
1430 if (mwm_hint->functions & MwmFuncClose)
1431 functions |= Func_Close;
1432 }
1433 }
1434 delete [] mwm_hint;
1435 }
1436
1437
1438 /*
1439 * Gets the blackbox hints from the class' contained window.
1440 * This is used while initializing the window to its first state, and not
1441 * thereafter.
1442 * Returns: true if the hints are successfully retreived and applied; false if
1443 * they are not.
1444 */
1445 bool BlackboxWindow::getBlackboxHints(void) {
1446 unsigned long num;
1447 BlackboxHints *blackbox_hint;
1448
1449 num = PropBlackboxHintsElements;
1450 if (! xatom->get(client.window, otk::OBProperty::blackbox_hints,
1451 otk::OBProperty::blackbox_hints, &num,
1452 (unsigned long **)&blackbox_hint))
1453 return False;
1454 if (num < PropBlackboxHintsElements) {
1455 delete [] blackbox_hint;
1456 return False;
1457 }
1458
1459 if (blackbox_hint->flags & AttribShaded)
1460 flags.shaded = (blackbox_hint->attrib & AttribShaded);
1461
1462 if ((blackbox_hint->flags & AttribMaxHoriz) &&
1463 (blackbox_hint->flags & AttribMaxVert))
1464 flags.maximized = (blackbox_hint->attrib &
1465 (AttribMaxHoriz | AttribMaxVert)) ? 1 : 0;
1466 else if (blackbox_hint->flags & AttribMaxVert)
1467 flags.maximized = (blackbox_hint->attrib & AttribMaxVert) ? 2 : 0;
1468 else if (blackbox_hint->flags & AttribMaxHoriz)
1469 flags.maximized = (blackbox_hint->attrib & AttribMaxHoriz) ? 3 : 0;
1470
1471 if (blackbox_hint->flags & AttribOmnipresent)
1472 flags.stuck = (blackbox_hint->attrib & AttribOmnipresent);
1473
1474 if (blackbox_hint->flags & AttribWorkspace)
1475 blackbox_attrib.workspace = blackbox_hint->workspace;
1476
1477 // if (blackbox_hint->flags & AttribStack)
1478 // don't yet have always on top/bottom for blackbox yet... working
1479 // on that
1480
1481 if (blackbox_hint->flags & AttribDecoration) {
1482 switch (blackbox_hint->decoration) {
1483 case DecorNone:
1484 blackbox_attrib.decoration = DecorNone;
1485 break;
1486
1487 case DecorTiny:
1488 case DecorTool:
1489 case DecorNormal:
1490 default:
1491 // blackbox_attrib.decoration defaults to DecorNormal
1492 break;
1493 }
1494 }
1495
1496 delete [] blackbox_hint;
1497
1498 return True;
1499 }
1500
1501
1502 void BlackboxWindow::getTransientInfo(void) {
1503 if (client.transient_for &&
1504 client.transient_for != (BlackboxWindow *) ~0ul) {
1505 // reset transient_for in preparation of looking for a new owner
1506 client.transient_for->client.transientList.remove(this);
1507 }
1508
1509 // we have no transient_for until we find a new one
1510 client.transient_for = (BlackboxWindow *) 0;
1511
1512 Window trans_for;
1513 if (! XGetTransientForHint(otk::OBDisplay::display, client.window,
1514 &trans_for)) {
1515 // transient_for hint not set
1516 return;
1517 }
1518
1519 if (trans_for == client.window) {
1520 // wierd client... treat this window as a normal window
1521 return;
1522 }
1523
1524 if (trans_for == None || trans_for == screen->getRootWindow()) {
1525 // this is an undocumented interpretation of the ICCCM. a transient
1526 // associated with None/Root/itself is assumed to be a modal root
1527 // transient. we don't support the concept of a global transient,
1528 // so we just associate this transient with nothing, and perhaps
1529 // we will add support later for global modality.
1530 client.transient_for = (BlackboxWindow *) ~0ul;
1531 flags.modal = True;
1532 return;
1533 }
1534
1535 client.transient_for = blackbox->searchWindow(trans_for);
1536 if (! client.transient_for &&
1537 client.window_group && trans_for == client.window_group) {
1538 // no direct transient_for, perhaps this is a group transient?
1539 BWindowGroup *group = blackbox->searchGroup(client.window_group);
1540 if (group) client.transient_for = group->find(screen);
1541 }
1542
1543 if (! client.transient_for || client.transient_for == this) {
1544 // no transient_for found, or we have a wierd client that wants to be
1545 // a transient for itself, so we treat this window as a normal window
1546 client.transient_for = (BlackboxWindow*) 0;
1547 return;
1548 }
1549
1550 // Check for a circular transient state: this can lock up Blackbox
1551 // when it tries to find the non-transient window for a transient.
1552 BlackboxWindow *w = this;
1553 while(w->client.transient_for &&
1554 w->client.transient_for != (BlackboxWindow *) ~0ul) {
1555 if(w->client.transient_for == this) {
1556 client.transient_for = (BlackboxWindow*) 0;
1557 break;
1558 }
1559 w = w->client.transient_for;
1560 }
1561
1562 if (client.transient_for &&
1563 client.transient_for != (BlackboxWindow *) ~0ul) {
1564 // register ourselves with our new transient_for
1565 client.transient_for->client.transientList.push_back(this);
1566 flags.stuck = client.transient_for->flags.stuck;
1567 }
1568 }
1569
1570
1571 BlackboxWindow *BlackboxWindow::getTransientFor(void) const {
1572 if (client.transient_for &&
1573 client.transient_for != (BlackboxWindow*) ~0ul)
1574 return client.transient_for;
1575 return 0;
1576 }
1577
1578
1579 /*
1580 * This function is responsible for updating both the client and the frame
1581 * rectangles.
1582 * According to the ICCCM a client message is not sent for a resize, only a
1583 * move.
1584 */
1585 void BlackboxWindow::configure(int dx, int dy,
1586 unsigned int dw, unsigned int dh) {
1587 bool send_event = ((frame.rect.x() != dx || frame.rect.y() != dy) &&
1588 ! flags.moving);
1589
1590 if (dw != frame.rect.width() || dh != frame.rect.height()) {
1591 frame.rect.setRect(dx, dy, dw, dh);
1592 frame.inside_w = frame.rect.width() - (frame.border_w * 2);
1593 frame.inside_h = frame.rect.height() - (frame.border_w * 2);
1594
1595 if (frame.rect.right() <= 0 || frame.rect.bottom() <= 0)
1596 frame.rect.setPos(0, 0);
1597
1598 client.rect.setCoords(frame.rect.left() + frame.margin.left,
1599 frame.rect.top() + frame.margin.top,
1600 frame.rect.right() - frame.margin.right,
1601 frame.rect.bottom() - frame.margin.bottom);
1602
1603 #ifdef SHAPE
1604 if (otk::OBDisplay::shape() && flags.shaped) {
1605 configureShape();
1606 }
1607 #endif // SHAPE
1608
1609 positionWindows();
1610 decorate();
1611 redrawWindowFrame();
1612 } else {
1613 frame.rect.setPos(dx, dy);
1614
1615 XMoveWindow(otk::OBDisplay::display, frame.window,
1616 frame.rect.x(), frame.rect.y());
1617 /*
1618 we may have been called just after an opaque window move, so even though
1619 the old coords match the new ones no ConfigureNotify has been sent yet.
1620 There are likely other times when this will be relevant as well.
1621 */
1622 if (! flags.moving) send_event = True;
1623 }
1624
1625 if (send_event) {
1626 // if moving, the update and event will occur when the move finishes
1627 client.rect.setPos(frame.rect.left() + frame.margin.left,
1628 frame.rect.top() + frame.margin.top);
1629
1630 XEvent event;
1631 event.type = ConfigureNotify;
1632
1633 event.xconfigure.display = otk::OBDisplay::display;
1634 event.xconfigure.event = client.window;
1635 event.xconfigure.window = client.window;
1636 event.xconfigure.x = client.rect.x();
1637 event.xconfigure.y = client.rect.y();
1638 event.xconfigure.width = client.rect.width();
1639 event.xconfigure.height = client.rect.height();
1640 event.xconfigure.border_width = client.old_bw;
1641 event.xconfigure.above = frame.window;
1642 event.xconfigure.override_redirect = False;
1643
1644 XSendEvent(otk::OBDisplay::display, client.window, False,
1645 StructureNotifyMask, &event);
1646 XFlush(otk::OBDisplay::display);
1647 }
1648 }
1649
1650
1651 #ifdef SHAPE
1652 void BlackboxWindow::configureShape(void) {
1653 XShapeCombineShape(otk::OBDisplay::display, frame.window, ShapeBounding,
1654 frame.margin.left - frame.border_w,
1655 frame.margin.top - frame.border_w,
1656 client.window, ShapeBounding, ShapeSet);
1657
1658 int num = 0;
1659 XRectangle xrect[2];
1660
1661 if (decorations & Decor_Titlebar) {
1662 xrect[0].x = xrect[0].y = -frame.border_w;
1663 xrect[0].width = frame.rect.width();
1664 xrect[0].height = frame.title_h + (frame.border_w * 2);
1665 ++num;
1666 }
1667
1668 if (decorations & Decor_Handle) {
1669 xrect[1].x = -frame.border_w;
1670 xrect[1].y = frame.rect.height() - frame.margin.bottom +
1671 frame.mwm_border_w - frame.border_w;
1672 xrect[1].width = frame.rect.width();
1673 xrect[1].height = frame.handle_h + (frame.border_w * 2);
1674 ++num;
1675 }
1676
1677 XShapeCombineRectangles(otk::OBDisplay::display, frame.window,
1678 ShapeBounding, 0, 0, xrect, num,
1679 ShapeUnion, Unsorted);
1680 }
1681
1682
1683 void BlackboxWindow::clearShape(void) {
1684 XShapeCombineMask(otk::OBDisplay::display, frame.window, ShapeBounding,
1685 frame.margin.left - frame.border_w,
1686 frame.margin.top - frame.border_w,
1687 None, ShapeSet);
1688 }
1689 #endif // SHAPE
1690
1691
1692 bool BlackboxWindow::setInputFocus(void) {
1693 if (flags.focused) return True;
1694
1695 assert(flags.stuck || // window must be on the current workspace or sticky
1696 blackbox_attrib.workspace == screen->getCurrentWorkspaceID());
1697
1698 /*
1699 We only do this check for normal windows and dialogs because other windows
1700 do this on purpose, such as kde's kicker, and we don't want to go moving
1701 it.
1702 */
1703 if (window_type == Type_Normal || window_type == Type_Dialog)
1704 if (! frame.rect.intersects(screen->getRect())) {
1705 // client is outside the screen, move it to the center
1706 configure((screen->getWidth() - frame.rect.width()) / 2,
1707 (screen->getHeight() - frame.rect.height()) / 2,
1708 frame.rect.width(), frame.rect.height());
1709 }
1710
1711 if (client.transientList.size() > 0) {
1712 // transfer focus to any modal transients
1713 BlackboxWindowList::iterator it, end = client.transientList.end();
1714 for (it = client.transientList.begin(); it != end; ++it)
1715 if ((*it)->flags.modal) return (*it)->setInputFocus();
1716 }
1717
1718 bool ret = True;
1719 if (focus_mode == F_LocallyActive || focus_mode == F_Passive) {
1720 XSetInputFocus(otk::OBDisplay::display, client.window,
1721 RevertToPointerRoot, CurrentTime);
1722 } else {
1723 /* we could set the focus to none, since the window doesn't accept focus,
1724 * but we shouldn't set focus to nothing since this would surely make
1725 * someone angry
1726 */
1727 ret = False;
1728 }
1729
1730 if (flags.send_focus_message) {
1731 XEvent ce;
1732 ce.xclient.type = ClientMessage;
1733 ce.xclient.message_type = xatom->atom(otk::OBProperty::wm_protocols);
1734 ce.xclient.display = otk::OBDisplay::display;
1735 ce.xclient.window = client.window;
1736 ce.xclient.format = 32;
1737 ce.xclient.data.l[0] = xatom->atom(otk::OBProperty::wm_take_focus);
1738 ce.xclient.data.l[1] = blackbox->getLastTime();
1739 ce.xclient.data.l[2] = 0l;
1740 ce.xclient.data.l[3] = 0l;
1741 ce.xclient.data.l[4] = 0l;
1742 XSendEvent(otk::OBDisplay::display, client.window, False,
1743 NoEventMask, &ce);
1744 XFlush(otk::OBDisplay::display);
1745 }
1746
1747 return ret;
1748 }
1749
1750
1751 void BlackboxWindow::iconify(void) {
1752 if (flags.iconic || ! (functions & Func_Iconify)) return;
1753
1754 // We don't need to worry about resizing because resizing always grabs the X
1755 // server. This should only ever happen if using opaque moving.
1756 if (flags.moving)
1757 endMove();
1758
1759 /*
1760 * we don't want this XUnmapWindow call to generate an UnmapNotify event, so
1761 * we need to clear the event mask on client.window for a split second.
1762 * HOWEVER, since X11 is asynchronous, the window could be destroyed in that
1763 * split second, leaving us with a ghost window... so, we need to do this
1764 * while the X server is grabbed
1765 */
1766 unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
1767 StructureNotifyMask;
1768 XGrabServer(otk::OBDisplay::display);
1769 XSelectInput(otk::OBDisplay::display, client.window,
1770 event_mask & ~StructureNotifyMask);
1771 XUnmapWindow(otk::OBDisplay::display, client.window);
1772 XSelectInput(otk::OBDisplay::display, client.window, event_mask);
1773 XUngrabServer(otk::OBDisplay::display);
1774
1775 XUnmapWindow(otk::OBDisplay::display, frame.window);
1776 flags.visible = False;
1777 flags.iconic = True;
1778
1779 setState(IconicState);
1780
1781 screen->getWorkspace(blackbox_attrib.workspace)->removeWindow(this);
1782 if (flags.stuck) {
1783 for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
1784 if (i != blackbox_attrib.workspace)
1785 screen->getWorkspace(i)->removeWindow(this, True);
1786 }
1787
1788 if (isTransient()) {
1789 if (client.transient_for != (BlackboxWindow *) ~0ul &&
1790 ! client.transient_for->flags.iconic) {
1791 // iconify our transient_for
1792 client.transient_for->iconify();
1793 }
1794 }
1795
1796 screen->addIcon(this);
1797
1798 if (client.transientList.size() > 0) {
1799 // iconify all transients
1800 BlackboxWindowList::iterator it, end = client.transientList.end();
1801 for (it = client.transientList.begin(); it != end; ++it) {
1802 if (! (*it)->flags.iconic) (*it)->iconify();
1803 }
1804 }
1805 screen->updateStackingList();
1806 }
1807
1808
1809 void BlackboxWindow::show(void) {
1810 flags.visible = True;
1811 flags.iconic = False;
1812
1813 current_state = (flags.shaded) ? IconicState : NormalState;
1814 setState(current_state);
1815
1816 XMapWindow(otk::OBDisplay::display, client.window);
1817 XMapSubwindows(otk::OBDisplay::display, frame.window);
1818 XMapWindow(otk::OBDisplay::display, frame.window);
1819
1820 #if 0
1821 int real_x, real_y;
1822 Window child;
1823 XTranslateCoordinates(otk::OBDisplay::display, client.window,
1824 screen->getRootWindow(),
1825 0, 0, &real_x, &real_y, &child);
1826 fprintf(stderr, "%s -- assumed: (%d, %d), real: (%d, %d)\n", getTitle(),
1827 client.rect.left(), client.rect.top(), real_x, real_y);
1828 assert(client.rect.left() == real_x && client.rect.top() == real_y);
1829 #endif
1830 }
1831
1832
1833 void BlackboxWindow::deiconify(bool reassoc, bool raise) {
1834 if (flags.iconic || reassoc)
1835 screen->reassociateWindow(this, otk::BSENTINEL, False);
1836 else if (blackbox_attrib.workspace != screen->getCurrentWorkspaceID())
1837 return;
1838
1839 show();
1840
1841 // reassociate and deiconify all transients
1842 if (reassoc && client.transientList.size() > 0) {
1843 BlackboxWindowList::iterator it, end = client.transientList.end();
1844 for (it = client.transientList.begin(); it != end; ++it)
1845 (*it)->deiconify(True, False);
1846 }
1847
1848 if (raise)
1849 screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
1850 }
1851
1852
1853 void BlackboxWindow::close(void) {
1854 if (! (functions & Func_Close)) return;
1855
1856 XEvent ce;
1857 ce.xclient.type = ClientMessage;
1858 ce.xclient.message_type = xatom->atom(otk::OBProperty::wm_protocols);
1859 ce.xclient.display = otk::OBDisplay::display;
1860 ce.xclient.window = client.window;
1861 ce.xclient.format = 32;
1862 ce.xclient.data.l[0] = xatom->atom(otk::OBProperty::wm_delete_window);
1863 ce.xclient.data.l[1] = CurrentTime;
1864 ce.xclient.data.l[2] = 0l;
1865 ce.xclient.data.l[3] = 0l;
1866 ce.xclient.data.l[4] = 0l;
1867 XSendEvent(otk::OBDisplay::display, client.window, False, NoEventMask, &ce);
1868 XFlush(otk::OBDisplay::display);
1869 }
1870
1871
1872 void BlackboxWindow::withdraw(void) {
1873 // We don't need to worry about resizing because resizing always grabs the X
1874 // server. This should only ever happen if using opaque moving.
1875 if (flags.moving)
1876 endMove();
1877
1878 flags.visible = False;
1879 flags.iconic = False;
1880
1881 setState(current_state);
1882
1883 XUnmapWindow(otk::OBDisplay::display, frame.window);
1884
1885 XGrabServer(otk::OBDisplay::display);
1886
1887 unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
1888 StructureNotifyMask;
1889 XSelectInput(otk::OBDisplay::display, client.window,
1890 event_mask & ~StructureNotifyMask);
1891 XUnmapWindow(otk::OBDisplay::display, client.window);
1892 XSelectInput(otk::OBDisplay::display, client.window, event_mask);
1893
1894 XUngrabServer(otk::OBDisplay::display);
1895 }
1896
1897
1898 void BlackboxWindow::maximize(unsigned int button) {
1899 if (! (functions & Func_Maximize)) return;
1900
1901 // We don't need to worry about resizing because resizing always grabs the X
1902 // server. This should only ever happen if using opaque moving.
1903 if (flags.moving)
1904 endMove();
1905
1906 if (flags.maximized) {
1907 flags.maximized = 0;
1908
1909 blackbox_attrib.flags &= ! (AttribMaxHoriz | AttribMaxVert);
1910 blackbox_attrib.attrib &= ! (AttribMaxHoriz | AttribMaxVert);
1911
1912 /*
1913 when a resize finishes, maximize(0) is called to clear any maximization
1914 flags currently set. Otherwise it still thinks it is maximized.
1915 so we do not need to call configure() because resizing will handle it
1916 */
1917 if (! flags.resizing)
1918 configure(blackbox_attrib.premax_x, blackbox_attrib.premax_y,
1919 blackbox_attrib.premax_w, blackbox_attrib.premax_h);
1920
1921 blackbox_attrib.premax_x = blackbox_attrib.premax_y = 0;
1922 blackbox_attrib.premax_w = blackbox_attrib.premax_h = 0;
1923
1924 redrawAllButtons(); // in case it is not called in configure()
1925 setState(current_state);
1926 return;
1927 }
1928
1929 blackbox_attrib.premax_x = frame.rect.x();
1930 blackbox_attrib.premax_y = frame.rect.y();
1931 blackbox_attrib.premax_w = frame.rect.width();
1932 // use client.rect so that clients can be restored even if shaded
1933 blackbox_attrib.premax_h =
1934 client.rect.height() + frame.margin.top + frame.margin.bottom;
1935
1936 #ifdef XINERAMA
1937 if (screen->isXineramaActive() && blackbox->doXineramaMaximizing()) {
1938 // find the area to use
1939 RectList availableAreas = screen->allAvailableAreas();
1940 RectList::iterator it, end = availableAreas.end();
1941
1942 for (it = availableAreas.begin(); it != end; ++it)
1943 if (it->intersects(frame.rect)) break;
1944 if (it == end) // the window isn't inside an area
1945 it = availableAreas.begin(); // so just default to the first one
1946
1947 frame.changing = *it;
1948 } else
1949 #endif // XINERAMA
1950 frame.changing = screen->availableArea();
1951
1952 switch(button) {
1953 case 1:
1954 blackbox_attrib.flags |= AttribMaxHoriz | AttribMaxVert;
1955 blackbox_attrib.attrib |= AttribMaxHoriz | AttribMaxVert;
1956 break;
1957
1958 case 2:
1959 blackbox_attrib.flags |= AttribMaxVert;
1960 blackbox_attrib.attrib |= AttribMaxVert;
1961
1962 frame.changing.setX(frame.rect.x());
1963 frame.changing.setWidth(frame.rect.width());
1964 break;
1965
1966 case 3:
1967 blackbox_attrib.flags |= AttribMaxHoriz;
1968 blackbox_attrib.attrib |= AttribMaxHoriz;
1969
1970 frame.changing.setY(frame.rect.y());
1971 frame.changing.setHeight(frame.rect.height());
1972 break;
1973 }
1974
1975 constrain(TopLeft);
1976
1977 if (flags.shaded) {
1978 blackbox_attrib.flags ^= AttribShaded;
1979 blackbox_attrib.attrib ^= AttribShaded;
1980 flags.shaded = False;
1981 }
1982
1983 flags.maximized = button;
1984
1985 configure(frame.changing.x(), frame.changing.y(),
1986 frame.changing.width(), frame.changing.height());
1987 if (flags.focused)
1988 screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
1989 redrawAllButtons(); // in case it is not called in configure()
1990 setState(current_state);
1991 }
1992
1993
1994 // re-maximizes the window to take into account availableArea changes
1995 void BlackboxWindow::remaximize(void) {
1996 if (flags.shaded) {
1997 // we only update the window's attributes otherwise we lose the shade bit
1998 switch(flags.maximized) {
1999 case 1:
2000 blackbox_attrib.flags |= AttribMaxHoriz | AttribMaxVert;
2001 blackbox_attrib.attrib |= AttribMaxHoriz | AttribMaxVert;
2002 break;
2003
2004 case 2:
2005 blackbox_attrib.flags |= AttribMaxVert;
2006 blackbox_attrib.attrib |= AttribMaxVert;
2007 break;
2008
2009 case 3:
2010 blackbox_attrib.flags |= AttribMaxHoriz;
2011 blackbox_attrib.attrib |= AttribMaxHoriz;
2012 break;
2013 }
2014 return;
2015 }
2016
2017 // save the original dimensions because maximize will wipe them out
2018 int premax_x = blackbox_attrib.premax_x,
2019 premax_y = blackbox_attrib.premax_y,
2020 premax_w = blackbox_attrib.premax_w,
2021 premax_h = blackbox_attrib.premax_h;
2022
2023 unsigned int button = flags.maximized;
2024 flags.maximized = 0; // trick maximize() into working
2025 maximize(button);
2026
2027 // restore saved values
2028 blackbox_attrib.premax_x = premax_x;
2029 blackbox_attrib.premax_y = premax_y;
2030 blackbox_attrib.premax_w = premax_w;
2031 blackbox_attrib.premax_h = premax_h;
2032 }
2033
2034
2035 void BlackboxWindow::setWorkspace(unsigned int n) {
2036 blackbox_attrib.flags |= AttribWorkspace;
2037 blackbox_attrib.workspace = n;
2038 if (n == otk::BSENTINEL) { // iconified window
2039 /*
2040 we set the workspace to 'all workspaces' so that taskbars will show the
2041 window. otherwise, it made uniconifying a window imposible without the
2042 blackbox workspace menu
2043 */
2044 n = 0xffffffff;
2045 }
2046 xatom->set(client.window, otk::OBProperty::net_wm_desktop,
2047 otk::OBProperty::Atom_Cardinal, n);
2048 }
2049
2050
2051 void BlackboxWindow::shade(void) {
2052 if (flags.shaded) {
2053 XResizeWindow(otk::OBDisplay::display, frame.window,
2054 frame.inside_w, frame.inside_h);
2055 flags.shaded = False;
2056 blackbox_attrib.flags ^= AttribShaded;
2057 blackbox_attrib.attrib ^= AttribShaded;
2058
2059 setState(NormalState);
2060
2061 // set the frame rect to the normal size
2062 frame.rect.setHeight(client.rect.height() + frame.margin.top +
2063 frame.margin.bottom);
2064 } else {
2065 if (! (decorations & Decor_Titlebar))
2066 return; // can't shade it without a titlebar!
2067
2068 XResizeWindow(otk::OBDisplay::display, frame.window,
2069 frame.inside_w, frame.title_h);
2070 flags.shaded = True;
2071 blackbox_attrib.flags |= AttribShaded;
2072 blackbox_attrib.attrib |= AttribShaded;
2073
2074 setState(IconicState);
2075
2076 // set the frame rect to the shaded size
2077 frame.rect.setHeight(frame.title_h + (frame.border_w * 2));
2078 }
2079 }
2080
2081
2082 /*
2083 * (Un)Sticks a window and its relatives.
2084 */
2085 void BlackboxWindow::stick(void) {
2086 if (flags.stuck) {
2087 blackbox_attrib.flags ^= AttribOmnipresent;
2088 blackbox_attrib.attrib ^= AttribOmnipresent;
2089
2090 flags.stuck = False;
2091
2092 for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
2093 if (i != blackbox_attrib.workspace)
2094 screen->getWorkspace(i)->removeWindow(this, True);
2095
2096 if (! flags.iconic)
2097 screen->reassociateWindow(this, otk::BSENTINEL, True);
2098 // temporary fix since sticky windows suck. set the hint to what we
2099 // actually hold in our data.
2100 xatom->set(client.window, otk::OBProperty::net_wm_desktop,
2101 otk::OBProperty::Atom_Cardinal,
2102 blackbox_attrib.workspace);
2103
2104 setState(current_state);
2105 } else {
2106 flags.stuck = True;
2107
2108 blackbox_attrib.flags |= AttribOmnipresent;
2109 blackbox_attrib.attrib |= AttribOmnipresent;
2110
2111 // temporary fix since sticky windows suck. set the hint to a different
2112 // value than that contained in the class' data.
2113 xatom->set(client.window, otk::OBProperty::net_wm_desktop,
2114 otk::OBProperty::Atom_Cardinal,
2115 0xffffffff);
2116
2117 for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
2118 if (i != blackbox_attrib.workspace)
2119 screen->getWorkspace(i)->addWindow(this, False, True);
2120
2121 setState(current_state);
2122 }
2123
2124 redrawAllButtons();
2125
2126 // go up the chain
2127 if (isTransient() && client.transient_for != (BlackboxWindow *) ~0ul &&
2128 client.transient_for->isStuck() != flags.stuck)
2129 client.transient_for->stick();
2130 // go down the chain
2131 BlackboxWindowList::iterator it;
2132 const BlackboxWindowList::iterator end = client.transientList.end();
2133 for (it = client.transientList.begin(); it != end; ++it)
2134 if ((*it)->isStuck() != flags.stuck)
2135 (*it)->stick();
2136 }
2137
2138
2139 void BlackboxWindow::redrawWindowFrame(void) const {
2140 if (decorations & Decor_Titlebar) {
2141 if (flags.focused) {
2142 if (frame.ftitle)
2143 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2144 frame.title, frame.ftitle);
2145 else
2146 XSetWindowBackground(otk::OBDisplay::display,
2147 frame.title, frame.ftitle_pixel);
2148 } else {
2149 if (frame.utitle)
2150 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2151 frame.title, frame.utitle);
2152 else
2153 XSetWindowBackground(otk::OBDisplay::display,
2154 frame.title, frame.utitle_pixel);
2155 }
2156 XClearWindow(otk::OBDisplay::display, frame.title);
2157
2158 redrawLabel();
2159 redrawAllButtons();
2160 }
2161
2162 if (decorations & Decor_Handle) {
2163 if (flags.focused) {
2164 if (frame.fhandle)
2165 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2166 frame.handle, frame.fhandle);
2167 else
2168 XSetWindowBackground(otk::OBDisplay::display,
2169 frame.handle, frame.fhandle_pixel);
2170
2171 if (frame.fgrip) {
2172 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2173 frame.left_grip, frame.fgrip);
2174 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2175 frame.right_grip, frame.fgrip);
2176 } else {
2177 XSetWindowBackground(otk::OBDisplay::display,
2178 frame.left_grip, frame.fgrip_pixel);
2179 XSetWindowBackground(otk::OBDisplay::display,
2180 frame.right_grip, frame.fgrip_pixel);
2181 }
2182 } else {
2183 if (frame.uhandle)
2184 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2185 frame.handle, frame.uhandle);
2186 else
2187 XSetWindowBackground(otk::OBDisplay::display,
2188 frame.handle, frame.uhandle_pixel);
2189
2190 if (frame.ugrip) {
2191 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2192 frame.left_grip, frame.ugrip);
2193 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2194 frame.right_grip, frame.ugrip);
2195 } else {
2196 XSetWindowBackground(otk::OBDisplay::display,
2197 frame.left_grip, frame.ugrip_pixel);
2198 XSetWindowBackground(otk::OBDisplay::display,
2199 frame.right_grip, frame.ugrip_pixel);
2200 }
2201 }
2202 XClearWindow(otk::OBDisplay::display, frame.handle);
2203 XClearWindow(otk::OBDisplay::display, frame.left_grip);
2204 XClearWindow(otk::OBDisplay::display, frame.right_grip);
2205 }
2206
2207 if (decorations & Decor_Border) {
2208 if (flags.focused)
2209 XSetWindowBorder(otk::OBDisplay::display,
2210 frame.plate, frame.fborder_pixel);
2211 else
2212 XSetWindowBorder(otk::OBDisplay::display,
2213 frame.plate, frame.uborder_pixel);
2214 }
2215 }
2216
2217
2218 void BlackboxWindow::setFocusFlag(bool focus) {
2219 // only focus a window if it is visible
2220 if (focus && ! flags.visible)
2221 return;
2222
2223 flags.focused = focus;
2224
2225 redrawWindowFrame();
2226
2227 if (flags.focused)
2228 blackbox->setFocusedWindow(this);
2229 }
2230
2231
2232 void BlackboxWindow::installColormap(bool install) {
2233 int i = 0, ncmap = 0;
2234 Colormap *cmaps = XListInstalledColormaps(otk::OBDisplay::display,
2235 client.window, &ncmap);
2236 if (cmaps) {
2237 XWindowAttributes wattrib;
2238 if (XGetWindowAttributes(otk::OBDisplay::display,
2239 client.window, &wattrib)) {
2240 if (install) {
2241 // install the window's colormap
2242 for (i = 0; i < ncmap; i++) {
2243 if (*(cmaps + i) == wattrib.colormap)
2244 // this window is using an installed color map... do not install
2245 install = False;
2246 }
2247 // otherwise, install the window's colormap
2248 if (install)
2249 XInstallColormap(otk::OBDisplay::display, wattrib.colormap);
2250 } else {
2251 // uninstall the window's colormap
2252 for (i = 0; i < ncmap; i++) {
2253 if (*(cmaps + i) == wattrib.colormap)
2254 // we found the colormap to uninstall
2255 XUninstallColormap(otk::OBDisplay::display, wattrib.colormap);
2256 }
2257 }
2258 }
2259
2260 XFree(cmaps);
2261 }
2262 }
2263
2264
2265 void BlackboxWindow::setAllowedActions(void) {
2266 Atom actions[7];
2267 int num = 0;
2268
2269 actions[num++] = xatom->atom(otk::OBProperty::net_wm_action_shade);
2270 actions[num++] = xatom->atom(otk::OBProperty::net_wm_action_change_desktop);
2271 actions[num++] = xatom->atom(otk::OBProperty::net_wm_action_close);
2272
2273 if (functions & Func_Move)
2274 actions[num++] = xatom->atom(otk::OBProperty::net_wm_action_move);
2275 if (functions & Func_Resize)
2276 actions[num++] = xatom->atom(otk::OBProperty::net_wm_action_resize);
2277 if (functions & Func_Maximize) {
2278 actions[num++] = xatom->atom(otk::OBProperty::net_wm_action_maximize_horz);
2279 actions[num++] = xatom->atom(otk::OBProperty::net_wm_action_maximize_vert);
2280 }
2281
2282 xatom->set(client.window, otk::OBProperty::net_wm_allowed_actions,
2283 otk::OBProperty::Atom_Atom,
2284 actions, num);
2285 }
2286
2287
2288 void BlackboxWindow::setState(unsigned long new_state) {
2289 current_state = new_state;
2290
2291 unsigned long state[2];
2292 state[0] = current_state;
2293 state[1] = None;
2294 xatom->set(client.window, otk::OBProperty::wm_state, otk::OBProperty::wm_state, state, 2);
2295
2296 xatom->set(client.window, otk::OBProperty::blackbox_attributes,
2297 otk::OBProperty::blackbox_attributes, (unsigned long *)&blackbox_attrib,
2298 PropBlackboxAttributesElements);
2299
2300 Atom netstate[8];
2301 int num = 0;
2302 if (flags.modal)
2303 netstate[num++] = xatom->atom(otk::OBProperty::net_wm_state_modal);
2304 if (flags.shaded)
2305 netstate[num++] = xatom->atom(otk::OBProperty::net_wm_state_shaded);
2306 if (flags.iconic)
2307 netstate[num++] = xatom->atom(otk::OBProperty::net_wm_state_hidden);
2308 if (flags.skip_taskbar)
2309 netstate[num++] = xatom->atom(otk::OBProperty::net_wm_state_skip_taskbar);
2310 if (flags.skip_pager)
2311 netstate[num++] = xatom->atom(otk::OBProperty::net_wm_state_skip_pager);
2312 if (flags.fullscreen)
2313 netstate[num++] = xatom->atom(otk::OBProperty::net_wm_state_fullscreen);
2314 if (flags.maximized == 1 || flags.maximized == 2)
2315 netstate[num++] = xatom->atom(otk::OBProperty::net_wm_state_maximized_vert);
2316 if (flags.maximized == 1 || flags.maximized == 3)
2317 netstate[num++] = xatom->atom(otk::OBProperty::net_wm_state_maximized_horz);
2318 xatom->set(client.window, otk::OBProperty::net_wm_state,
2319 otk::OBProperty::Atom_Atom,
2320 netstate, num);
2321 }
2322
2323
2324 bool BlackboxWindow::getState(void) {
2325 bool ret = xatom->get(client.window, otk::OBProperty::wm_state,
2326 otk::OBProperty::wm_state, &current_state);
2327 if (! ret) current_state = 0;
2328 return ret;
2329 }
2330
2331
2332 void BlackboxWindow::restoreAttributes(void) {
2333 unsigned long num = PropBlackboxAttributesElements;
2334 BlackboxAttributes *net;
2335 if (! xatom->get(client.window, otk::OBProperty::blackbox_attributes,
2336 otk::OBProperty::blackbox_attributes, &num,
2337 (unsigned long **)&net))
2338 return;
2339 if (num < PropBlackboxAttributesElements) {
2340 delete [] net;
2341 return;
2342 }
2343
2344 if (net->flags & AttribShaded && net->attrib & AttribShaded) {
2345 flags.shaded = False;
2346 unsigned long orig_state = current_state;
2347 shade();
2348
2349 /*
2350 At this point in the life of a window, current_state should only be set
2351 to IconicState if the window was an *icon*, not if it was shaded.
2352 */
2353 if (orig_state != IconicState)
2354 current_state = WithdrawnState;
2355 }
2356
2357 if (net->workspace != screen->getCurrentWorkspaceID() &&
2358 net->workspace < screen->getWorkspaceCount())
2359 screen->reassociateWindow(this, net->workspace, True);
2360
2361 if ((blackbox_attrib.workspace != screen->getCurrentWorkspaceID()) &&
2362 (blackbox_attrib.workspace < screen->getWorkspaceCount())) {
2363 // set to WithdrawnState so it will be mapped on the new workspace
2364 if (current_state == NormalState) current_state = WithdrawnState;
2365 } else if (current_state == WithdrawnState) {
2366 // the window is on this workspace and is Withdrawn, so it is waiting to
2367 // be mapped
2368 current_state = NormalState;
2369 }
2370
2371 if (net->flags & AttribOmnipresent && net->attrib & AttribOmnipresent &&
2372 ! flags.stuck) {
2373 stick();
2374
2375 // if the window was on another workspace, it was going to be hidden. this
2376 // specifies that the window should be mapped since it is sticky.
2377 if (current_state == WithdrawnState) current_state = NormalState;
2378 }
2379
2380 if (net->flags & AttribMaxHoriz || net->flags & AttribMaxVert) {
2381 int x = net->premax_x, y = net->premax_y;
2382 unsigned int w = net->premax_w, h = net->premax_h;
2383 flags.maximized = 0;
2384
2385 unsigned int m = 0;
2386 if ((net->flags & AttribMaxHoriz) &&
2387 (net->flags & AttribMaxVert))
2388 m = (net->attrib & (AttribMaxHoriz | AttribMaxVert)) ? 1 : 0;
2389 else if (net->flags & AttribMaxVert)
2390 m = (net->attrib & AttribMaxVert) ? 2 : 0;
2391 else if (net->flags & AttribMaxHoriz)
2392 m = (net->attrib & AttribMaxHoriz) ? 3 : 0;
2393
2394 if (m) maximize(m);
2395
2396 blackbox_attrib.premax_x = x;
2397 blackbox_attrib.premax_y = y;
2398 blackbox_attrib.premax_w = w;
2399 blackbox_attrib.premax_h = h;
2400 }
2401
2402 if (net->flags & AttribDecoration) {
2403 switch (net->decoration) {
2404 case DecorNone:
2405 enableDecor(False);
2406 break;
2407
2408 /* since tools only let you toggle this anyways, we'll just make that all
2409 it supports for now.
2410 */
2411 default:
2412 case DecorNormal:
2413 case DecorTiny:
2414 case DecorTool:
2415 enableDecor(True);
2416 break;
2417 }
2418 }
2419
2420 // with the state set it will then be the map event's job to read the
2421 // window's state and behave accordingly
2422
2423 delete [] net;
2424 }
2425
2426
2427 /*
2428 * Positions the Rect r according the the client window position and
2429 * window gravity.
2430 */
2431 void BlackboxWindow::applyGravity(otk::Rect &r) {
2432 // apply horizontal window gravity
2433 switch (client.win_gravity) {
2434 default:
2435 case NorthWestGravity:
2436 case SouthWestGravity:
2437 case WestGravity:
2438 r.setX(client.rect.x());
2439 break;
2440
2441 case NorthGravity:
2442 case SouthGravity:
2443 case CenterGravity:
2444 r.setX(client.rect.x() - (frame.margin.left + frame.margin.right) / 2);
2445 break;
2446
2447 case NorthEastGravity:
2448 case SouthEastGravity:
2449 case EastGravity:
2450 r.setX(client.rect.x() - frame.margin.left - frame.margin.right + 2);
2451 break;
2452
2453 case ForgetGravity:
2454 case StaticGravity:
2455 r.setX(client.rect.x() - frame.margin.left);
2456 break;
2457 }
2458
2459 // apply vertical window gravity
2460 switch (client.win_gravity) {
2461 default:
2462 case NorthWestGravity:
2463 case NorthEastGravity:
2464 case NorthGravity:
2465 r.setY(client.rect.y());
2466 break;
2467
2468 case CenterGravity:
2469 case EastGravity:
2470 case WestGravity:
2471 r.setY(client.rect.y() - (frame.margin.top + frame.margin.bottom) / 2);
2472 break;
2473
2474 case SouthWestGravity:
2475 case SouthEastGravity:
2476 case SouthGravity:
2477 r.setY(client.rect.y() - frame.margin.top - frame.margin.bottom + 2);
2478 break;
2479
2480 case ForgetGravity:
2481 case StaticGravity:
2482 r.setY(client.rect.y() - frame.margin.top);
2483 break;
2484 }
2485 }
2486
2487
2488 /*
2489 * The reverse of the applyGravity function.
2490 *
2491 * Positions the Rect r according to the frame window position and
2492 * window gravity.
2493 */
2494 void BlackboxWindow::restoreGravity(otk::Rect &r) {
2495 // restore horizontal window gravity
2496 switch (client.win_gravity) {
2497 default:
2498 case NorthWestGravity:
2499 case SouthWestGravity:
2500 case WestGravity:
2501 r.setX(frame.rect.x());
2502 break;
2503
2504 case NorthGravity:
2505 case SouthGravity:
2506 case CenterGravity:
2507 r.setX(frame.rect.x() + (frame.margin.left + frame.margin.right) / 2);
2508 break;
2509
2510 case NorthEastGravity:
2511 case SouthEastGravity:
2512 case EastGravity:
2513 r.setX(frame.rect.x() + frame.margin.left + frame.margin.right - 2);
2514 break;
2515
2516 case ForgetGravity:
2517 case StaticGravity:
2518 r.setX(frame.rect.x() + frame.margin.left);
2519 break;
2520 }
2521
2522 // restore vertical window gravity
2523 switch (client.win_gravity) {
2524 default:
2525 case NorthWestGravity:
2526 case NorthEastGravity:
2527 case NorthGravity:
2528 r.setY(frame.rect.y());
2529 break;
2530
2531 case CenterGravity:
2532 case EastGravity:
2533 case WestGravity:
2534 r.setY(frame.rect.y() + (frame.margin.top + frame.margin.bottom) / 2);
2535 break;
2536
2537 case SouthWestGravity:
2538 case SouthEastGravity:
2539 case SouthGravity:
2540 r.setY(frame.rect.y() + frame.margin.top + frame.margin.bottom - 2);
2541 break;
2542
2543 case ForgetGravity:
2544 case StaticGravity:
2545 r.setY(frame.rect.y() + frame.margin.top);
2546 break;
2547 }
2548 }
2549
2550
2551 void BlackboxWindow::redrawLabel(void) const {
2552 if (flags.focused) {
2553 if (frame.flabel)
2554 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2555 frame.label, frame.flabel);
2556 else
2557 XSetWindowBackground(otk::OBDisplay::display,
2558 frame.label, frame.flabel_pixel);
2559 } else {
2560 if (frame.ulabel)
2561 XSetWindowBackgroundPixmap(otk::OBDisplay::display,
2562 frame.label, frame.ulabel);
2563 else
2564 XSetWindowBackground(otk::OBDisplay::display,
2565 frame.label, frame.ulabel_pixel);
2566 }
2567 XClearWindow(otk::OBDisplay::display, frame.label);
2568
2569 otk::Style *style = screen->getWindowStyle();
2570
2571 int pos = frame.bevel_w * 2;
2572 style->doJustify(client.title.c_str(), pos, frame.label_w, frame.bevel_w * 4);
2573 style->font->drawString(frame.label, pos, 1,
2574 (flags.focused ? style->l_text_focus :
2575 style->l_text_unfocus),
2576 client.title);
2577 }
2578
2579
2580 void BlackboxWindow::redrawAllButtons(void) const {
2581 if (frame.iconify_button) redrawIconifyButton(False);
2582 if (frame.maximize_button) redrawMaximizeButton(flags.maximized);
2583 if (frame.close_button) redrawCloseButton(False);
2584 if (frame.stick_button) redrawStickyButton(flags.stuck);
2585 }
2586
2587
2588 void BlackboxWindow::redrawButton(bool pressed, Window win,
2589 Pixmap fppix, unsigned long fppixel,
2590 Pixmap uppix, unsigned long uppixel,
2591 Pixmap fpix, unsigned long fpixel,
2592 Pixmap upix, unsigned long upixel) const {
2593 Pixmap p;
2594 unsigned long pix;
2595
2596 if (pressed) {
2597 if (flags.focused) {
2598 p = fppix;
2599 pix = fppixel;
2600 } else {
2601 p = uppix;
2602 pix = uppixel;
2603 }
2604 } else {
2605 if (flags.focused) {
2606 p = fpix;
2607 pix = fpixel;
2608 } else {
2609 p = upix;
2610 pix = upixel;
2611 }
2612 }
2613
2614 if (p)
2615 XSetWindowBackgroundPixmap(otk::OBDisplay::display, win, p);
2616 else
2617 XSetWindowBackground(otk::OBDisplay::display, win, pix);
2618
2619 }
2620
2621 void BlackboxWindow::redrawIconifyButton(bool pressed) const {
2622 redrawButton(pressed, frame.iconify_button,
2623 frame.pfbutton, frame.pfbutton_pixel,
2624 frame.pubutton, frame.pubutton_pixel,
2625 frame.fbutton, frame.fbutton_pixel,
2626 frame.ubutton, frame.ubutton_pixel);
2627
2628 XClearWindow(otk::OBDisplay::display, frame.iconify_button);
2629 otk::BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
2630 screen->getWindowStyle()->b_pic_unfocus);
2631
2632 otk::Style::PixmapMask pm = screen->getWindowStyle()->icon_button;
2633
2634 if (screen->getWindowStyle()->icon_button.mask != None) {
2635 XSetClipMask(otk::OBDisplay::display, pen.gc(), pm.mask);
2636 XSetClipOrigin(otk::OBDisplay::display, pen.gc(),
2637 (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
2638
2639 XFillRectangle(otk::OBDisplay::display, frame.iconify_button, pen.gc(),
2640 (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
2641 (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
2642
2643 XSetClipMask(otk::OBDisplay::display, pen.gc(), None);
2644 XSetClipOrigin(otk::OBDisplay::display, pen.gc(), 0, 0);
2645 } else {
2646 XDrawRectangle(otk::OBDisplay::display, frame.iconify_button, pen.gc(),
2647 2, (frame.button_w - 5), (frame.button_w - 5), 2);
2648 }
2649 }
2650
2651
2652 void BlackboxWindow::redrawMaximizeButton(bool pressed) const {
2653 redrawButton(pressed, frame.maximize_button,
2654 frame.pfbutton, frame.pfbutton_pixel,
2655 frame.pubutton, frame.pubutton_pixel,
2656 frame.fbutton, frame.fbutton_pixel,
2657 frame.ubutton, frame.ubutton_pixel);
2658
2659 XClearWindow(otk::OBDisplay::display, frame.maximize_button);
2660
2661 otk::BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
2662 screen->getWindowStyle()->b_pic_unfocus);
2663
2664 otk::Style::PixmapMask pm = screen->getWindowStyle()->max_button;
2665
2666 if (pm.mask != None) {
2667 XSetClipMask(otk::OBDisplay::display, pen.gc(), pm.mask);
2668 XSetClipOrigin(otk::OBDisplay::display, pen.gc(),
2669 (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
2670
2671 XFillRectangle(otk::OBDisplay::display, frame.maximize_button, pen.gc(),
2672 (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
2673 (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
2674
2675 XSetClipOrigin(otk::OBDisplay::display, pen.gc(), 0, 0 );
2676 XSetClipMask( otk::OBDisplay::display, pen.gc(), None );
2677 } else {
2678 XDrawRectangle(otk::OBDisplay::display, frame.maximize_button, pen.gc(),
2679 2, 2, (frame.button_w - 5), (frame.button_w - 5));
2680 XDrawLine(otk::OBDisplay::display, frame.maximize_button, pen.gc(),
2681 2, 3, (frame.button_w - 3), 3);
2682 }
2683 }
2684
2685
2686 void BlackboxWindow::redrawCloseButton(bool pressed) const {
2687 redrawButton(pressed, frame.close_button,
2688 frame.pfbutton, frame.pfbutton_pixel,
2689 frame.pubutton, frame.pubutton_pixel,
2690 frame.fbutton, frame.fbutton_pixel,
2691 frame.ubutton, frame.ubutton_pixel);
2692
2693 XClearWindow(otk::OBDisplay::display, frame.close_button);
2694
2695 otk::BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
2696 screen->getWindowStyle()->b_pic_unfocus);
2697
2698 otk::Style::PixmapMask pm = screen->getWindowStyle()->close_button;
2699
2700 if (pm.mask != None) {
2701 XSetClipMask(otk::OBDisplay::display, pen.gc(), pm.mask);
2702 XSetClipOrigin(otk::OBDisplay::display, pen.gc(),
2703 (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
2704
2705 XFillRectangle(otk::OBDisplay::display, frame.close_button, pen.gc(),
2706 (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
2707 (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
2708
2709
2710 XSetClipOrigin(otk::OBDisplay::display, pen.gc(), 0, 0 );
2711 XSetClipMask( otk::OBDisplay::display, pen.gc(), None );
2712 } else {
2713 XDrawLine(otk::OBDisplay::display, frame.close_button, pen.gc(),
2714 2, 2, (frame.button_w - 3), (frame.button_w - 3));
2715 XDrawLine(otk::OBDisplay::display, frame.close_button, pen.gc(),
2716 2, (frame.button_w - 3), (frame.button_w - 3), 2);
2717 }
2718 }
2719
2720 void BlackboxWindow::redrawStickyButton(bool pressed) const {
2721 redrawButton(pressed, frame.stick_button,
2722 frame.pfbutton, frame.pfbutton_pixel,
2723 frame.pubutton, frame.pubutton_pixel,
2724 frame.fbutton, frame.fbutton_pixel,
2725 frame.ubutton, frame.ubutton_pixel);
2726
2727 XClearWindow(otk::OBDisplay::display, frame.stick_button);
2728
2729 otk::BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
2730 screen->getWindowStyle()->b_pic_unfocus);
2731
2732 otk::Style::PixmapMask pm = screen->getWindowStyle()->stick_button;
2733
2734 if (pm.mask != None) {
2735 XSetClipMask(otk::OBDisplay::display, pen.gc(), pm.mask);
2736 XSetClipOrigin(otk::OBDisplay::display, pen.gc(),
2737 (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
2738
2739 XFillRectangle(otk::OBDisplay::display, frame.stick_button, pen.gc(),
2740 (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
2741 (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
2742
2743
2744 XSetClipOrigin(otk::OBDisplay::display, pen.gc(), 0, 0 );
2745 XSetClipMask( otk::OBDisplay::display, pen.gc(), None );
2746 } else {
2747 XFillRectangle(otk::OBDisplay::display, frame.stick_button, pen.gc(),
2748 frame.button_w/2 - 1, frame.button_w/2 -1, 2, 2 );
2749 }
2750 }
2751
2752 void BlackboxWindow::mapRequestEvent(const XMapRequestEvent *re) {
2753 if (re->window != client.window)
2754 return;
2755
2756 #ifdef DEBUG
2757 fprintf(stderr, "BlackboxWindow::mapRequestEvent() for 0x%lx\n",
2758 client.window);
2759 #endif // DEBUG
2760
2761 /*
2762 Even though the window wants to be shown, if it is not on the current
2763 workspace, then it isn't going to be shown right now.
2764 */
2765 if (! flags.stuck &&
2766 blackbox_attrib.workspace != screen->getCurrentWorkspaceID() &&
2767 blackbox_attrib.workspace < screen->getWorkspaceCount())
2768 if (current_state == NormalState) current_state = WithdrawnState;
2769
2770 switch (current_state) {
2771 case IconicState:
2772 iconify();
2773 break;
2774
2775 case WithdrawnState:
2776 withdraw();
2777 break;
2778
2779 case NormalState:
2780 case InactiveState:
2781 case ZoomState:
2782 default:
2783 show();
2784 screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
2785 if (isNormal()) {
2786 if (blackbox->state() != Openbox::State_Starting) {
2787 XSync(otk::OBDisplay::display, False); // make sure the frame is mapped
2788 if (screen->doFocusNew() || (isTransient() && getTransientFor() &&
2789 getTransientFor()->isFocused())) {
2790 setInputFocus();
2791 }
2792 if (screen->getPlacementPolicy() == BScreen::ClickMousePlacement) {
2793 int x, y, rx, ry;
2794 Window c, r;
2795 unsigned int m;
2796 XQueryPointer(otk::OBDisplay::display, screen->getRootWindow(),
2797 &r, &c, &rx, &ry, &x, &y, &m);
2798 beginMove(rx, ry);
2799 }
2800 }
2801 }
2802 break;
2803 }
2804 }
2805
2806
2807 void BlackboxWindow::unmapNotifyEvent(const XUnmapEvent *ue) {
2808 if (ue->window != client.window)
2809 return;
2810
2811 #ifdef DEBUG
2812 fprintf(stderr, "BlackboxWindow::unmapNotifyEvent() for 0x%lx\n",
2813 client.window);
2814 #endif // DEBUG
2815
2816 screen->unmanageWindow(this, False);
2817 }
2818
2819
2820 void BlackboxWindow::destroyNotifyEvent(const XDestroyWindowEvent *de) {
2821 if (de->window != client.window)
2822 return;
2823
2824 #ifdef DEBUG
2825 fprintf(stderr, "BlackboxWindow::destroyNotifyEvent() for 0x%lx\n",
2826 client.window);
2827 #endif // DEBUG
2828
2829 screen->unmanageWindow(this, False);
2830 }
2831
2832
2833 void BlackboxWindow::reparentNotifyEvent(const XReparentEvent *re) {
2834 if (re->window != client.window || re->parent == frame.plate)
2835 return;
2836
2837 #ifdef DEBUG
2838 fprintf(stderr, "BlackboxWindow::reparentNotifyEvent(): reparent 0x%lx to "
2839 "0x%lx.\n", client.window, re->parent);
2840 #endif // DEBUG
2841
2842 XEvent ev;
2843 ev.xreparent = *re;
2844 XPutBackEvent(otk::OBDisplay::display, &ev);
2845 screen->unmanageWindow(this, True);
2846 }
2847
2848
2849 void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent *pe) {
2850 if (pe->state == PropertyDelete || ! validateClient())
2851 return;
2852
2853 #if 0
2854 fprintf(stderr, "BlackboxWindow::propertyNotifyEvent(): for 0x%lx\n",
2855 client.window);
2856 #endif
2857
2858 switch(pe->atom) {
2859 case XA_WM_CLASS:
2860 case XA_WM_CLIENT_MACHINE:
2861 case XA_WM_COMMAND:
2862 break;
2863
2864 case XA_WM_TRANSIENT_FOR: {
2865 bool s = flags.stuck;
2866
2867 // determine if this is a transient window
2868 getTransientInfo();
2869
2870 if (flags.stuck != s) stick();
2871
2872 // adjust the window decorations based on transience
2873 if (isTransient()) {
2874 functions &= ~Func_Maximize;
2875 setAllowedActions();
2876 setupDecor();
2877 }
2878
2879 reconfigure();
2880 }
2881 break;
2882
2883 case XA_WM_HINTS:
2884 getWMHints();
2885 break;
2886
2887 case XA_WM_ICON_NAME:
2888 getWMIconName();
2889 if (flags.iconic) screen->propagateWindowName(this);
2890 break;
2891
2892 case otk::OBProperty::net_wm_name:
2893 case XA_WM_NAME:
2894 getWMName();
2895
2896 if (decorations & Decor_Titlebar)
2897 redrawLabel();
2898
2899 screen->propagateWindowName(this);
2900 break;
2901
2902 case XA_WM_NORMAL_HINTS: {
2903 getWMNormalHints();
2904
2905 if ((client.normal_hint_flags & PMinSize) &&
2906 (client.normal_hint_flags & PMaxSize)) {
2907 // the window now can/can't resize itself, so the buttons need to be
2908 // regrabbed.
2909 ungrabButtons();
2910 if (client.max_width <= client.min_width &&
2911 client.max_height <= client.min_height) {
2912 functions &= ~(Func_Resize | Func_Maximize);
2913 } else {
2914 if (! isTransient())
2915 functions |= Func_Maximize;
2916 functions |= Func_Resize;
2917 }
2918 grabButtons();
2919 setAllowedActions();
2920 setupDecor();
2921 }
2922
2923 otk::Rect old_rect = frame.rect;
2924
2925 upsize();
2926
2927 if (old_rect != frame.rect)
2928 reconfigure();
2929
2930 break;
2931 }
2932
2933 default:
2934 if (pe->atom == xatom->atom(otk::OBProperty::wm_protocols)) {
2935 getWMProtocols();
2936
2937 if ((decorations & Decor_Close) && (! frame.close_button)) {
2938 createCloseButton();
2939 if (decorations & Decor_Titlebar) {
2940 positionButtons(True);
2941 XMapSubwindows(otk::OBDisplay::display, frame.title);
2942 }
2943 }
2944 } else if (pe->atom == xatom->atom(otk::OBProperty::net_wm_strut)) {
2945 updateStrut();
2946 }
2947
2948 break;
2949 }
2950 }
2951
2952
2953 void BlackboxWindow::exposeEvent(const XExposeEvent *ee) {
2954 #if 0
2955 fprintf(stderr, "BlackboxWindow::exposeEvent() for 0x%lx\n", client.window);
2956 #endif
2957
2958 if (frame.label == ee->window && (decorations & Decor_Titlebar))
2959 redrawLabel();
2960 else if (frame.close_button == ee->window)
2961 redrawCloseButton(False);
2962 else if (frame.maximize_button == ee->window)
2963 redrawMaximizeButton(flags.maximized);
2964 else if (frame.iconify_button == ee->window)
2965 redrawIconifyButton(False);
2966 else if (frame.stick_button == ee->window)
2967 redrawStickyButton(flags.stuck);
2968 }
2969
2970
2971 void BlackboxWindow::configureRequestEvent(const XConfigureRequestEvent *cr) {
2972 if (cr->window != client.window || flags.iconic)
2973 return;
2974
2975 if (cr->value_mask & CWBorderWidth)
2976 client.old_bw = cr->border_width;
2977
2978 if (cr->value_mask & (CWX | CWY | CWWidth | CWHeight)) {
2979 frame.changing = frame.rect;
2980
2981 if (cr->value_mask & (CWX | CWY)) {
2982 if (cr->value_mask & CWX)
2983 client.rect.setX(cr->x);
2984 if (cr->value_mask & CWY)
2985 client.rect.setY(cr->y);
2986
2987 applyGravity(frame.changing);
2988 }
2989
2990 if (cr->value_mask & (CWWidth | CWHeight)) {
2991 if (cr->value_mask & CWWidth)
2992 frame.changing.setWidth(cr->width +
2993 frame.margin.left + frame.margin.right);
2994
2995 if (cr->value_mask & CWHeight)
2996 frame.changing.setHeight(cr->height +
2997 frame.margin.top + frame.margin.bottom);
2998
2999 /*
3000 if a position change has been specified, then that position will be
3001 used instead of determining a position based on the window's gravity.
3002 */
3003 if (! (cr->value_mask & (CWX | CWY))) {
3004 Corner corner;
3005 switch (client.win_gravity) {
3006 case NorthEastGravity:
3007 case EastGravity:
3008 corner = TopRight;
3009 break;
3010 case SouthWestGravity:
3011 case SouthGravity:
3012 corner = BottomLeft;
3013 break;
3014 case SouthEastGravity:
3015 corner = BottomRight;
3016 break;
3017 default: // NorthWest, Static, etc
3018 corner = TopLeft;
3019 }
3020 constrain(corner);
3021 }
3022 }
3023
3024 configure(frame.changing.x(), frame.changing.y(),
3025 frame.changing.width(), frame.changing.height());
3026 }
3027
3028 if (cr->value_mask & CWStackMode && !isDesktop()) {
3029 switch (cr->detail) {
3030 case Below:
3031 case BottomIf:
3032 screen->getWorkspace(blackbox_attrib.workspace)->lowerWindow(this);
3033 break;
3034
3035 case Above:
3036 case TopIf:
3037 default:
3038 screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
3039 break;
3040 }
3041 }
3042 }
3043
3044
3045 void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
3046 #ifdef DEBUG
3047 fprintf(stderr, "BlackboxWindow::buttonPressEvent() for 0x%lx\n",
3048 client.window);
3049 #endif
3050
3051 if (frame.maximize_button == be->window && be->button <= 3) {
3052 redrawMaximizeButton(True);
3053 } else if (be->button == 1 || (be->button == 3 && be->state == mod_mask)) {
3054 if (! flags.focused)
3055 setInputFocus();
3056
3057 if (frame.iconify_button == be->window) {
3058 redrawIconifyButton(True);
3059 } else if (frame.close_button == be->window) {
3060 redrawCloseButton(True);
3061 } else if (frame.stick_button == be->window) {
3062 redrawStickyButton(True);
3063 } else if (frame.plate == be->window) {
3064 screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
3065
3066 XAllowEvents(otk::OBDisplay::display, ReplayPointer, be->time);
3067 } else {
3068 if (frame.title == be->window || frame.label == be->window) {
3069 if (((be->time - lastButtonPressTime) <=
3070 blackbox->getDoubleClickInterval()) ||
3071 (be->state == ControlMask)) {
3072 lastButtonPressTime = 0;
3073 shade();
3074 } else {
3075 lastButtonPressTime = be->time;
3076 }
3077 }
3078
3079 screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
3080 }
3081 } else if (be->button == 2 && (be->window != frame.iconify_button) &&
3082 (be->window != frame.close_button) &&
3083 (be->window != frame.stick_button)) {
3084 screen->getWorkspace(blackbox_attrib.workspace)->lowerWindow(this);
3085 // mouse wheel up
3086 } else if (be->button == 4) {
3087 if ((be->window == frame.label ||
3088 be->window == frame.title ||
3089 be->window == frame.maximize_button ||
3090 be->window == frame.iconify_button ||
3091 be->window == frame.close_button ||
3092 be->window == frame.stick_button) &&
3093 ! flags.shaded)
3094 shade();
3095 // mouse wheel down
3096 } else if (be->button == 5) {
3097 if ((be->window == frame.label ||
3098 be->window == frame.title ||
3099 be->window == frame.maximize_button ||
3100 be->window == frame.iconify_button ||
3101 be->window == frame.close_button ||
3102 be->window == frame.stick_button) &&
3103 flags.shaded)
3104 shade();
3105 }
3106 }
3107
3108
3109 void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) {
3110 #ifdef DEBUG
3111 fprintf(stderr, "BlackboxWindow::buttonReleaseEvent() for 0x%lx\n",
3112 client.window);
3113 #endif
3114
3115 if (re->window == frame.maximize_button &&
3116 re->button >= 1 && re->button <= 3) {
3117 if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
3118 (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w))) {
3119 maximize(re->button);
3120 } else {
3121 redrawMaximizeButton(flags.maximized);
3122 }
3123 } else if (re->window == frame.iconify_button && re->button == 1) {
3124 if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
3125 (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w))) {
3126 iconify();
3127 } else {
3128 redrawIconifyButton(False);
3129 }
3130 } else if (re->window == frame.stick_button && re->button == 1) {
3131 if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
3132 (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w))) {
3133 stick();
3134 } else {
3135 redrawStickyButton(False);
3136 }
3137 } else if (re->window == frame.close_button & re->button == 1) {
3138 if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
3139 (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w)))
3140 close();
3141 redrawCloseButton(False);
3142 } else if (flags.moving) {
3143 endMove();
3144 } else if (flags.resizing) {
3145 endResize();
3146 } else if (re->window == frame.window) {
3147 if (re->button == 2 && re->state == mod_mask)
3148 XUngrabPointer(otk::OBDisplay::display, CurrentTime);
3149 }
3150 }
3151
3152
3153
3154 void BlackboxWindow::beginMove(int x_root, int y_root) {
3155 if (! (functions & Func_Move)) return;
3156
3157 assert(! (flags.resizing || flags.moving));
3158
3159 /*
3160 Only one window can be moved/resized at a time. If another window is already
3161 being moved or resized, then stop it before whating to work with this one.
3162 */
3163 BlackboxWindow *changing = blackbox->getChangingWindow();
3164 if (changing && changing != this) {
3165 if (changing->flags.moving)
3166 changing->endMove();
3167 else // if (changing->flags.resizing)
3168 changing->endResize();
3169 }
3170
3171 XGrabPointer(otk::OBDisplay::display, frame.window, False,
3172 PointerMotionMask | ButtonReleaseMask,
3173 GrabModeAsync, GrabModeAsync,
3174 None, blackbox->getMoveCursor(), CurrentTime);
3175
3176 flags.moving = True;
3177 blackbox->setChangingWindow(this);
3178
3179 if (! screen->doOpaqueMove()) {
3180 XGrabServer(otk::OBDisplay::display);
3181
3182 frame.changing = frame.rect;
3183 screen->showPosition(frame.changing.x(), frame.changing.y());
3184
3185 XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3186 screen->getOpGC(),
3187 frame.changing.x(),
3188 frame.changing.y(),
3189 frame.changing.width() - 1,
3190 frame.changing.height() - 1);
3191 }
3192
3193 frame.grab_x = x_root - frame.rect.x() - frame.border_w;
3194 frame.grab_y = y_root - frame.rect.y() - frame.border_w;
3195 }
3196
3197
3198 void BlackboxWindow::doMove(int x_root, int y_root) {
3199 assert(flags.moving);
3200 assert(blackbox->getChangingWindow() == this);
3201
3202 int dx = x_root - frame.grab_x, dy = y_root - frame.grab_y;
3203 dx -= frame.border_w;
3204 dy -= frame.border_w;
3205
3206 doWindowSnapping(dx, dy);
3207
3208 if (screen->doOpaqueMove()) {
3209 if (screen->doWorkspaceWarping())
3210 doWorkspaceWarping(x_root, y_root, dx);
3211
3212 configure(dx, dy, frame.rect.width(), frame.rect.height());
3213 } else {
3214 XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3215 screen->getOpGC(),
3216 frame.changing.x(),
3217 frame.changing.y(),
3218 frame.changing.width() - 1,
3219 frame.changing.height() - 1);
3220
3221 if (screen->doWorkspaceWarping())
3222 doWorkspaceWarping(x_root, y_root, dx);
3223
3224 frame.changing.setPos(dx, dy);
3225
3226 XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3227 screen->getOpGC(),
3228 frame.changing.x(),
3229 frame.changing.y(),
3230 frame.changing.width() - 1,
3231 frame.changing.height() - 1);
3232 }
3233
3234 screen->showPosition(dx, dy);
3235 }
3236
3237
3238 void BlackboxWindow::doWorkspaceWarping(int x_root, int y_root, int &dx) {
3239 // workspace warping
3240 bool warp = False;
3241 unsigned int dest = screen->getCurrentWorkspaceID();
3242 if (x_root <= 0) {
3243 warp = True;
3244
3245 if (dest > 0) dest--;
3246 else dest = screen->getNumberOfWorkspaces() - 1;
3247
3248 } else if (x_root >= screen->getRect().right()) {
3249 warp = True;
3250
3251 if (dest < screen->getNumberOfWorkspaces() - 1) dest++;
3252 else dest = 0;
3253 }
3254 if (! warp)
3255 return;
3256
3257 bool focus = flags.focused; // had focus while moving?
3258
3259 int dest_x = x_root;
3260 if (x_root <= 0) {
3261 dest_x += screen->getRect().width() - 1;
3262 dx += screen->getRect().width() - 1;
3263 } else {
3264 dest_x -= screen->getRect().width() - 1;
3265 dx -= screen->getRect().width() - 1;
3266 }
3267
3268 if (! flags.stuck)
3269 screen->reassociateWindow(this, dest, False);
3270 screen->changeWorkspaceID(dest);
3271
3272 if (screen->doOpaqueMove())
3273 XGrabServer(otk::OBDisplay::display);
3274
3275 XUngrabPointer(otk::OBDisplay::display, CurrentTime);
3276 XWarpPointer(otk::OBDisplay::display, None,
3277 screen->getRootWindow(), 0, 0, 0, 0,
3278 dest_x, y_root);
3279 XGrabPointer(otk::OBDisplay::display, frame.window, False,
3280 PointerMotionMask | ButtonReleaseMask,
3281 GrabModeAsync, GrabModeAsync,
3282 None, blackbox->getMoveCursor(), CurrentTime);
3283
3284 if (screen->doOpaqueMove())
3285 XUngrabServer(otk::OBDisplay::display);
3286
3287 if (focus)
3288 setInputFocus();
3289
3290 }
3291
3292
3293 void BlackboxWindow::doWindowSnapping(int &dx, int &dy) {
3294 // how much resistance to edges to provide
3295 const int resistance_size = screen->getResistanceSize();
3296
3297 // how far away to snap
3298 const int snap_distance = screen->getSnapThreshold();
3299
3300 // how to snap windows
3301 const int snap_to_windows = screen->getWindowToWindowSnap();
3302 const int snap_to_edges = screen->getWindowToEdgeSnap();
3303 // the amount of space away from the edge to provide resistance/snap
3304 const int snap_offset = screen->getSnapOffset();
3305
3306 // find the geomeetery where the moving window currently is
3307 const otk::Rect &moving =
3308 screen->doOpaqueMove() ? frame.rect : frame.changing;
3309
3310 // window corners
3311 const int wleft = dx,
3312 wright = dx + frame.rect.width() - 1,
3313 wtop = dy,
3314 wbottom = dy + frame.rect.height() - 1;
3315
3316 if (snap_to_windows) {
3317 otk::RectList rectlist;
3318
3319 Workspace *w = screen->getWorkspace(getWorkspaceNumber());
3320 assert(w);
3321
3322 // add windows on the workspace to the rect list
3323 const BlackboxWindowList& stack_list = w->getStackingList();
3324 BlackboxWindowList::const_iterator st_it, st_end = stack_list.end();
3325 for (st_it = stack_list.begin(); st_it != st_end; ++st_it)
3326 if (*st_it != this) // don't snap to ourself
3327 rectlist.push_back( (*st_it)->frameRect() );
3328
3329 otk::RectList::const_iterator it, end = rectlist.end();
3330 for (it = rectlist.begin(); it != end; ++it) {
3331 bool snapped = False;
3332 const otk::Rect &winrect = *it;
3333 otk::Rect offsetrect;
3334 offsetrect.setCoords(winrect.left() - snap_offset,
3335 winrect.top() - snap_offset,
3336 winrect.right() + snap_offset,
3337 winrect.bottom() + snap_offset);
3338
3339 if (snap_to_windows == BScreen::WindowResistance)
3340 // if the window is already over top of this snap target, then
3341 // resistance is futile, so just ignore it
3342 if (winrect.intersects(moving))
3343 continue;
3344
3345 int dleft, dright, dtop, dbottom;
3346
3347 // if the windows are in the same plane vertically
3348 if (wtop >= (signed)(winrect.y() - frame.rect.height() + 1) &&
3349 wtop < (signed)(winrect.y() + winrect.height() - 1)) {
3350
3351 if (snap_to_windows == BScreen::WindowResistance) {
3352 dleft = wright - offsetrect.left();
3353 dright = offsetrect.right() - wleft;
3354
3355 // snap left of other window?
3356 if (dleft >= 0 && dleft < resistance_size &&
3357 dleft < (wright - wleft)) {
3358 dx = offsetrect.left() - frame.rect.width();
3359 snapped = True;
3360 }
3361 // snap right of other window?
3362 else if (dright >= 0 && dright < resistance_size &&
3363 dright < (wright - wleft)) {
3364 dx = offsetrect.right() + 1;
3365 snapped = True;
3366 }
3367 } else { // BScreen::WindowSnap
3368 dleft = abs(wright - offsetrect.left());
3369 dright = abs(wleft - offsetrect.right());
3370
3371 // snap left of other window?
3372 if (dleft < snap_distance && dleft <= dright) {
3373 dx = offsetrect.left() - frame.rect.width();
3374 snapped = True;
3375 }
3376 // snap right of other window?
3377 else if (dright < snap_distance) {
3378 dx = offsetrect.right() + 1;
3379 snapped = True;
3380 }
3381 }
3382
3383 if (snapped) {
3384 if (screen->getWindowCornerSnap()) {
3385 // try corner-snap to its other sides
3386 if (snap_to_windows == BScreen::WindowResistance) {
3387 dtop = winrect.top() - wtop;
3388 dbottom = wbottom - winrect.bottom();
3389 if (dtop > 0 && dtop < resistance_size) {
3390 // if we're already past the top edge, then don't provide
3391 // resistance
3392 if (moving.top() >= winrect.top())
3393 dy = winrect.top();
3394 } else if (dbottom > 0 && dbottom < resistance_size) {
3395 // if we're already past the bottom edge, then don't provide
3396 // resistance
3397 if (moving.bottom() <= winrect.bottom())
3398 dy = winrect.bottom() - frame.rect.height() + 1;
3399 }
3400 } else { // BScreen::WindowSnap
3401 dtop = abs(wtop - winrect.top());
3402 dbottom = abs(wbottom - winrect.bottom());
3403 if (dtop < snap_distance && dtop <= dbottom)
3404 dy = winrect.top();
3405 else if (dbottom < snap_distance)
3406 dy = winrect.bottom() - frame.rect.height() + 1;
3407 }
3408 }
3409
3410 continue;
3411 }
3412 }
3413
3414 // if the windows are on the same plane horizontally
3415 if (wleft >= (signed)(winrect.x() - frame.rect.width() + 1) &&
3416 wleft < (signed)(winrect.x() + winrect.width() - 1)) {
3417
3418 if (snap_to_windows == BScreen::WindowResistance) {
3419 dtop = wbottom - offsetrect.top();
3420 dbottom = offsetrect.bottom() - wtop;
3421
3422 // snap top of other window?
3423 if (dtop >= 0 && dtop < resistance_size && dtop < (wbottom - wtop)) {
3424 dy = offsetrect.top() - frame.rect.height();
3425 snapped = True;
3426 }
3427 // snap bottom of other window?
3428 else if (dbottom >= 0 && dbottom < resistance_size &&
3429 dbottom < (wbottom - wtop)) {
3430 dy = offsetrect.bottom() + 1;
3431 snapped = True;
3432 }
3433 } else { // BScreen::WindowSnap
3434 dtop = abs(wbottom - offsetrect.top());
3435 dbottom = abs(wtop - offsetrect.bottom());
3436
3437 // snap top of other window?
3438 if (dtop < snap_distance && dtop <= dbottom) {
3439 dy = offsetrect.top() - frame.rect.height();
3440 snapped = True;
3441 }
3442 // snap bottom of other window?
3443 else if (dbottom < snap_distance) {
3444 dy = offsetrect.bottom() + 1;
3445 snapped = True;
3446 }
3447
3448 }
3449
3450 if (snapped) {
3451 if (screen->getWindowCornerSnap()) {
3452 // try corner-snap to its other sides
3453 if (snap_to_windows == BScreen::WindowResistance) {
3454 dleft = winrect.left() - wleft;
3455 dright = wright - winrect.right();
3456 if (dleft > 0 && dleft < resistance_size) {
3457 // if we're already past the left edge, then don't provide
3458 // resistance
3459 if (moving.left() >= winrect.left())
3460 dx = winrect.left();
3461 } else if (dright > 0 && dright < resistance_size) {
3462 // if we're already past the right edge, then don't provide
3463 // resistance
3464 if (moving.right() <= winrect.right())
3465 dx = winrect.right() - frame.rect.width() + 1;
3466 }
3467 } else { // BScreen::WindowSnap
3468 dleft = abs(wleft - winrect.left());
3469 dright = abs(wright - winrect.right());
3470 if (dleft < snap_distance && dleft <= dright)
3471 dx = winrect.left();
3472 else if (dright < snap_distance)
3473 dx = winrect.right() - frame.rect.width() + 1;
3474 }
3475 }
3476
3477 continue;
3478 }
3479 }
3480 }
3481 }
3482
3483 if (snap_to_edges) {
3484 otk::RectList rectlist;
3485
3486 // snap to the screen edges (and screen boundaries for xinerama)
3487 #ifdef XINERAMA
3488 if (screen->isXineramaActive() && blackbox->doXineramaSnapping()) {
3489 rectlist.insert(rectlist.begin(),
3490 screen->getXineramaAreas().begin(),
3491 screen->getXineramaAreas().end());
3492 } else
3493 #endif // XINERAMA
3494 rectlist.push_back(screen->getRect());
3495
3496 otk::RectList::const_iterator it, end = rectlist.end();
3497 for (it = rectlist.begin(); it != end; ++it) {
3498 const otk::Rect &srect = *it;
3499 otk::Rect offsetrect;
3500 offsetrect.setCoords(srect.left() + snap_offset,
3501 srect.top() + snap_offset,
3502 srect.right() - snap_offset,
3503 srect.bottom() - snap_offset);
3504
3505 if (snap_to_edges == BScreen::WindowResistance) {
3506 // if we're not in the rectangle then don't snap to it.
3507 if (! srect.contains(moving))
3508 continue;
3509 } else { // BScreen::WindowSnap
3510 // if we're not in the rectangle then don't snap to it.
3511 if (! srect.intersects(otk::Rect(wleft, wtop, frame.rect.width(),
3512 frame.rect.height())))
3513 continue;
3514 }
3515
3516 if (snap_to_edges == BScreen::WindowResistance) {
3517 int dleft = offsetrect.left() - wleft,
3518 dright = wright - offsetrect.right(),
3519 dtop = offsetrect.top() - wtop,
3520 dbottom = wbottom - offsetrect.bottom();
3521
3522 // snap left?
3523 if (dleft > 0 && dleft < resistance_size)
3524 dx = offsetrect.left();
3525 // snap right?
3526 else if (dright > 0 && dright < resistance_size)
3527 dx = offsetrect.right() - frame.rect.width() + 1;
3528
3529 // snap top?
3530 if (dtop > 0 && dtop < resistance_size)
3531 dy = offsetrect.top();
3532 // snap bottom?
3533 else if (dbottom > 0 && dbottom < resistance_size)
3534 dy = offsetrect.bottom() - frame.rect.height() + 1;
3535 } else { // BScreen::WindowSnap
3536 int dleft = abs(wleft - offsetrect.left()),
3537 dright = abs(wright - offsetrect.right()),
3538 dtop = abs(wtop - offsetrect.top()),
3539 dbottom = abs(wbottom - offsetrect.bottom());
3540
3541 // snap left?
3542 if (dleft < snap_distance && dleft <= dright)
3543 dx = offsetrect.left();
3544 // snap right?
3545 else if (dright < snap_distance)
3546 dx = offsetrect.right() - frame.rect.width() + 1;
3547
3548 // snap top?
3549 if (dtop < snap_distance && dtop <= dbottom)
3550 dy = offsetrect.top();
3551 // snap bottom?
3552 else if (dbottom < snap_distance)
3553 dy = offsetrect.bottom() - frame.rect.height() + 1;
3554 }
3555 }
3556 }
3557 }
3558
3559
3560 void BlackboxWindow::endMove(void) {
3561 assert(flags.moving);
3562 assert(blackbox->getChangingWindow() == this);
3563
3564 flags.moving = False;
3565 blackbox->setChangingWindow(0);
3566
3567 if (! screen->doOpaqueMove()) {
3568 /* when drawing the rubber band, we need to make sure we only draw inside
3569 * the frame... frame.changing_* contain the new coords for the window,
3570 * so we need to subtract 1 from changing_w/changing_h every where we
3571 * draw the rubber band (for both moving and resizing)
3572 */
3573 XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3574 screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3575 frame.changing.width() - 1, frame.changing.height() - 1);
3576 XUngrabServer(otk::OBDisplay::display);
3577
3578 configure(frame.changing.x(), frame.changing.y(),
3579 frame.changing.width(), frame.changing.height());
3580 } else {
3581 configure(frame.rect.x(), frame.rect.y(),
3582 frame.rect.width(), frame.rect.height());
3583 }
3584 screen->hideGeometry();
3585
3586 XUngrabPointer(otk::OBDisplay::display, CurrentTime);
3587
3588 // if there are any left over motions from the move, drop them now
3589 XSync(otk::OBDisplay::display, false); // make sure we don't miss any
3590 XEvent e;
3591 while (XCheckTypedWindowEvent(otk::OBDisplay::display, frame.window,
3592 MotionNotify, &e));
3593 }
3594
3595
3596 void BlackboxWindow::beginResize(int x_root, int y_root, Corner dir) {
3597 if (! (functions & Func_Resize)) return;
3598
3599 assert(! (flags.resizing || flags.moving));
3600
3601 /*
3602 Only one window can be moved/resized at a time. If another window is
3603 already being moved or resized, then stop it before whating to work with
3604 this one.
3605 */
3606 BlackboxWindow *changing = blackbox->getChangingWindow();
3607 if (changing && changing != this) {
3608 if (changing->flags.moving)
3609 changing->endMove();
3610 else // if (changing->flags.resizing)
3611 changing->endResize();
3612 }
3613
3614 resize_dir = dir;
3615
3616 Cursor cursor;
3617 Corner anchor;
3618
3619 switch (resize_dir) {
3620 case BottomLeft:
3621 anchor = TopRight;
3622 cursor = blackbox->getLowerLeftAngleCursor();
3623 break;
3624
3625 case BottomRight:
3626 anchor = TopLeft;
3627 cursor = blackbox->getLowerRightAngleCursor();
3628 break;
3629
3630 case TopLeft:
3631 anchor = BottomRight;
3632 cursor = blackbox->getUpperLeftAngleCursor();
3633 break;
3634
3635 case TopRight:
3636 anchor = BottomLeft;
3637 cursor = blackbox->getUpperRightAngleCursor();
3638 break;
3639
3640 default:
3641 assert(false); // unhandled Corner
3642 return; // unreachable, for the compiler
3643 }
3644
3645 XGrabServer(otk::OBDisplay::display);
3646 XGrabPointer(otk::OBDisplay::display, frame.window, False,
3647 PointerMotionMask | ButtonReleaseMask,
3648 GrabModeAsync, GrabModeAsync, None, cursor, CurrentTime);
3649
3650 flags.resizing = True;
3651 blackbox->setChangingWindow(this);
3652
3653 unsigned int gw, gh;
3654 frame.changing = frame.rect;
3655
3656 constrain(anchor, &gw, &gh);
3657
3658 XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3659 screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3660 frame.changing.width() - 1, frame.changing.height() - 1);
3661
3662 screen->showGeometry(gw, gh);
3663
3664 frame.grab_x = x_root;
3665 frame.grab_y = y_root;
3666 }
3667
3668
3669 void BlackboxWindow::doResize(int x_root, int y_root) {
3670 assert(flags.resizing);
3671 assert(blackbox->getChangingWindow() == this);
3672
3673 XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3674 screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3675 frame.changing.width() - 1, frame.changing.height() - 1);
3676
3677 unsigned int gw, gh;
3678 Corner anchor;
3679 int dx, dy; // the amount of change in the size of the window
3680
3681 switch (resize_dir) {
3682 case BottomLeft:
3683 anchor = TopRight;
3684 dx = - (x_root - frame.grab_x);
3685 dy = + (y_root - frame.grab_y);
3686 break;
3687 case BottomRight:
3688 anchor = TopLeft;
3689 dx = + (x_root - frame.grab_x);
3690 dy = + (y_root - frame.grab_y);
3691 break;
3692 case TopLeft:
3693 anchor = BottomRight;
3694 dx = - (x_root - frame.grab_x);
3695 dy = - (y_root - frame.grab_y);
3696 break;
3697 case TopRight:
3698 anchor = BottomLeft;
3699 dx = + (x_root - frame.grab_x);
3700 dy = - (y_root - frame.grab_y);
3701 break;
3702
3703 default:
3704 assert(false); // unhandled Corner
3705 return; // unreachable, for the compiler
3706 }
3707
3708 // make sure the user cant resize the window smaller than 0, which makes it
3709 // wrap around and become huge
3710 if (dx < -(signed)client.rect.width()) dx = -(signed)client.rect.width();
3711 if (dy < -(signed)client.rect.height()) dy = -(signed)client.rect.height();
3712
3713 frame.changing.setSize(frame.rect.width() + dx, frame.rect.height() + dy);
3714
3715 constrain(anchor, &gw, &gh);
3716
3717 XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3718 screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3719 frame.changing.width() - 1, frame.changing.height() - 1);
3720
3721 screen->showGeometry(gw, gh);
3722 }
3723
3724
3725 void BlackboxWindow::endResize(void) {
3726 assert(flags.resizing);
3727 assert(blackbox->getChangingWindow() == this);
3728
3729 XDrawRectangle(otk::OBDisplay::display, screen->getRootWindow(),
3730 screen->getOpGC(), frame.changing.x(), frame.changing.y(),
3731 frame.changing.width() - 1, frame.changing.height() - 1);
3732 XUngrabServer(otk::OBDisplay::display);
3733
3734 // unset maximized state after resized when fully maximized
3735 if (flags.maximized == 1)
3736 maximize(0);
3737
3738 flags.resizing = False;
3739 blackbox->setChangingWindow(0);
3740
3741 configure(frame.changing.x(), frame.changing.y(),
3742 frame.changing.width(), frame.changing.height());
3743 screen->hideGeometry();
3744
3745 XUngrabPointer(otk::OBDisplay::display, CurrentTime);
3746
3747 // if there are any left over motions from the resize, drop them now
3748 XSync(otk::OBDisplay::display, false); // make sure we don't miss any
3749 XEvent e;
3750 while (XCheckTypedWindowEvent(otk::OBDisplay::display, frame.window,
3751 MotionNotify, &e));
3752 }
3753
3754
3755 void BlackboxWindow::motionNotifyEvent(const XMotionEvent *me) {
3756 #if 0
3757 fprintf(stderr, "BlackboxWindow::motionNotifyEvent() for 0x%lx\n",
3758 client.window);
3759 #endif
3760
3761 if (flags.moving) {
3762 doMove(me->x_root, me->y_root);
3763 } else if (flags.resizing) {
3764 doResize(me->x_root, me->y_root);
3765 } else {
3766 if ((functions & Func_Move) &&
3767 (me->state & Button1Mask) &&
3768 (frame.title == me->window || frame.label == me->window ||
3769 frame.handle == me->window || frame.window == me->window)) {
3770 beginMove(me->x_root, me->y_root);
3771 } else if ((functions & Func_Resize) &&
3772 ((me->state & Button1Mask) &&
3773 (me->window == frame.right_grip ||
3774 me->window == frame.left_grip)) ||
3775 ((me->state & Button3Mask) && (me->state & mod_mask) &&
3776 (frame.title == me->window || frame.label == me->window ||
3777 frame.handle == me->window || frame.window == me->window ||
3778 frame.right_grip == me->window ||
3779 frame.left_grip == me->window))) {
3780 unsigned int zones = screen->getResizeZones();
3781 Corner corner;
3782
3783 if (me->window == frame.left_grip) {
3784 corner = BottomLeft;
3785 } else if (me->window == frame.right_grip || zones == 1) {
3786 corner = BottomRight;
3787 } else {
3788 bool top;
3789 bool left = (me->x_root - frame.rect.x() <=
3790 static_cast<signed>(frame.rect.width() / 2));
3791 if (zones == 2)
3792 top = False;
3793 else // (zones == 4)
3794 top = (me->y_root - frame.rect.y() <=
3795 static_cast<signed>(frame.rect.height() / 2));
3796 corner = (top ? (left ? TopLeft : TopRight) :
3797 (left ? BottomLeft : BottomRight));
3798 }
3799
3800 beginResize(me->x_root, me->y_root, corner);
3801 }
3802 }
3803 }
3804
3805
3806 void BlackboxWindow::enterNotifyEvent(const XCrossingEvent* ce) {
3807 if (! (screen->isSloppyFocus() && isVisible() && isNormal()))
3808 return;
3809
3810 XEvent e;
3811 bool leave = False, inferior = False;
3812
3813 while (XCheckTypedWindowEvent(otk::OBDisplay::display, ce->window,
3814 LeaveNotify, &e)) {
3815 if (e.type == LeaveNotify && e.xcrossing.mode == NotifyNormal) {
3816 leave = True;
3817 inferior = (e.xcrossing.detail == NotifyInferior);
3818 }
3819 }
3820
3821 if (! leave || inferior) {
3822 if (! isFocused()) {
3823 bool success = setInputFocus();
3824 if (success) // if focus succeeded install the colormap
3825 installColormap(True); // XXX: shouldnt we honour no install?
3826
3827 /*
3828 We only auto-raise when the window wasn't focused because otherwise
3829 we run into problems with gtk+ drop-down lists. The window ends up
3830 raising over the list.
3831 */
3832 if (screen->doAutoRaise())
3833 timer->start();
3834 }
3835 }
3836 }
3837
3838
3839 void BlackboxWindow::leaveNotifyEvent(const XCrossingEvent*) {
3840 if (! (screen->isSloppyFocus() && screen->doAutoRaise() && isNormal()))
3841 return;
3842
3843 installColormap(False);
3844
3845 timer->stop();
3846 }
3847
3848
3849 #ifdef SHAPE
3850 void BlackboxWindow::shapeEvent(XShapeEvent *e) {
3851 if (otk::OBDisplay::shape()) {
3852 if (! e->shaped && flags.shaped) {
3853 clearShape();
3854 flags.shaped = False;
3855 } else if (e->shaped) {
3856 configureShape();
3857 flags.shaped = True;
3858 }
3859 }
3860 }
3861 #endif // SHAPE
3862
3863
3864 bool BlackboxWindow::validateClient(void) const {
3865 XSync(otk::OBDisplay::display, False);
3866
3867 XEvent e;
3868 if (XCheckTypedWindowEvent(otk::OBDisplay::display, client.window,
3869 DestroyNotify, &e) ||
3870 XCheckTypedWindowEvent(otk::OBDisplay::display, client.window,
3871 UnmapNotify, &e)) {
3872 XPutBackEvent(otk::OBDisplay::display, &e);
3873
3874 return False;
3875 }
3876
3877 return True;
3878 }
3879
3880
3881 void BlackboxWindow::restore(bool remap) {
3882 XChangeSaveSet(otk::OBDisplay::display, client.window, SetModeDelete);
3883 XSelectInput(otk::OBDisplay::display, client.window, NoEventMask);
3884 XSelectInput(otk::OBDisplay::display, frame.plate, NoEventMask);
3885
3886 // do not leave a shaded window as an icon unless it was an icon
3887 if (flags.shaded && ! flags.iconic)
3888 setState(NormalState);
3889
3890 // erase the netwm stuff that we read when a window maps, so that it
3891 // doesn't persist between mappings.
3892 // (these are the ones read in getNetWMFlags().)
3893 xatom->erase(client.window, otk::OBProperty::net_wm_desktop);
3894 xatom->erase(client.window, otk::OBProperty::net_wm_state);
3895
3896 restoreGravity(client.rect);
3897
3898 XUnmapWindow(otk::OBDisplay::display, frame.window);
3899 XUnmapWindow(otk::OBDisplay::display, client.window);
3900
3901 XSetWindowBorderWidth(otk::OBDisplay::display, client.window, client.old_bw);
3902
3903 XEvent ev;
3904 if (XCheckTypedWindowEvent(otk::OBDisplay::display, client.window,
3905 ReparentNotify, &ev)) {
3906 remap = True;
3907 } else {
3908 // according to the ICCCM - if the client doesn't reparent to
3909 // root, then we have to do it for them
3910 XReparentWindow(otk::OBDisplay::display, client.window,
3911 screen->getRootWindow(),
3912 client.rect.x(), client.rect.y());
3913 }
3914
3915 if (remap) XMapWindow(otk::OBDisplay::display, client.window);
3916 }
3917
3918
3919 // timer for autoraise
3920 void BlackboxWindow::timeout(BlackboxWindow *t) {
3921 t->screen->getWorkspace(t->blackbox_attrib.workspace)->raiseWindow(t);
3922 printf("TIMED OUT YA YAY\n");
3923 }
3924
3925
3926 void BlackboxWindow::changeBlackboxHints(const BlackboxHints *net) {
3927 if ((net->flags & AttribShaded) &&
3928 ((blackbox_attrib.attrib & AttribShaded) !=
3929 (net->attrib & AttribShaded)))
3930 shade();
3931
3932 if (flags.visible && // watch out for requests when we can not be seen
3933 (net->flags & (AttribMaxVert | AttribMaxHoriz)) &&
3934 ((blackbox_attrib.attrib & (AttribMaxVert | AttribMaxHoriz)) !=
3935 (net->attrib & (AttribMaxVert | AttribMaxHoriz)))) {
3936 if (flags.maximized) {
3937 maximize(0);
3938 } else {
3939 int button = 0;
3940
3941 if ((net->flags & AttribMaxHoriz) && (net->flags & AttribMaxVert))
3942 button = ((net->attrib & (AttribMaxHoriz | AttribMaxVert)) ? 1 : 0);
3943 else if (net->flags & AttribMaxVert)
3944 button = ((net->attrib & AttribMaxVert) ? 2 : 0);
3945 else if (net->flags & AttribMaxHoriz)
3946 button = ((net->attrib & AttribMaxHoriz) ? 3 : 0);
3947
3948 maximize(button);
3949 }
3950 }
3951
3952 if ((net->flags & AttribOmnipresent) &&
3953 ((blackbox_attrib.attrib & AttribOmnipresent) !=
3954 (net->attrib & AttribOmnipresent)))
3955 stick();
3956
3957 if ((net->flags & AttribWorkspace) &&
3958 (blackbox_attrib.workspace != net->workspace)) {
3959 screen->reassociateWindow(this, net->workspace, True);
3960
3961 if (screen->getCurrentWorkspaceID() != net->workspace) {
3962 withdraw();
3963 } else {
3964 show();
3965 screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
3966 }
3967 }
3968
3969 if (net->flags & AttribDecoration) {
3970 switch (net->decoration) {
3971 case DecorNone:
3972 enableDecor(False);
3973 break;
3974
3975 default:
3976 case DecorNormal:
3977 case DecorTiny:
3978 case DecorTool:
3979 enableDecor(True);
3980 break;
3981 }
3982 }
3983 }
3984
3985
3986 /*
3987 * Set the sizes of all components of the window frame
3988 * (the window decorations).
3989 * These values are based upon the current style settings and the client
3990 * window's dimensions.
3991 */
3992 void BlackboxWindow::upsize(void) {
3993 frame.bevel_w = screen->getWindowStyle()->getBevelWidth();
3994
3995 if (decorations & Decor_Border) {
3996 frame.border_w = screen->getWindowStyle()->getBorderWidth();
3997 if (! isTransient())
3998 frame.mwm_border_w = screen->getWindowStyle()->getFrameWidth();
3999 else
4000 frame.mwm_border_w = 0;
4001 } else {
4002 frame.mwm_border_w = frame.border_w = 0;
4003 }
4004
4005 if (decorations & Decor_Titlebar) {
4006 // the height of the titlebar is based upon the height of the font being
4007 // used to display the window's title
4008 otk::Style *style = screen->getWindowStyle();
4009 frame.title_h = style->font->height() + (frame.bevel_w * 2) + 2;
4010
4011 frame.label_h = frame.title_h - (frame.bevel_w * 2);
4012 frame.button_w = (frame.label_h - 2);
4013
4014 // set the top frame margin
4015 frame.margin.top = frame.border_w + frame.title_h +
4016 frame.border_w + frame.mwm_border_w;
4017 } else {
4018 frame.title_h = 0;
4019 frame.label_h = 0;
4020 frame.button_w = 0;
4021
4022 // set the top frame margin
4023 frame.margin.top = frame.border_w + frame.mwm_border_w;
4024 }
4025
4026 // set the left/right frame margin
4027 frame.margin.left = frame.margin.right = frame.border_w + frame.mwm_border_w;
4028
4029 if (decorations & Decor_Handle) {
4030 frame.grip_w = frame.button_w * 2;
4031 frame.handle_h = screen->getWindowStyle()->getHandleWidth();
4032
4033 // set the bottom frame margin
4034 frame.margin.bottom = frame.border_w + frame.handle_h +
4035 frame.border_w + frame.mwm_border_w;
4036 } else {
4037 frame.handle_h = 0;
4038 frame.grip_w = 0;
4039
4040 // set the bottom frame margin
4041 frame.margin.bottom = frame.border_w + frame.mwm_border_w;
4042 }
4043
4044 /*
4045 We first get the normal dimensions and use this to define the inside_w/h
4046 then we modify the height if shading is in effect.
4047 If the shade state is not considered then frame.rect gets reset to the
4048 normal window size on a reconfigure() call resulting in improper
4049 dimensions appearing in move/resize and other events.
4050 */
4051 unsigned int
4052 height = client.rect.height() + frame.margin.top + frame.margin.bottom,
4053 width = client.rect.width() + frame.margin.left + frame.margin.right;
4054
4055 frame.inside_w = width - (frame.border_w * 2);
4056 frame.inside_h = height - (frame.border_w * 2);
4057
4058 if (flags.shaded)
4059 height = frame.title_h + (frame.border_w * 2);
4060 frame.rect.setSize(width, height);
4061 }
4062
4063
4064 /*
4065 * Calculate the size of the client window and constrain it to the
4066 * size specified by the size hints of the client window.
4067 *
4068 * The logical width and height are placed into pw and ph, if they
4069 * are non-zero. Logical size refers to the users perception of
4070 * the window size (for example an xterm resizes in cells, not in pixels).
4071 * pw and ph are then used to display the geometry during window moves, resize,
4072 * etc.
4073 *
4074 * The physical geometry is placed into frame.changing_{x,y,width,height}.
4075 * Physical geometry refers to the geometry of the window in pixels.
4076 */
4077 void BlackboxWindow::constrain(Corner anchor,
4078 unsigned int *pw, unsigned int *ph) {
4079 // frame.changing represents the requested frame size, we need to
4080 // strip the frame margin off and constrain the client size
4081 frame.changing.setCoords(frame.changing.left() + frame.margin.left,
4082 frame.changing.top() + frame.margin.top,
4083 frame.changing.right() - frame.margin.right,
4084 frame.changing.bottom() - frame.margin.bottom);
4085
4086 unsigned int dw = frame.changing.width(), dh = frame.changing.height(),
4087 base_width = (client.base_width) ? client.base_width : client.min_width,
4088 base_height = (client.base_height) ? client.base_height :
4089 client.min_height;
4090
4091 // constrain, but only if the min/max are being used. if they aren't, then
4092 // this resize is going to be from a ConfigureRequest because the window
4093 // isn't allowed to be resized by the user. And in that case, we don't want
4094 // to limit what the app can do
4095 if (client.max_width > client.min_width ||
4096 client.max_height > client.min_height) {
4097 if (dw < client.min_width) dw = client.min_width;
4098 if (dh < client.min_height) dh = client.min_height;
4099 if (dw > client.max_width) dw = client.max_width;
4100 if (dh > client.max_height) dh = client.max_height;
4101 }
4102
4103 if (client.width_inc > 1) {
4104 dw -= base_width;
4105 dw /= client.width_inc;
4106 }
4107 if (client.height_inc > 1) {
4108 dh -= base_height;
4109 dh /= client.height_inc;
4110 }
4111
4112 if (pw)
4113 *pw = dw;
4114
4115 if (ph)
4116 *ph = dh;
4117
4118 if (client.width_inc > 1) {
4119 dw *= client.width_inc;
4120 dw += base_width;
4121 }
4122 if (client.height_inc > 1) {
4123 dh *= client.height_inc;
4124 dh += base_height;
4125 }
4126
4127 frame.changing.setSize(dw, dh);
4128
4129 // add the frame margin back onto frame.changing
4130 frame.changing.setCoords(frame.changing.left() - frame.margin.left,
4131 frame.changing.top() - frame.margin.top,
4132 frame.changing.right() + frame.margin.right,
4133 frame.changing.bottom() + frame.margin.bottom);
4134
4135 // move frame.changing to the specified anchor
4136 int dx = 0,
4137 dy = 0;
4138 switch (anchor) {
4139 case TopLeft:
4140 break;
4141
4142 case TopRight:
4143 dx = frame.rect.right() - frame.changing.right();
4144 break;
4145
4146 case BottomLeft:
4147 dy = frame.rect.bottom() - frame.changing.bottom();
4148 break;
4149
4150 case BottomRight:
4151 dx = frame.rect.right() - frame.changing.right();
4152 dy = frame.rect.bottom() - frame.changing.bottom();
4153 break;
4154
4155 default:
4156 assert(false); // unhandled corner
4157 }
4158 frame.changing.setPos(frame.changing.x() + dx, frame.changing.y() + dy);
4159 }
4160
4161
4162 BWindowGroup::BWindowGroup(Blackbox *b, Window _group)
4163 : blackbox(b), group(_group) {
4164 XWindowAttributes wattrib;
4165 if (! XGetWindowAttributes(otk::OBDisplay::display, group, &wattrib)) {
4166 // group window doesn't seem to exist anymore
4167 delete this;
4168 return;
4169 }
4170
4171 XSelectInput(otk::OBDisplay::display, group,
4172 PropertyChangeMask | FocusChangeMask | StructureNotifyMask);
4173
4174 blackbox->saveGroupSearch(group, this);
4175 }
4176
4177
4178 BWindowGroup::~BWindowGroup(void) {
4179 blackbox->removeGroupSearch(group);
4180 }
4181
4182
4183 BlackboxWindow *
4184 BWindowGroup::find(BScreen *screen, bool allow_transients) const {
4185 BlackboxWindow *ret = blackbox->getFocusedWindow();
4186
4187 // does the focus window match (or any transient_fors)?
4188 for (; ret; ret = ret->getTransientFor()) {
4189 if (ret->getScreen() == screen && ret->getGroupWindow() == group &&
4190 (! ret->isTransient() || allow_transients))
4191 break;
4192 }
4193
4194 if (ret) return ret;
4195
4196 // the focus window didn't match, look in the group's window list
4197 BlackboxWindowList::const_iterator it, end = windowList.end();
4198 for (it = windowList.begin(); it != end; ++it) {
4199 ret = *it;
4200 if (ret->getScreen() == screen && ret->getGroupWindow() == group &&
4201 (! ret->isTransient() || allow_transients))
4202 break;
4203 }
4204
4205 return ret;
4206 }
4207
4208 }
This page took 0.225147 seconds and 3 git commands to generate.