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


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