use otk objects in the ob scripts by importing otk
[mikachu/openbox.git] / 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 }