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