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


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