]> Dogcows Code - chaz/openbox/blob - src/client.cc
projects / chaz / openbox / blob
? search:


d25d458ef920a1e391b3bc1caa100c19799ecd2f
[chaz/openbox] / src / client.cc
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2
3 #ifdef HAVE_CONFIG_H
4 # include "../config.h"
5 #endif
6
7 #include "client.hh"
8 #include "frame.hh"
9 #include "screen.hh"
10 #include "openbox.hh"
11 #include "bindings.hh"
12 #include "otk/display.hh"
13 #include "otk/property.hh"
14
15 extern "C" {
16 #include <X11/Xlib.h>
17 #include <X11/Xutil.h>
18 #include <X11/Xatom.h>
19
20 #include <assert.h>
21
22 #include "gettext.h"
23 #define _(str) gettext(str)
24 }
25
26 #include <algorithm>
27
28 namespace ob {
29
30 Client::Client(int screen, Window window)
31 : otk::EventHandler(),
32 WidgetBase(WidgetBase::Type_Client),
33 frame(0), _screen(screen), _window(window)
34 {
35 assert(screen >= 0);
36 assert(window);
37
38 ignore_unmaps = 0;
39
40 // update EVERYTHING the first time!!
41
42 // we default to NormalState, visible
43 _wmstate = NormalState;
44 // start unfocused
45 _focused = false;
46 // not a transient by default of course
47 _transient_for = 0;
48 // pick a layer to start from
49 _layer = Layer_Normal;
50 // default to not urgent
51 _urgent = false;
52 // not positioned unless specified
53 _positioned = false;
54 // nothing is disabled unless specified
55 _disabled_decorations = 0;
56
57 getArea();
58 getDesktop();
59
60 updateTransientFor();
61 getType();
62 getMwmHints();
63
64 getState();
65 getShaped();
66
67 updateProtocols();
68
69 getGravity(); // get the attribute gravity
70 updateNormalHints(); // this may override the attribute gravity
71
72 // got the type, the mwmhints, the protocols, and the normal hints (min/max
73 // sizes), so we're ready to set up
74 // the decorations/functions
75 setupDecorAndFunctions();
76
77 // also get the initial_state and set _iconic if we aren't "starting"
78 // when we're "starting" that means we should use whatever state was already
79 // on the window over the initial map state, because it was already mapped
80 updateWMHints(openbox->state() != Openbox::State_Starting);
81 updateTitle();
82 updateIconTitle();
83 updateClass();
84 updateStrut();
85
86 // this makes sure that these windows appear on all desktops
87 if (/*_type == Type_Dock ||*/ _type == Type_Desktop)
88 _desktop = 0xffffffff;
89
90 // set the desktop hint, to make sure that it always exists, and to reflect
91 // any changes we've made here
92 otk::Property::set(_window, otk::Property::atoms.net_wm_desktop,
93 otk::Property::atoms.cardinal, (unsigned)_desktop);
94
95 changeState();
96 }
97
98
99 Client::~Client()
100 {
101 // clean up childrens' references
102 while (!_transients.empty()) {
103 _transients.front()->_transient_for = 0;
104 _transients.pop_front();
105 }
106
107 // clean up parents reference to this
108 if (_transient_for)
109 _transient_for->_transients.remove(this); // remove from old parent
110
111 if (openbox->state() != Openbox::State_Exiting) {
112 // these values should not be persisted across a window unmapping/mapping
113 otk::Property::erase(_window, otk::Property::atoms.net_wm_desktop);
114 otk::Property::erase(_window, otk::Property::atoms.net_wm_state);
115 } else {
116 // if we're left in an iconic state, the client wont be mapped. this is
117 // bad, since we will no longer be managing the window on restart
118 if (_iconic)
119 XMapWindow(**otk::display, _window);
120 }
121 }
122
123
124 bool Client::validate() const
125 {
126 XSync(**otk::display, false); // get all events on the server
127
128 XEvent e;
129 if (XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &e) ||
130 XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &e)) {
131 XPutBackEvent(**otk::display, &e);
132 return false;
133 }
134
135 return true;
136 }
137
138
139 void Client::getGravity()
140 {
141 XWindowAttributes wattrib;
142 Status ret;
143
144 ret = XGetWindowAttributes(**otk::display, _window, &wattrib);
145 assert(ret != BadWindow);
146 _gravity = wattrib.win_gravity;
147 }
148
149
150 void Client::getDesktop()
151 {
152 // defaults to the current desktop
153 _desktop = openbox->screen(_screen)->desktop();
154
155 if (otk::Property::get(_window, otk::Property::atoms.net_wm_desktop,
156 otk::Property::atoms.cardinal,
157 (long unsigned*)&_desktop)) {
158 #ifdef DEBUG
159 // printf("Window requested desktop: %ld\n", _desktop);
160 #endif
161 }
162 }
163
164
165 void Client::getType()
166 {
167 _type = (WindowType) -1;
168
169 unsigned long *val;
170 unsigned long num = (unsigned) -1;
171 if (otk::Property::get(_window, otk::Property::atoms.net_wm_window_type,
172 otk::Property::atoms.atom, &num, &val)) {
173 // use the first value that we know about in the array
174 for (unsigned long i = 0; i < num; ++i) {
175 if (val[i] == otk::Property::atoms.net_wm_window_type_desktop)
176 _type = Type_Desktop;
177 else if (val[i] == otk::Property::atoms.net_wm_window_type_dock)
178 _type = Type_Dock;
179 else if (val[i] == otk::Property::atoms.net_wm_window_type_toolbar)
180 _type = Type_Toolbar;
181 else if (val[i] == otk::Property::atoms.net_wm_window_type_menu)
182 _type = Type_Menu;
183 else if (val[i] == otk::Property::atoms.net_wm_window_type_utility)
184 _type = Type_Utility;
185 else if (val[i] == otk::Property::atoms.net_wm_window_type_splash)
186 _type = Type_Splash;
187 else if (val[i] == otk::Property::atoms.net_wm_window_type_dialog)
188 _type = Type_Dialog;
189 else if (val[i] == otk::Property::atoms.net_wm_window_type_normal)
190 _type = Type_Normal;
191 // XXX: make this work again
192 // else if (val[i] == otk::Property::atoms.kde_net_wm_window_type_override)
193 // mwm_decorations = 0; // prevent this window from getting any decor
194 if (_type != (WindowType) -1)
195 break; // grab the first known type
196 }
197 delete val;
198 }
199
200 if (_type == (WindowType) -1) {
201 /*
202 * the window type hint was not set, which means we either classify ourself
203 * as a normal window or a dialog, depending on if we are a transient.
204 */
205 if (_transient_for)
206 _type = Type_Dialog;
207 else
208 _type = Type_Normal;
209 }
210 }
211
212
213 void Client::setupDecorAndFunctions()
214 {
215 // start with everything (cept fullscreen)
216 _decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
217 Decor_AllDesktops | Decor_Iconify | Decor_Maximize;
218 _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
219 Func_Shade;
220 if (_delete_window) {
221 _decorations |= Decor_Close;
222 _functions |= Func_Close;
223 }
224
225 if (!(_min_size.x() < _max_size.x() || _min_size.y() < _max_size.y())) {
226 _decorations &= ~(Decor_Maximize | Decor_Handle);
227 _functions &= ~(Func_Resize | Func_Maximize);
228 }
229
230 switch (_type) {
231 case Type_Normal:
232 // normal windows retain all of the possible decorations and
233 // functionality, and are the only windows that you can fullscreen
234 _functions |= Func_Fullscreen;
235
236 case Type_Dialog:
237 // dialogs cannot be maximized
238 _decorations &= ~Decor_Maximize;
239 _functions &= ~Func_Maximize;
240 break;
241
242 case Type_Menu:
243 case Type_Toolbar:
244 case Type_Utility:
245 // these windows get less functionality
246 _decorations &= ~(Decor_Iconify | Decor_Handle);
247 _functions &= ~(Func_Iconify | Func_Resize);
248 break;
249
250 case Type_Desktop:
251 case Type_Dock:
252 case Type_Splash:
253 // none of these windows are manipulated by the window manager
254 _decorations = 0;
255 _functions = 0;
256 break;
257 }
258
259 // Mwm Hints are applied subtractively to what has already been chosen for
260 // decor and functionality
261 if (_mwmhints.flags & MwmFlag_Decorations) {
262 if (! (_mwmhints.decorations & MwmDecor_All)) {
263 if (! (_mwmhints.decorations & MwmDecor_Border))
264 _decorations &= ~Decor_Border;
265 if (! (_mwmhints.decorations & MwmDecor_Handle))
266 _decorations &= ~Decor_Handle;
267 if (! (_mwmhints.decorations & MwmDecor_Title)) {
268 _decorations &= ~Decor_Titlebar;
269 // if we don't have a titlebar, then we cannot shade!
270 _functions &= ~Func_Shade;
271 }
272 if (! (_mwmhints.decorations & MwmDecor_Iconify))
273 _decorations &= ~Decor_Iconify;
274 if (! (_mwmhints.decorations & MwmDecor_Maximize))
275 _decorations &= ~Decor_Maximize;
276 }
277 }
278
279 if (_mwmhints.flags & MwmFlag_Functions) {
280 if (! (_mwmhints.functions & MwmFunc_All)) {
281 if (! (_mwmhints.functions & MwmFunc_Resize))
282 _functions &= ~Func_Resize;
283 if (! (_mwmhints.functions & MwmFunc_Move))
284 _functions &= ~Func_Move;
285 if (! (_mwmhints.functions & MwmFunc_Iconify))
286 _functions &= ~Func_Iconify;
287 if (! (_mwmhints.functions & MwmFunc_Maximize))
288 _functions &= ~Func_Maximize;
289 // dont let mwm hints kill the close button
290 //if (! (_mwmhints.functions & MwmFunc_Close))
291 // _functions &= ~Func_Close;
292 }
293 }
294
295 // finally, user specified disabled decorations are applied to subtract
296 // decorations
297 if (_disabled_decorations & Decor_Titlebar)
298 _decorations &= ~Decor_Titlebar;
299 if (_disabled_decorations & Decor_Handle)
300 _decorations &= ~Decor_Handle;
301 if (_disabled_decorations & Decor_Border)
302 _decorations &= ~Decor_Border;
303 if (_disabled_decorations & Decor_Iconify)
304 _decorations &= ~Decor_Iconify;
305 if (_disabled_decorations & Decor_Maximize)
306 _decorations &= ~Decor_Maximize;
307 if (_disabled_decorations & Decor_AllDesktops)
308 _decorations &= ~Decor_AllDesktops;
309 if (_disabled_decorations & Decor_Close)
310 _decorations &= ~Decor_Close;
311
312 // You can't shade without a titlebar
313 if (!(_decorations & Decor_Titlebar))
314 _functions &= ~Func_Shade;
315
316 changeAllowedActions();
317
318 if (frame) {
319 frame->adjustSize(); // change the decors on the frame
320 frame->adjustPosition(); // with more/less decorations, we may need to be
321 // moved
322 }
323 }
324
325
326 void Client::getMwmHints()
327 {
328 unsigned long num = MwmHints::elements;
329 unsigned long *hints;
330
331 _mwmhints.flags = 0; // default to none
332
333 if (!otk::Property::get(_window, otk::Property::atoms.motif_wm_hints,
334 otk::Property::atoms.motif_wm_hints, &num,
335 (unsigned long **)&hints))
336 return;
337
338 if (num >= MwmHints::elements) {
339 // retrieved the hints
340 _mwmhints.flags = hints[0];
341 _mwmhints.functions = hints[1];
342 _mwmhints.decorations = hints[2];
343 }
344
345 delete [] hints;
346 }
347
348
349 void Client::getArea()
350 {
351 XWindowAttributes wattrib;
352 Status ret;
353
354 ret = XGetWindowAttributes(**otk::display, _window, &wattrib);
355 assert(ret != BadWindow);
356
357 _area.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
358 _border_width = wattrib.border_width;
359 }
360
361
362 void Client::getState()
363 {
364 _modal = _shaded = _max_horz = _max_vert = _fullscreen = _above = _below =
365 _iconic = _skip_taskbar = _skip_pager = false;
366
367 unsigned long *state;
368 unsigned long num = (unsigned) -1;
369
370 if (otk::Property::get(_window, otk::Property::atoms.net_wm_state,
371 otk::Property::atoms.atom, &num, &state)) {
372 for (unsigned long i = 0; i < num; ++i) {
373 if (state[i] == otk::Property::atoms.net_wm_state_modal)
374 _modal = true;
375 else if (state[i] == otk::Property::atoms.net_wm_state_shaded)
376 _shaded = true;
377 else if (state[i] == otk::Property::atoms.net_wm_state_hidden)
378 _iconic = true;
379 else if (state[i] == otk::Property::atoms.net_wm_state_skip_taskbar)
380 _skip_taskbar = true;
381 else if (state[i] == otk::Property::atoms.net_wm_state_skip_pager)
382 _skip_pager = true;
383 else if (state[i] == otk::Property::atoms.net_wm_state_fullscreen)
384 _fullscreen = true;
385 else if (state[i] == otk::Property::atoms.net_wm_state_maximized_vert)
386 _max_vert = true;
387 else if (state[i] == otk::Property::atoms.net_wm_state_maximized_horz)
388 _max_horz = true;
389 else if (state[i] == otk::Property::atoms.net_wm_state_above)
390 _above = true;
391 else if (state[i] == otk::Property::atoms.net_wm_state_below)
392 _below = true;
393 }
394
395 delete [] state;
396 }
397 }
398
399
400 void Client::getShaped()
401 {
402 _shaped = false;
403 #ifdef SHAPE
404 if (otk::display->shape()) {
405 int foo;
406 unsigned int ufoo;
407 int s;
408
409 XShapeSelectInput(**otk::display, _window, ShapeNotifyMask);
410
411 XShapeQueryExtents(**otk::display, _window, &s, &foo,
412 &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo);
413 _shaped = (s != 0);
414 }
415 #endif // SHAPE
416 }
417
418
419 void Client::calcLayer() {
420 StackLayer l;
421
422 if (_iconic) l = Layer_Icon;
423 else if (_fullscreen) l = Layer_Fullscreen;
424 else if (_type == Type_Desktop) l = Layer_Desktop;
425 else if (_type == Type_Dock) {
426 if (!_below) l = Layer_Top;
427 else l = Layer_Normal;
428 }
429 else if (_above) l = Layer_Above;
430 else if (_below) l = Layer_Below;
431 else l = Layer_Normal;
432
433 if (l != _layer) {
434 _layer = l;
435 if (frame) {
436 /*
437 if we don't have a frame, then we aren't mapped yet (and this would
438 SIGSEGV :)
439 */
440 openbox->screen(_screen)->raiseWindow(this);
441 }
442 }
443 }
444
445
446 void Client::updateProtocols()
447 {
448 Atom *proto;
449 int num_return = 0;
450
451 _focus_notify = false;
452 _delete_window = false;
453
454 if (XGetWMProtocols(**otk::display, _window, &proto, &num_return)) {
455 for (int i = 0; i < num_return; ++i) {
456 if (proto[i] == otk::Property::atoms.wm_delete_window) {
457 // this means we can request the window to close
458 _delete_window = true;
459 } else if (proto[i] == otk::Property::atoms.wm_take_focus)
460 // if this protocol is requested, then the window will be notified
461 // by the window manager whenever it receives focus
462 _focus_notify = true;
463 }
464 XFree(proto);
465 }
466 }
467
468
469 void Client::updateNormalHints()
470 {
471 XSizeHints size;
472 long ret;
473 int oldgravity = _gravity;
474
475 // defaults
476 _min_ratio = 0.0;
477 _max_ratio = 0.0;
478 _size_inc.setPoint(1, 1);
479 _base_size.setPoint(0, 0);
480 _min_size.setPoint(0, 0);
481 _max_size.setPoint(INT_MAX, INT_MAX);
482
483 // XXX: might want to cancel any interactive resizing of the window at this
484 // point..
485
486 // get the hints from the window
487 if (XGetWMNormalHints(**otk::display, _window, &size, &ret)) {
488 _positioned = (size.flags & (PPosition|USPosition));
489
490 if (size.flags & PWinGravity) {
491 _gravity = size.win_gravity;
492
493 // if the client has a frame, i.e. has already been mapped and is
494 // changing its gravity
495 if (frame && _gravity != oldgravity) {
496 // move our idea of the client's position based on its new gravity
497 int x, y;
498 frame->frameGravity(x, y);
499 _area.setPos(x, y);
500 }
501 }
502
503 if (size.flags & PAspect) {
504 if (size.min_aspect.y) _min_ratio = size.min_aspect.x/size.min_aspect.y;
505 if (size.max_aspect.y) _max_ratio = size.max_aspect.x/size.max_aspect.y;
506 }
507
508 if (size.flags & PMinSize)
509 _min_size.setPoint(size.min_width, size.min_height);
510
511 if (size.flags & PMaxSize)
512 _max_size.setPoint(size.max_width, size.max_height);
513
514 if (size.flags & PBaseSize)
515 _base_size.setPoint(size.base_width, size.base_height);
516
517 if (size.flags & PResizeInc)
518 _size_inc.setPoint(size.width_inc, size.height_inc);
519 }
520 }
521
522
523 void Client::updateWMHints(bool initstate)
524 {
525 XWMHints *hints;
526
527 // assume a window takes input if it doesnt specify
528 _can_focus = true;
529 bool ur = false;
530
531 if ((hints = XGetWMHints(**otk::display, _window)) != NULL) {
532 if (hints->flags & InputHint)
533 _can_focus = hints->input;
534
535 // only do this when initstate is true!
536 if (initstate && (hints->flags & StateHint))
537 _iconic = hints->initial_state == IconicState;
538
539 if (hints->flags & XUrgencyHint)
540 ur = true;
541
542 if (hints->flags & WindowGroupHint) {
543 if (hints->window_group != _group) {
544 // XXX: remove from the old group if there was one
545 _group = hints->window_group;
546 // XXX: do stuff with the group
547 }
548 } else // no group!
549 _group = None;
550
551 XFree(hints);
552 }
553
554 if (ur != _urgent) {
555 _urgent = ur;
556 #ifdef DEBUG
557 printf("DEBUG: Urgent Hint for 0x%lx: %s\n",
558 (long)_window, _urgent ? "ON" : "OFF");
559 #endif
560 // fire the urgent callback if we're mapped, otherwise, wait until after
561 // we're mapped
562 if (frame)
563 fireUrgent();
564 }
565 }
566
567
568 void Client::updateTitle()
569 {
570 _title = "";
571
572 // try netwm
573 if (!otk::Property::get(_window, otk::Property::atoms.net_wm_name,
574 otk::Property::utf8, &_title)) {
575 // try old x stuff
576 otk::Property::get(_window, otk::Property::atoms.wm_name,
577 otk::Property::ascii, &_title);
578 }
579
580 if (_title.empty())
581 _title = _("Unnamed Window");
582
583 if (frame)
584 frame->setTitle(_title);
585 }
586
587
588 void Client::updateIconTitle()
589 {
590 _icon_title = "";
591
592 // try netwm
593 if (!otk::Property::get(_window, otk::Property::atoms.net_wm_icon_name,
594 otk::Property::utf8, &_icon_title)) {
595 // try old x stuff
596 otk::Property::get(_window, otk::Property::atoms.wm_icon_name,
597 otk::Property::ascii, &_icon_title);
598 }
599
600 if (_title.empty())
601 _icon_title = _("Unnamed Window");
602 }
603
604
605 void Client::updateClass()
606 {
607 // set the defaults
608 _app_name = _app_class = _role = "";
609
610 otk::Property::StringVect v;
611 unsigned long num = 2;
612
613 if (otk::Property::get(_window, otk::Property::atoms.wm_class,
614 otk::Property::ascii, &num, &v)) {
615 if (num > 0) _app_name = v[0].c_str();
616 if (num > 1) _app_class = v[1].c_str();
617 }
618
619 v.clear();
620 num = 1;
621 if (otk::Property::get(_window, otk::Property::atoms.wm_window_role,
622 otk::Property::ascii, &num, &v)) {
623 if (num > 0) _role = v[0].c_str();
624 }
625 }
626
627
628 void Client::updateStrut()
629 {
630 unsigned long num = 4;
631 unsigned long *data;
632 if (!otk::Property::get(_window, otk::Property::atoms.net_wm_strut,
633 otk::Property::atoms.cardinal, &num, &data))
634 return;
635
636 if (num == 4) {
637 _strut.left = data[0];
638 _strut.right = data[1];
639 _strut.top = data[2];
640 _strut.bottom = data[3];
641
642 // updating here is pointless while we're being mapped cuz we're not in
643 // the screen's client list yet
644 if (frame)
645 openbox->screen(_screen)->updateStrut();
646 }
647
648 delete [] data;
649 }
650
651
652 void Client::updateTransientFor()
653 {
654 Window t = 0;
655 Client *c = 0;
656
657 if (XGetTransientForHint(**otk::display, _window, &t) &&
658 t != _window) { // cant be transient to itself!
659 c = openbox->findClient(t);
660 assert(c != this); // if this happens then we need to check for it
661
662 if (!c /*XXX: && _group*/) {
663 // not transient to a client, see if it is transient for a group
664 if (//t == _group->leader() ||
665 t == None ||
666 t == otk::display->screenInfo(_screen)->rootWindow()) {
667 // window is a transient for its group!
668 // XXX: for now this is treated as non-transient.
669 // this needs to be fixed!
670 }
671 }
672 }
673
674 // if anything has changed...
675 if (c != _transient_for) {
676 if (_transient_for)
677 _transient_for->_transients.remove(this); // remove from old parent
678 _transient_for = c;
679 if (_transient_for)
680 _transient_for->_transients.push_back(this); // add to new parent
681
682 // XXX: change decor status?
683 }
684 }
685
686
687 void Client::propertyHandler(const XPropertyEvent &e)
688 {
689 otk::EventHandler::propertyHandler(e);
690
691 // validate cuz we query stuff off the client here
692 if (!validate()) return;
693
694 // compress changes to a single property into a single change
695 XEvent ce;
696 while (XCheckTypedEvent(**otk::display, e.type, &ce)) {
697 // XXX: it would be nice to compress ALL changes to a property, not just
698 // changes in a row without other props between.
699 if (ce.xproperty.atom != e.atom) {
700 XPutBackEvent(**otk::display, &ce);
701 break;
702 }
703 }
704
705 if (e.atom == XA_WM_NORMAL_HINTS) {
706 updateNormalHints();
707 setupDecorAndFunctions(); // normal hints can make a window non-resizable
708 } else if (e.atom == XA_WM_HINTS)
709 updateWMHints();
710 else if (e.atom == XA_WM_TRANSIENT_FOR) {
711 updateTransientFor();
712 getType();
713 calcLayer(); // type may have changed, so update the layer
714 setupDecorAndFunctions();
715 }
716 else if (e.atom == otk::Property::atoms.net_wm_name ||
717 e.atom == otk::Property::atoms.wm_name)
718 updateTitle();
719 else if (e.atom == otk::Property::atoms.net_wm_icon_name ||
720 e.atom == otk::Property::atoms.wm_icon_name)
721 updateIconTitle();
722 else if (e.atom == otk::Property::atoms.wm_class)
723 updateClass();
724 else if (e.atom == otk::Property::atoms.wm_protocols) {
725 updateProtocols();
726 setupDecorAndFunctions();
727 }
728 else if (e.atom == otk::Property::atoms.net_wm_strut)
729 updateStrut();
730 }
731
732
733 void Client::setWMState(long state)
734 {
735 if (state == _wmstate) return; // no change
736
737 switch (state) {
738 case IconicState:
739 setDesktop(ICONIC_DESKTOP);
740 break;
741 case NormalState:
742 setDesktop(openbox->screen(_screen)->desktop());
743 break;
744 }
745 }
746
747
748 void Client::setDesktop(long target)
749 {
750 if (target == _desktop) return;
751
752 printf("Setting desktop %ld\n", target);
753
754 if (!(target >= 0 || target == (signed)0xffffffff ||
755 target == ICONIC_DESKTOP))
756 return;
757
758 _desktop = target;
759
760 // set the desktop hint, but not if we're iconifying
761 if (_desktop != ICONIC_DESKTOP)
762 otk::Property::set(_window, otk::Property::atoms.net_wm_desktop,
763 otk::Property::atoms.cardinal, (unsigned)_desktop);
764
765 // 'move' the window to the new desktop
766 if (_desktop == openbox->screen(_screen)->desktop() ||
767 _desktop == (signed)0xffffffff)
768 frame->show();
769 else
770 frame->hide();
771
772 // Handle Iconic state. Iconic state is maintained by the client being a
773 // member of the ICONIC_DESKTOP, so this is where we make iconifying and
774 // uniconifying happen.
775 bool i = _desktop == ICONIC_DESKTOP;
776 if (i != _iconic) { // has the state changed?
777 _iconic = i;
778 if (_iconic) {
779 _wmstate = IconicState;
780 ignore_unmaps++;
781 // we unmap the client itself so that we can get MapRequest events, and
782 // because the ICCCM tells us to!
783 XUnmapWindow(**otk::display, _window);
784 } else {
785 _wmstate = NormalState;
786 XMapWindow(**otk::display, _window);
787 }
788 changeState();
789 }
790
791 frame->adjustState();
792 }
793
794
795 void Client::setState(StateAction action, long data1, long data2)
796 {
797 bool shadestate = _shaded;
798 bool fsstate = _fullscreen;
799
800 if (!(action == State_Add || action == State_Remove ||
801 action == State_Toggle))
802 return; // an invalid action was passed to the client message, ignore it
803
804 for (int i = 0; i < 2; ++i) {
805 Atom state = i == 0 ? data1 : data2;
806
807 if (! state) continue;
808
809 // if toggling, then pick whether we're adding or removing
810 if (action == State_Toggle) {
811 if (state == otk::Property::atoms.net_wm_state_modal)
812 action = _modal ? State_Remove : State_Add;
813 else if (state == otk::Property::atoms.net_wm_state_maximized_vert)
814 action = _max_vert ? State_Remove : State_Add;
815 else if (state == otk::Property::atoms.net_wm_state_maximized_horz)
816 action = _max_horz ? State_Remove : State_Add;
817 else if (state == otk::Property::atoms.net_wm_state_shaded)
818 action = _shaded ? State_Remove : State_Add;
819 else if (state == otk::Property::atoms.net_wm_state_skip_taskbar)
820 action = _skip_taskbar ? State_Remove : State_Add;
821 else if (state == otk::Property::atoms.net_wm_state_skip_pager)
822 action = _skip_pager ? State_Remove : State_Add;
823 else if (state == otk::Property::atoms.net_wm_state_fullscreen)
824 action = _fullscreen ? State_Remove : State_Add;
825 else if (state == otk::Property::atoms.net_wm_state_above)
826 action = _above ? State_Remove : State_Add;
827 else if (state == otk::Property::atoms.net_wm_state_below)
828 action = _below ? State_Remove : State_Add;
829 }
830
831 if (action == State_Add) {
832 if (state == otk::Property::atoms.net_wm_state_modal) {
833 if (_modal) continue;
834 _modal = true;
835 // XXX: give it focus if another window has focus that shouldnt now
836 } else if (state == otk::Property::atoms.net_wm_state_maximized_vert) {
837 if (_max_vert) continue;
838 _max_vert = true;
839 // XXX: resize the window etc
840 } else if (state == otk::Property::atoms.net_wm_state_maximized_horz) {
841 if (_max_horz) continue;
842 _max_horz = true;
843 // XXX: resize the window etc
844 } else if (state == otk::Property::atoms.net_wm_state_shaded) {
845 shadestate = true;
846 } else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) {
847 _skip_taskbar = true;
848 } else if (state == otk::Property::atoms.net_wm_state_skip_pager) {
849 _skip_pager = true;
850 } else if (state == otk::Property::atoms.net_wm_state_fullscreen) {
851 fsstate = true;
852 } else if (state == otk::Property::atoms.net_wm_state_above) {
853 if (_above) continue;
854 _above = true;
855 } else if (state == otk::Property::atoms.net_wm_state_below) {
856 if (_below) continue;
857 _below = true;
858 }
859
860 } else { // action == State_Remove
861 if (state == otk::Property::atoms.net_wm_state_modal) {
862 if (!_modal) continue;
863 _modal = false;
864 } else if (state == otk::Property::atoms.net_wm_state_maximized_vert) {
865 if (!_max_vert) continue;
866 _max_vert = false;
867 // XXX: resize the window etc
868 } else if (state == otk::Property::atoms.net_wm_state_maximized_horz) {
869 if (!_max_horz) continue;
870 _max_horz = false;
871 // XXX: resize the window etc
872 } else if (state == otk::Property::atoms.net_wm_state_shaded) {
873 shadestate = false;
874 } else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) {
875 _skip_taskbar = false;
876 } else if (state == otk::Property::atoms.net_wm_state_skip_pager) {
877 _skip_pager = false;
878 } else if (state == otk::Property::atoms.net_wm_state_fullscreen) {
879 fsstate = false;
880 } else if (state == otk::Property::atoms.net_wm_state_above) {
881 if (!_above) continue;
882 _above = false;
883 } else if (state == otk::Property::atoms.net_wm_state_below) {
884 if (!_below) continue;
885 _below = false;
886 }
887 }
888 }
889 // change fullscreen state before shading, as it will affect if the window
890 // can shade or not
891 if (fsstate != _fullscreen)
892 fullscreen(fsstate);
893 if (shadestate != _shaded)
894 shade(shadestate);
895 calcLayer();
896 }
897
898
899 void Client::toggleClientBorder(bool addborder)
900 {
901 // adjust our idea of where the client is, based on its border. When the
902 // border is removed, the client should now be considered to be in a
903 // different position.
904 // when re-adding the border to the client, the same operation needs to be
905 // reversed.
906 int oldx = _area.x(), oldy = _area.y();
907 int x = oldx, y = oldy;
908 switch(_gravity) {
909 default:
910 case NorthWestGravity:
911 case WestGravity:
912 case SouthWestGravity:
913 break;
914 case NorthEastGravity:
915 case EastGravity:
916 case SouthEastGravity:
917 if (addborder) x -= _border_width * 2;
918 else x += _border_width * 2;
919 break;
920 case NorthGravity:
921 case SouthGravity:
922 case CenterGravity:
923 case ForgetGravity:
924 case StaticGravity:
925 if (addborder) x -= _border_width;
926 else x += _border_width;
927 break;
928 }
929 switch(_gravity) {
930 default:
931 case NorthWestGravity:
932 case NorthGravity:
933 case NorthEastGravity:
934 break;
935 case SouthWestGravity:
936 case SouthGravity:
937 case SouthEastGravity:
938 if (addborder) y -= _border_width * 2;
939 else y += _border_width * 2;
940 break;
941 case WestGravity:
942 case EastGravity:
943 case CenterGravity:
944 case ForgetGravity:
945 case StaticGravity:
946 if (addborder) y -= _border_width;
947 else y += _border_width;
948 break;
949 }
950 _area.setPos(x, y);
951
952 if (addborder) {
953 XSetWindowBorderWidth(**otk::display, _window, _border_width);
954
955 // move the client so it is back it the right spot _with_ its border!
956 if (x != oldx || y != oldy)
957 XMoveWindow(**otk::display, _window, x, y);
958 } else
959 XSetWindowBorderWidth(**otk::display, _window, 0);
960 }
961
962
963 void Client::clientMessageHandler(const XClientMessageEvent &e)
964 {
965 otk::EventHandler::clientMessageHandler(e);
966
967 // validate cuz we query stuff off the client here
968 if (!validate()) return;
969
970 if (e.format != 32) return;
971
972 if (e.message_type == otk::Property::atoms.wm_change_state) {
973 // compress changes into a single change
974 bool compress = false;
975 XEvent ce;
976 while (XCheckTypedEvent(**otk::display, e.type, &ce)) {
977 // XXX: it would be nice to compress ALL messages of a type, not just
978 // messages in a row without other message types between.
979 if (ce.xclient.message_type != e.message_type) {
980 XPutBackEvent(**otk::display, &ce);
981 break;
982 }
983 compress = true;
984 }
985 if (compress)
986 setWMState(ce.xclient.data.l[0]); // use the found event
987 else
988 setWMState(e.data.l[0]); // use the original event
989 } else if (e.message_type == otk::Property::atoms.net_wm_desktop) {
990 // compress changes into a single change
991 bool compress = false;
992 XEvent ce;
993 while (XCheckTypedEvent(**otk::display, e.type, &ce)) {
994 // XXX: it would be nice to compress ALL messages of a type, not just
995 // messages in a row without other message types between.
996 if (ce.xclient.message_type != e.message_type) {
997 XPutBackEvent(**otk::display, &ce);
998 break;
999 }
1000 compress = true;
1001 }
1002 if (compress)
1003 setDesktop(e.data.l[0]); // use the found event
1004 else
1005 setDesktop(e.data.l[0]); // use the original event
1006 } else if (e.message_type == otk::Property::atoms.net_wm_state) {
1007 // can't compress these
1008 #ifdef DEBUG
1009 printf("net_wm_state %s %ld %ld for 0x%lx\n",
1010 (e.data.l[0] == 0 ? "Remove" : e.data.l[0] == 1 ? "Add" :
1011 e.data.l[0] == 2 ? "Toggle" : "INVALID"),
1012 e.data.l[1], e.data.l[2], _window);
1013 #endif
1014 setState((StateAction)e.data.l[0], e.data.l[1], e.data.l[2]);
1015 } else if (e.message_type == otk::Property::atoms.net_close_window) {
1016 #ifdef DEBUG
1017 printf("net_close_window for 0x%lx\n", _window);
1018 #endif
1019 close();
1020 } else if (e.message_type == otk::Property::atoms.net_active_window) {
1021 #ifdef DEBUG
1022 printf("net_active_window for 0x%lx\n", _window);
1023 #endif
1024 if (_iconic)
1025 setDesktop(openbox->screen(_screen)->desktop());
1026 if (_shaded)
1027 shade(false);
1028 // XXX: deiconify
1029 focus();
1030 openbox->screen(_screen)->raiseWindow(this);
1031 }
1032 }
1033
1034
1035 #if defined(SHAPE)
1036 void Client::shapeHandler(const XShapeEvent &e)
1037 {
1038 otk::EventHandler::shapeHandler(e);
1039
1040 if (e.kind == ShapeBounding) {
1041 _shaped = e.shaped;
1042 frame->adjustShape();
1043 }
1044 }
1045 #endif
1046
1047
1048 void Client::resize(Corner anchor, int w, int h)
1049 {
1050 if (!(_functions & Func_Resize)) return;
1051 internal_resize(anchor, w, h);
1052 }
1053
1054
1055 void Client::internal_resize(Corner anchor, int w, int h, bool user,
1056 int x, int y)
1057 {
1058 w -= _base_size.x();
1059 h -= _base_size.y();
1060
1061 // for interactive resizing. have to move half an increment in each
1062 // direction.
1063 w += _size_inc.x() / 2;
1064 h += _size_inc.y() / 2;
1065
1066 if (user) {
1067 // if this is a user-requested resize, then check against min/max sizes
1068 // and aspect ratios
1069
1070 // smaller than min size or bigger than max size?
1071 if (w < _min_size.x()) w = _min_size.x();
1072 else if (w > _max_size.x()) w = _max_size.x();
1073 if (h < _min_size.y()) h = _min_size.y();
1074 else if (h > _max_size.y()) h = _max_size.y();
1075
1076 // adjust the height ot match the width for the aspect ratios
1077 if (_min_ratio)
1078 if (h * _min_ratio > w) h = static_cast<int>(w / _min_ratio);
1079 if (_max_ratio)
1080 if (h * _max_ratio < w) h = static_cast<int>(w / _max_ratio);
1081 }
1082
1083 // keep to the increments
1084 w /= _size_inc.x();
1085 h /= _size_inc.y();
1086
1087 // you cannot resize to nothing
1088 if (w < 1) w = 1;
1089 if (h < 1) h = 1;
1090
1091 // store the logical size
1092 _logical_size.setPoint(w, h);
1093
1094 w *= _size_inc.x();
1095 h *= _size_inc.y();
1096
1097 w += _base_size.x();
1098 h += _base_size.y();
1099
1100 if (x == INT_MIN || y == INT_MIN) {
1101 x = _area.x();
1102 y = _area.y();
1103 switch (anchor) {
1104 case TopLeft:
1105 break;
1106 case TopRight:
1107 x -= w - _area.width();
1108 break;
1109 case BottomLeft:
1110 y -= h - _area.height();
1111 break;
1112 case BottomRight:
1113 x -= w - _area.width();
1114 y -= h - _area.height();
1115 break;
1116 }
1117 }
1118
1119 _area.setSize(w, h);
1120
1121 XResizeWindow(**otk::display, _window, w, h);
1122
1123 // resize the frame to match the request
1124 frame->adjustSize();
1125 internal_move(x, y);
1126 }
1127
1128
1129 void Client::move(int x, int y)
1130 {
1131 if (!(_functions & Func_Move)) return;
1132 internal_move(x, y);
1133 }
1134
1135
1136 void Client::internal_move(int x, int y)
1137 {
1138 _area.setPos(x, y);
1139
1140 // move the frame to be in the requested position
1141 if (frame) { // this can be called while mapping, before frame exists
1142 frame->adjustPosition();
1143
1144 // send synthetic configure notify (we don't need to if we aren't mapped
1145 // yet)
1146 XEvent event;
1147 event.type = ConfigureNotify;
1148 event.xconfigure.display = **otk::display;
1149 event.xconfigure.event = _window;
1150 event.xconfigure.window = _window;
1151
1152 // root window coords with border in mind
1153 event.xconfigure.x = x - _border_width + frame->size().left;
1154 event.xconfigure.y = y - _border_width + frame->size().top;
1155
1156 event.xconfigure.width = _area.width();
1157 event.xconfigure.height = _area.height();
1158 event.xconfigure.border_width = _border_width;
1159 event.xconfigure.above = frame->plate();
1160 event.xconfigure.override_redirect = False;
1161 XSendEvent(event.xconfigure.display, event.xconfigure.window, False,
1162 StructureNotifyMask, &event);
1163 #if 0//def DEBUG
1164 printf("Sent synthetic ConfigureNotify %d,%d %d,%d to 0x%lx\n",
1165 event.xconfigure.x, event.xconfigure.y, event.xconfigure.width,
1166 event.xconfigure.height, event.xconfigure.window);
1167 #endif
1168 }
1169 }
1170
1171
1172 void Client::close()
1173 {
1174 XEvent ce;
1175
1176 if (!(_functions & Func_Close)) return;
1177
1178 // XXX: itd be cool to do timeouts and shit here for killing the client's
1179 // process off
1180 // like... if the window is around after 5 seconds, then the close button
1181 // turns a nice red, and if this function is called again, the client is
1182 // explicitly killed.
1183
1184 ce.xclient.type = ClientMessage;
1185 ce.xclient.message_type = otk::Property::atoms.wm_protocols;
1186 ce.xclient.display = **otk::display;
1187 ce.xclient.window = _window;
1188 ce.xclient.format = 32;
1189 ce.xclient.data.l[0] = otk::Property::atoms.wm_delete_window;
1190 ce.xclient.data.l[1] = CurrentTime;
1191 ce.xclient.data.l[2] = 0l;
1192 ce.xclient.data.l[3] = 0l;
1193 ce.xclient.data.l[4] = 0l;
1194 XSendEvent(**otk::display, _window, false, NoEventMask, &ce);
1195 }
1196
1197
1198 void Client::changeState()
1199 {
1200 unsigned long state[2];
1201 state[0] = _wmstate;
1202 state[1] = None;
1203 otk::Property::set(_window, otk::Property::atoms.wm_state,
1204 otk::Property::atoms.wm_state, state, 2);
1205
1206 Atom netstate[10];
1207 int num = 0;
1208 if (_modal)
1209 netstate[num++] = otk::Property::atoms.net_wm_state_modal;
1210 if (_shaded)
1211 netstate[num++] = otk::Property::atoms.net_wm_state_shaded;
1212 if (_iconic)
1213 netstate[num++] = otk::Property::atoms.net_wm_state_hidden;
1214 if (_skip_taskbar)
1215 netstate[num++] = otk::Property::atoms.net_wm_state_skip_taskbar;
1216 if (_skip_pager)
1217 netstate[num++] = otk::Property::atoms.net_wm_state_skip_pager;
1218 if (_fullscreen)
1219 netstate[num++] = otk::Property::atoms.net_wm_state_fullscreen;
1220 if (_max_vert)
1221 netstate[num++] = otk::Property::atoms.net_wm_state_maximized_vert;
1222 if (_max_horz)
1223 netstate[num++] = otk::Property::atoms.net_wm_state_maximized_horz;
1224 if (_above)
1225 netstate[num++] = otk::Property::atoms.net_wm_state_above;
1226 if (_below)
1227 netstate[num++] = otk::Property::atoms.net_wm_state_below;
1228 otk::Property::set(_window, otk::Property::atoms.net_wm_state,
1229 otk::Property::atoms.atom, netstate, num);
1230
1231 calcLayer();
1232
1233 if (frame)
1234 frame->adjustState();
1235 }
1236
1237
1238 void Client::changeAllowedActions(void)
1239 {
1240 Atom actions[9];
1241 int num = 0;
1242
1243 actions[num++] = otk::Property::atoms.net_wm_action_change_desktop;
1244
1245 if (_functions & Func_Shade)
1246 actions[num++] = otk::Property::atoms.net_wm_action_shade;
1247 if (_functions & Func_Close)
1248 actions[num++] = otk::Property::atoms.net_wm_action_close;
1249 if (_functions & Func_Move)
1250 actions[num++] = otk::Property::atoms.net_wm_action_move;
1251 if (_functions & Func_Iconify)
1252 actions[num++] = otk::Property::atoms.net_wm_action_minimize;
1253 if (_functions & Func_Resize)
1254 actions[num++] = otk::Property::atoms.net_wm_action_resize;
1255 if (_functions & Func_Fullscreen)
1256 actions[num++] = otk::Property::atoms.net_wm_action_fullscreen;
1257 if (_functions & Func_Maximize) {
1258 actions[num++] = otk::Property::atoms.net_wm_action_maximize_horz;
1259 actions[num++] = otk::Property::atoms.net_wm_action_maximize_vert;
1260 }
1261
1262 otk::Property::set(_window, otk::Property::atoms.net_wm_allowed_actions,
1263 otk::Property::atoms.atom, actions, num);
1264 }
1265
1266
1267 void Client::applyStartupState()
1268 {
1269 // these are in a carefully crafted order..
1270
1271 if (_iconic) {
1272 _iconic = false;
1273 setDesktop(ICONIC_DESKTOP);
1274 }
1275 if (_fullscreen) {
1276 _fullscreen = false;
1277 fullscreen(true);
1278 }
1279 if (_shaded) {
1280 _shaded = false;
1281 shade(true);
1282 }
1283 if (_urgent)
1284 fireUrgent();
1285
1286 if (_max_vert); // XXX: incomplete
1287 if (_max_horz); // XXX: incomplete
1288
1289 if (_skip_taskbar); // nothing to do for this
1290 if (_skip_pager); // nothing to do for this
1291 if (_modal); // nothing to do for this
1292 if (_above); // nothing to do for this
1293 if (_below); // nothing to do for this
1294 }
1295
1296
1297 void Client::fireUrgent()
1298 {
1299 // call the python UrgentWindow callbacks
1300 EventData data(_screen, this, EventAction::UrgentWindow, 0);
1301 openbox->bindings()->fireEvent(&data);
1302 }
1303
1304
1305 void Client::shade(bool shade)
1306 {
1307 if (!(_functions & Func_Shade) || // can't
1308 _shaded == shade) return; // already done
1309
1310 // when we're iconic, don't change the wmstate
1311 if (!_iconic)
1312 _wmstate = shade ? IconicState : NormalState;
1313 _shaded = shade;
1314 changeState();
1315 frame->adjustSize();
1316 }
1317
1318
1319 void Client::fullscreen(bool fs)
1320 {
1321 static FunctionFlags saved_func;
1322 static DecorationFlags saved_decor;
1323 static otk::Rect saved_area;
1324 static otk::Point saved_logical_size;
1325
1326 if (!(_functions & Func_Fullscreen) || // can't
1327 _fullscreen == fs) return; // already done
1328
1329 _fullscreen = fs;
1330 changeState(); // change the state hints on the client
1331
1332 if (fs) {
1333 // save the functions and remove them
1334 saved_func = _functions;
1335 _functions = _functions & (Func_Close | Func_Fullscreen | Func_Iconify);
1336 // save the decorations and remove them
1337 saved_decor = _decorations;
1338 _decorations = 0;
1339 // save the area and adjust it (we don't call internal resize here for
1340 // constraints on the size, etc, we just make it fullscreen).
1341 saved_area = _area;
1342 const otk::ScreenInfo *info = otk::display->screenInfo(_screen);
1343 _area.setRect(0, 0, info->width(), info->height());
1344 saved_logical_size = _logical_size;
1345 _logical_size.setPoint((info->width() - _base_size.x()) / _size_inc.x(),
1346 (info->height() - _base_size.y()) / _size_inc.y());
1347 } else {
1348 _functions = saved_func;
1349 _decorations = saved_decor;
1350 _area = saved_area;
1351 _logical_size = saved_logical_size;
1352 }
1353
1354 changeAllowedActions(); // based on the new _functions
1355
1356 frame->adjustSize(); // drop/replace the decor's and resize
1357 frame->adjustPosition(); // get (back) in position!
1358
1359 // raise (back) into our stacking layer
1360 openbox->screen(_screen)->raiseWindow(this);
1361
1362 // try focus us when we go into fullscreen mode
1363 if (fs) focus();
1364 }
1365
1366
1367 void Client::disableDecorations(DecorationFlags flags)
1368 {
1369 _disabled_decorations = flags;
1370 setupDecorAndFunctions();
1371 }
1372
1373
1374 bool Client::focus()
1375 {
1376 // won't try focus if the client doesn't want it, or if the window isn't
1377 // visible on the screen
1378 if (!(frame->isVisible() && (_can_focus || _focus_notify))) return false;
1379
1380 if (_focused) return true;
1381
1382 // do a check to see if the window has already been unmapped or destroyed
1383 // do this intelligently while watching out for unmaps we've generated
1384 // (ignore_unmaps > 0)
1385 XEvent ev;
1386 if (XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &ev)) {
1387 XPutBackEvent(**otk::display, &ev);
1388 return false;
1389 }
1390 while (XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &ev)) {
1391 if (ignore_unmaps) {
1392 unmapHandler(ev.xunmap);
1393 } else {
1394 XPutBackEvent(**otk::display, &ev);
1395 return false;
1396 }
1397 }
1398
1399 if (_can_focus)
1400 XSetInputFocus(**otk::display, _window,
1401 RevertToNone, CurrentTime);
1402
1403 if (_focus_notify) {
1404 XEvent ce;
1405 ce.xclient.type = ClientMessage;
1406 ce.xclient.message_type = otk::Property::atoms.wm_protocols;
1407 ce.xclient.display = **otk::display;
1408 ce.xclient.window = _window;
1409 ce.xclient.format = 32;
1410 ce.xclient.data.l[0] = otk::Property::atoms.wm_take_focus;
1411 ce.xclient.data.l[1] = openbox->lastTime();
1412 ce.xclient.data.l[2] = 0l;
1413 ce.xclient.data.l[3] = 0l;
1414 ce.xclient.data.l[4] = 0l;
1415 XSendEvent(**otk::display, _window, False, NoEventMask, &ce);
1416 }
1417
1418 XSync(**otk::display, False);
1419 return true;
1420 }
1421
1422
1423 void Client::unfocus() const
1424 {
1425 if (!_focused) return;
1426
1427 assert(openbox->focusedClient() == this);
1428 openbox->setFocusedClient(0);
1429 }
1430
1431
1432 void Client::focusHandler(const XFocusChangeEvent &e)
1433 {
1434 #ifdef DEBUG
1435 // printf("FocusIn for 0x%lx\n", e.window);
1436 #endif // DEBUG
1437
1438 otk::EventHandler::focusHandler(e);
1439
1440 frame->focus();
1441 _focused = true;
1442
1443 openbox->setFocusedClient(this);
1444 }
1445
1446
1447 void Client::unfocusHandler(const XFocusChangeEvent &e)
1448 {
1449 #ifdef DEBUG
1450 // printf("FocusOut for 0x%lx\n", e.window);
1451 #endif // DEBUG
1452
1453 otk::EventHandler::unfocusHandler(e);
1454
1455 frame->unfocus();
1456 _focused = false;
1457
1458 if (openbox->focusedClient() == this)
1459 openbox->setFocusedClient(0);
1460 }
1461
1462
1463 void Client::configureRequestHandler(const XConfigureRequestEvent &e)
1464 {
1465 #ifdef DEBUG
1466 printf("ConfigureRequest for 0x%lx\n", e.window);
1467 #endif // DEBUG
1468
1469 otk::EventHandler::configureRequestHandler(e);
1470
1471 // if we are iconic (or shaded (fvwm does this)) ignore the event
1472 if (_iconic || _shaded) return;
1473
1474 if (e.value_mask & CWBorderWidth)
1475 _border_width = e.border_width;
1476
1477 // resize, then move, as specified in the EWMH section 7.7
1478 if (e.value_mask & (CWWidth | CWHeight)) {
1479 int w = (e.value_mask & CWWidth) ? e.width : _area.width();
1480 int h = (e.value_mask & CWHeight) ? e.height : _area.height();
1481
1482 Corner corner;
1483 switch (_gravity) {
1484 case NorthEastGravity:
1485 case EastGravity:
1486 corner = TopRight;
1487 break;
1488 case SouthWestGravity:
1489 case SouthGravity:
1490 corner = BottomLeft;
1491 break;
1492 case SouthEastGravity:
1493 corner = BottomRight;
1494 break;
1495 default: // NorthWest, Static, etc
1496 corner = TopLeft;
1497 }
1498
1499 // if moving AND resizing ...
1500 if (e.value_mask & (CWX | CWY)) {
1501 int x = (e.value_mask & CWX) ? e.x : _area.x();
1502 int y = (e.value_mask & CWY) ? e.y : _area.y();
1503 internal_resize(corner, w, h, false, x, y);
1504 } else // if JUST resizing...
1505 internal_resize(corner, w, h, false);
1506 } else if (e.value_mask & (CWX | CWY)) { // if JUST moving...
1507 int x = (e.value_mask & CWX) ? e.x : _area.x();
1508 int y = (e.value_mask & CWY) ? e.y : _area.y();
1509 internal_move(x, y);
1510 }
1511
1512 if (e.value_mask & CWStackMode) {
1513 switch (e.detail) {
1514 case Below:
1515 case BottomIf:
1516 openbox->screen(_screen)->lowerWindow(this);
1517 break;
1518
1519 case Above:
1520 case TopIf:
1521 default:
1522 openbox->screen(_screen)->raiseWindow(this);
1523 break;
1524 }
1525 }
1526 }
1527
1528
1529 void Client::unmapHandler(const XUnmapEvent &e)
1530 {
1531 if (ignore_unmaps) {
1532 #ifdef DEBUG
1533 // printf("Ignored UnmapNotify for 0x%lx (event 0x%lx)\n", e.window, e.event);
1534 #endif // DEBUG
1535 ignore_unmaps--;
1536 return;
1537 }
1538
1539 #ifdef DEBUG
1540 printf("UnmapNotify for 0x%lx\n", e.window);
1541 #endif // DEBUG
1542
1543 otk::EventHandler::unmapHandler(e);
1544
1545 // this deletes us etc
1546 openbox->screen(_screen)->unmanageWindow(this);
1547 }
1548
1549
1550 void Client::destroyHandler(const XDestroyWindowEvent &e)
1551 {
1552 #ifdef DEBUG
1553 printf("DestroyNotify for 0x%lx\n", e.window);
1554 #endif // DEBUG
1555
1556 otk::EventHandler::destroyHandler(e);
1557
1558 // this deletes us etc
1559 openbox->screen(_screen)->unmanageWindow(this);
1560 }
1561
1562
1563 void Client::reparentHandler(const XReparentEvent &e)
1564 {
1565 // this is when the client is first taken captive in the frame
1566 if (e.parent == frame->plate()) return;
1567
1568 #ifdef DEBUG
1569 printf("ReparentNotify for 0x%lx\n", e.window);
1570 #endif // DEBUG
1571
1572 otk::EventHandler::reparentHandler(e);
1573
1574 /*
1575 This event is quite rare and is usually handled in unmapHandler.
1576 However, if the window is unmapped when the reparent event occurs,
1577 the window manager never sees it because an unmap event is not sent
1578 to an already unmapped window.
1579 */
1580
1581 // we don't want the reparent event, put it back on the stack for the X
1582 // server to deal with after we unmanage the window
1583 XEvent ev;
1584 ev.xreparent = e;
1585 XPutBackEvent(**otk::display, &ev);
1586
1587 // this deletes us etc
1588 openbox->screen(_screen)->unmanageWindow(this);
1589 }
1590
1591 void Client::mapRequestHandler(const XMapRequestEvent &e)
1592 {
1593 #ifdef DEBUG
1594 printf("MapRequest for already managed 0x%lx\n", e.window);
1595 #endif // DEBUG
1596
1597 assert(_iconic); // we shouldn't be able to get this unless we're iconic
1598
1599 // move to the current desktop (uniconify)
1600 setDesktop(openbox->screen(_screen)->desktop());
1601 // XXX: should we focus/raise the window? (basically a net_wm_active_window)
1602 }
1603
1604 }
my patches for the openbox window manager
This page took 0.106685 seconds and 4 git commands to generate.