PROPERLY HANDLE CLIENT BORDERS
[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 "bbscreen.hh"
11 #include "openbox.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
19 #include <assert.h>
20
21 #include "gettext.h"
22 #define _(str) gettext(str)
23 }
24
25 namespace ob {
26
27 OBClient::OBClient(int screen, Window window)
28   : otk::OtkEventHandler(),
29     frame(0), _screen(screen), _window(window)
30 {
31   assert(screen >= 0);
32   assert(window);
33
34   ignore_unmaps = 0;
35   
36   // update EVERYTHING the first time!!
37
38   // the state is kinda assumed to be normal. is this right? XXX
39   _wmstate = NormalState;
40   // no default decors or functions, each has to be enabled
41   _decorations = _functions = 0;
42   
43   getArea();
44   getDesktop();
45   getType();
46
47   // set the decorations and functions
48   switch (_type) {
49   case Type_Normal:
50     // normal windows retain all of the possible decorations and
51     // functionality
52     _decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
53                    Decor_Iconify | Decor_Maximize;
54     _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
55
56   case Type_Dialog:
57     // dialogs cannot be maximized
58     _decorations &= ~Decor_Maximize;
59     _functions &= ~Func_Maximize;
60     break;
61
62   case Type_Menu:
63   case Type_Toolbar:
64   case Type_Utility:
65     // these windows get less functionality
66     _decorations &= ~(Decor_Iconify | Decor_Handle);
67     _functions &= ~(Func_Iconify | Func_Resize);
68     break;
69
70   case Type_Desktop:
71   case Type_Dock:
72   case Type_Splash:
73     // none of these windows are manipulated by the window manager
74     _decorations = 0;
75     _functions = 0;
76     break;
77   }
78   
79   getMwmHints(); // this fucks (in good ways) with the decors and functions
80   getState();
81   getShaped();
82
83   updateProtocols();
84   updateNormalHints();
85   updateWMHints();
86   // XXX: updateTransientFor();
87   updateTitle();
88   updateIconTitle();
89   updateClass();
90
91 /*
92 #ifdef DEBUG
93   printf("Mapped window: 0x%lx\n"
94          "  title:         \t%s\t  icon title:    \t%s\n"
95          "  app name:      \t%s\t\t  class:         \t%s\n"
96          "  position:      \t%d, %d\t\t  size:          \t%d, %d\n"
97          "  desktop:       \t%lu\t\t  group:         \t0x%lx\n"
98          "  type:          \t%d\t\t  min size       \t%d, %d\n"
99          "  base size      \t%d, %d\t\t  max size       \t%d, %d\n"
100          "  size incr      \t%d, %d\t\t  gravity        \t%d\n"
101          "  wm state       \t%ld\t\t  can be focused:\t%s\n"
102          "  notify focus:  \t%s\t\t  urgent:        \t%s\n"
103          "  shaped:        \t%s\t\t  modal:         \t%s\n"
104          "  shaded:        \t%s\t\t  iconic:        \t%s\n"
105          "  vert maximized:\t%s\t\t  horz maximized:\t%s\n"
106          "  fullscreen:    \t%s\t\t  floating:      \t%s\n"
107          "  requested pos: \t%s\n",
108          _window,
109          _title.c_str(),
110          _icon_title.c_str(),
111          _app_name.c_str(),
112          _app_class.c_str(),
113          _area.x(), _area.y(),
114          _area.width(), _area.height(),
115          _desktop,
116          _group,
117          _type,
118          _min_x, _min_y,
119          _base_x, _base_y,
120          _max_x, _max_y,
121          _inc_x, _inc_y,
122          _gravity,
123          _wmstate,
124          _can_focus ? "yes" : "no",
125          _focus_notify ? "yes" : "no",
126          _urgent ? "yes" : "no",
127          _shaped ? "yes" : "no",
128          _modal ? "yes" : "no",
129          _shaded ? "yes" : "no",
130          _iconic ? "yes" : "no",
131          _max_vert ? "yes" : "no",
132          _max_horz ? "yes" : "no",
133          _fullscreen ? "yes" : "no",
134          _floating ? "yes" : "no",
135          _positioned ? "yes" : "no");
136 #endif
137 */
138 }
139
140
141 OBClient::~OBClient()
142 {
143   const otk::OBProperty *property = Openbox::instance->property();
144
145   // these values should not be persisted across a window unmapping/mapping
146   property->erase(_window, otk::OBProperty::net_wm_desktop);
147   property->erase(_window, otk::OBProperty::net_wm_state);
148 }
149
150
151 void OBClient::getDesktop()
152 {
153   const otk::OBProperty *property = Openbox::instance->property();
154
155   // defaults to the current desktop
156   _desktop = 0; // XXX: change this to the current desktop!
157
158   property->get(_window, otk::OBProperty::net_wm_desktop,
159                 otk::OBProperty::Atom_Cardinal,
160                 &_desktop);
161 }
162
163
164 void OBClient::getType()
165 {
166   const otk::OBProperty *property = Openbox::instance->property();
167
168   _type = (WindowType) -1;
169   
170   unsigned long *val;
171   unsigned long num = (unsigned) -1;
172   if (property->get(_window, otk::OBProperty::net_wm_window_type,
173                     otk::OBProperty::Atom_Atom,
174                     &num, &val)) {
175     // use the first value that we know about in the array
176     for (unsigned long i = 0; i < num; ++i) {
177       if (val[i] ==
178           property->atom(otk::OBProperty::net_wm_window_type_desktop))
179         _type = Type_Desktop;
180       else if (val[i] ==
181                property->atom(otk::OBProperty::net_wm_window_type_dock))
182         _type = Type_Dock;
183       else if (val[i] ==
184                property->atom(otk::OBProperty::net_wm_window_type_toolbar))
185         _type = Type_Toolbar;
186       else if (val[i] ==
187                property->atom(otk::OBProperty::net_wm_window_type_menu))
188         _type = Type_Menu;
189       else if (val[i] ==
190                property->atom(otk::OBProperty::net_wm_window_type_utility))
191         _type = Type_Utility;
192       else if (val[i] ==
193                property->atom(otk::OBProperty::net_wm_window_type_splash))
194         _type = Type_Splash;
195       else if (val[i] ==
196                property->atom(otk::OBProperty::net_wm_window_type_dialog))
197         _type = Type_Dialog;
198       else if (val[i] ==
199                property->atom(otk::OBProperty::net_wm_window_type_normal))
200         _type = Type_Normal;
201 //      else if (val[i] ==
202 //               property->atom(otk::OBProperty::kde_net_wm_window_type_override))
203 //        mwm_decorations = 0; // prevent this window from getting any decor
204       // XXX: make this work again
205     }
206     delete val;
207   }
208     
209   if (_type == (WindowType) -1) {
210     /*
211      * the window type hint was not set, which means we either classify ourself
212      * as a normal window or a dialog, depending on if we are a transient.
213      */
214     // XXX: make this code work!
215     //if (isTransient())
216     //  _type = Type_Dialog;
217     //else
218       _type = Type_Normal;
219   }
220 }
221
222
223 void OBClient::getMwmHints()
224 {
225   const otk::OBProperty *property = Openbox::instance->property();
226
227   unsigned long num;
228   MwmHints *hints;
229
230   num = MwmHints::elements;
231   if (!property->get(_window, otk::OBProperty::motif_wm_hints,
232                      otk::OBProperty::motif_wm_hints, &num,
233                      (unsigned long **)&hints))
234     return;
235   
236   if (num < MwmHints::elements) {
237     delete [] hints;
238     return;
239   }
240
241   // retrieved the hints
242   // Mwm Hints are applied subtractively to what has already been chosen for
243   // decor and functionality
244
245   if (hints->flags & MwmFlag_Decorations) {
246     if (! (hints->decorations & MwmDecor_All)) {
247       if (! (hints->decorations & MwmDecor_Border))
248         _decorations &= ~Decor_Border;
249       if (! (hints->decorations & MwmDecor_Handle))
250         _decorations &= ~Decor_Handle;
251       if (! (hints->decorations & MwmDecor_Title))
252         _decorations &= ~Decor_Titlebar;
253       if (! (hints->decorations & MwmDecor_Iconify))
254         _decorations &= ~Decor_Iconify;
255       if (! (hints->decorations & MwmDecor_Maximize))
256         _decorations &= ~Decor_Maximize;
257     }
258   }
259
260   if (hints->flags & MwmFlag_Functions) {
261     if (! (hints->functions & MwmFunc_All)) {
262       if (! (hints->functions & MwmFunc_Resize))
263         _functions &= ~Func_Resize;
264       if (! (hints->functions & MwmFunc_Move))
265         _functions &= ~Func_Move;
266       if (! (hints->functions & MwmFunc_Iconify))
267         _functions &= ~Func_Iconify;
268       if (! (hints->functions & MwmFunc_Maximize))
269         _functions &= ~Func_Maximize;
270       //if (! (hints->functions & MwmFunc_Close))
271       //  _functions &= ~Func_Close;
272     }
273   }
274   delete [] hints;
275 }
276
277
278 void OBClient::getArea()
279 {
280   XWindowAttributes wattrib;
281   Status ret;
282   
283   ret = XGetWindowAttributes(otk::OBDisplay::display, _window, &wattrib);
284   assert(ret != BadWindow);
285
286   _area.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
287   _border_width = wattrib.border_width;
288 }
289
290
291 void OBClient::getState()
292 {
293   const otk::OBProperty *property = Openbox::instance->property();
294
295   _modal = _shaded = _max_horz = _max_vert = _fullscreen = _floating = false;
296   
297   unsigned long *state;
298   unsigned long num = (unsigned) -1;
299   
300   if (property->get(_window, otk::OBProperty::net_wm_state,
301                     otk::OBProperty::Atom_Atom, &num, &state)) {
302     for (unsigned long i = 0; i < num; ++i) {
303       if (state[i] == property->atom(otk::OBProperty::net_wm_state_modal))
304         _modal = true;
305       else if (state[i] ==
306                property->atom(otk::OBProperty::net_wm_state_shaded))
307         _shaded = true;
308       else if (state[i] ==
309                property->atom(otk::OBProperty::net_wm_state_fullscreen))
310         _fullscreen = true;
311       else if (state[i] ==
312                property->atom(otk::OBProperty::net_wm_state_maximized_vert))
313         _max_vert = true;
314       else if (state[i] ==
315                property->atom(otk::OBProperty::net_wm_state_maximized_horz))
316         _max_horz = true;
317     }
318
319     delete [] state;
320   }
321 }
322
323
324 void OBClient::getShaped()
325 {
326   _shaped = false;
327 #ifdef   SHAPE
328   if (otk::OBDisplay::shape()) {
329     int foo;
330     unsigned int ufoo;
331     int s;
332
333     XShapeSelectInput(otk::OBDisplay::display, _window, ShapeNotifyMask);
334
335     XShapeQueryExtents(otk::OBDisplay::display, _window, &s, &foo,
336                        &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo);
337     _shaped = (s != 0);
338   }
339 #endif // SHAPE
340 }
341
342
343 void OBClient::updateProtocols()
344 {
345   const otk::OBProperty *property = Openbox::instance->property();
346
347   Atom *proto;
348   int num_return = 0;
349
350   _focus_notify = false;
351   _decorations &= ~Decor_Close;
352   _functions &= ~Func_Close;
353
354   if (XGetWMProtocols(otk::OBDisplay::display, _window, &proto, &num_return)) {
355     for (int i = 0; i < num_return; ++i) {
356       if (proto[i] == property->atom(otk::OBProperty::wm_delete_window)) {
357         _decorations |= Decor_Close;
358         _functions |= Func_Close;
359         // XXX: update the decor?
360       } else if (proto[i] == property->atom(otk::OBProperty::wm_take_focus))
361         // if this protocol is requested, then the window will be notified
362         // by the window manager whenever it receives focus
363         _focus_notify = true;
364     }
365     XFree(proto);
366   }
367 }
368
369
370 void OBClient::updateNormalHints()
371 {
372   XSizeHints size;
373   long ret;
374   int oldgravity = _gravity;
375
376   // defaults
377   _gravity = NorthWestGravity;
378   _size_inc.setPoint(1, 1);
379   _base_size.setPoint(0, 0);
380   _min_size.setPoint(0, 0);
381   _max_size.setPoint(INT_MAX, INT_MAX);
382
383   // XXX: might want to cancel any interactive resizing of the window at this
384   // point..
385
386   // get the hints from the window
387   if (XGetWMNormalHints(otk::OBDisplay::display, _window, &size, &ret)) {
388     _positioned = (size.flags & (PPosition|USPosition));
389
390     if (size.flags & PWinGravity)
391       _gravity = size.win_gravity;
392
393     if (size.flags & PMinSize)
394       _min_size.setPoint(size.min_width, size.min_height);
395     
396     if (size.flags & PMaxSize)
397       _max_size.setPoint(size.max_width, size.max_height);
398     
399     if (size.flags & PBaseSize)
400       _base_size.setPoint(size.base_width, size.base_height);
401     
402     if (size.flags & PResizeInc)
403       _size_inc.setPoint(size.width_inc, size.height_inc);
404   }
405
406   // if the client has a frame, i.e. has already been mapped and is
407   // changing its gravity
408   if (frame && _gravity != oldgravity) {
409     // move our idea of the client's position based on its new gravity
410     int x, y;
411     frame->frameGravity(x, y);
412     _area.setPos(x, y);
413   }
414 }
415
416
417 void OBClient::updateWMHints()
418 {
419   XWMHints *hints;
420
421   // assume a window takes input if it doesnt specify
422   _can_focus = true;
423   _urgent = false;
424   
425   if ((hints = XGetWMHints(otk::OBDisplay::display, _window)) != NULL) {
426     if (hints->flags & InputHint)
427       _can_focus = hints->input;
428
429     if (hints->flags & XUrgencyHint)
430       _urgent = true;
431
432     if (hints->flags & WindowGroupHint) {
433       if (hints->window_group != _group) {
434         // XXX: remove from the old group if there was one
435         _group = hints->window_group;
436         // XXX: do stuff with the group
437       }
438     } else // no group!
439       _group = None;
440
441     XFree(hints);
442   }
443 }
444
445
446 void OBClient::updateTitle()
447 {
448   const otk::OBProperty *property = Openbox::instance->property();
449
450   _title = "";
451   
452   // try netwm
453   if (! property->get(_window, otk::OBProperty::net_wm_name,
454                       otk::OBProperty::utf8, &_title)) {
455     // try old x stuff
456     property->get(_window, otk::OBProperty::wm_name,
457                   otk::OBProperty::ascii, &_title);
458   }
459
460   if (_title.empty())
461     _title = _("Unnamed Window");
462 }
463
464
465 void OBClient::updateIconTitle()
466 {
467   const otk::OBProperty *property = Openbox::instance->property();
468
469   _icon_title = "";
470   
471   // try netwm
472   if (! property->get(_window, otk::OBProperty::net_wm_icon_name,
473                       otk::OBProperty::utf8, &_icon_title)) {
474     // try old x stuff
475     property->get(_window, otk::OBProperty::wm_icon_name,
476                   otk::OBProperty::ascii, &_icon_title);
477   }
478
479   if (_title.empty())
480     _icon_title = _("Unnamed Window");
481 }
482
483
484 void OBClient::updateClass()
485 {
486   const otk::OBProperty *property = Openbox::instance->property();
487
488   // set the defaults
489   _app_name = _app_class = "";
490
491   otk::OBProperty::StringVect v;
492   unsigned long num = 2;
493
494   if (! property->get(_window, otk::OBProperty::wm_class,
495                       otk::OBProperty::ascii, &num, &v))
496     return;
497
498   if (num > 0) _app_name = v[0];
499   if (num > 1) _app_class = v[1];
500 }
501
502
503 void OBClient::propertyHandler(const XPropertyEvent &e)
504 {
505   otk::OtkEventHandler::propertyHandler(e);
506   
507   const otk::OBProperty *property = Openbox::instance->property();
508
509   // compress changes to a single property into a single change
510   XEvent ce;
511   while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
512     // XXX: it would be nice to compress ALL changes to a property, not just
513     //      changes in a row without other props between.
514     if (ce.xproperty.atom != e.atom) {
515       XPutBackEvent(otk::OBDisplay::display, &ce);
516       break;
517     }
518   }
519
520   if (e.atom == XA_WM_NORMAL_HINTS)
521     updateNormalHints();
522   else if (e.atom == XA_WM_HINTS)
523     updateWMHints();
524   else if (e.atom == property->atom(otk::OBProperty::net_wm_name) ||
525            e.atom == property->atom(otk::OBProperty::wm_name))
526     updateTitle();
527   else if (e.atom == property->atom(otk::OBProperty::net_wm_icon_name) ||
528            e.atom == property->atom(otk::OBProperty::wm_icon_name))
529     updateIconTitle();
530   else if (e.atom == property->atom(otk::OBProperty::wm_class))
531     updateClass();
532   else if (e.atom == property->atom(otk::OBProperty::wm_protocols))
533     updateProtocols();
534   // XXX: transient for hint
535   // XXX: strut hint
536 }
537
538
539 void OBClient::setWMState(long state)
540 {
541   if (state == _wmstate) return; // no change
542   
543   switch (state) {
544   case IconicState:
545     // XXX: cause it to iconify
546     break;
547   case NormalState:
548     // XXX: cause it to uniconify
549     break;
550   }
551   _wmstate = state;
552 }
553
554
555 void OBClient::setDesktop(long target)
556 {
557   assert(target >= 0);
558   //assert(target == 0xffffffff || target < MAX);
559   
560   // XXX: move the window to the new desktop
561   _desktop = target;
562 }
563
564
565 void OBClient::setState(StateAction action, long data1, long data2)
566 {
567   const otk::OBProperty *property = Openbox::instance->property();
568
569   if (!(action == State_Add || action == State_Remove ||
570         action == State_Toggle))
571     return; // an invalid action was passed to the client message, ignore it
572
573   for (int i = 0; i < 2; ++i) {
574     Atom state = i == 0 ? data1 : data2;
575     
576     if (! state) continue;
577
578     // if toggling, then pick whether we're adding or removing
579     if (action == State_Toggle) {
580       if (state == property->atom(otk::OBProperty::net_wm_state_modal))
581         action = _modal ? State_Remove : State_Add;
582       else if (state ==
583                property->atom(otk::OBProperty::net_wm_state_maximized_vert))
584         action = _max_vert ? State_Remove : State_Add;
585       else if (state ==
586                property->atom(otk::OBProperty::net_wm_state_maximized_horz))
587         action = _max_horz ? State_Remove : State_Add;
588       else if (state == property->atom(otk::OBProperty::net_wm_state_shaded))
589         action = _shaded ? State_Remove : State_Add;
590       else if (state ==
591                property->atom(otk::OBProperty::net_wm_state_fullscreen))
592         action = _fullscreen ? State_Remove : State_Add;
593       else if (state == property->atom(otk::OBProperty::net_wm_state_floating))
594         action = _floating ? State_Remove : State_Add;
595     }
596     
597     if (action == State_Add) {
598       if (state == property->atom(otk::OBProperty::net_wm_state_modal)) {
599         if (_modal) continue;
600         _modal = true;
601         // XXX: give it focus if another window has focus that shouldnt now
602       } else if (state ==
603                  property->atom(otk::OBProperty::net_wm_state_maximized_vert)){
604         if (_max_vert) continue;
605         _max_vert = true;
606         // XXX: resize the window etc
607       } else if (state ==
608                  property->atom(otk::OBProperty::net_wm_state_maximized_horz)){
609         if (_max_horz) continue;
610         _max_horz = true;
611         // XXX: resize the window etc
612       } else if (state ==
613                  property->atom(otk::OBProperty::net_wm_state_shaded)) {
614         if (_shaded) continue;
615         _shaded = true;
616         // XXX: hide the client window
617       } else if (state ==
618                  property->atom(otk::OBProperty::net_wm_state_fullscreen)) {
619         if (_fullscreen) continue;
620         _fullscreen = true;
621         // XXX: raise the window n shit
622       } else if (state ==
623                  property->atom(otk::OBProperty::net_wm_state_floating)) {
624         if (_floating) continue;
625         _floating = true;
626         // XXX: raise the window n shit
627       }
628
629     } else { // action == State_Remove
630       if (state == property->atom(otk::OBProperty::net_wm_state_modal)) {
631         if (!_modal) continue;
632         _modal = false;
633       } else if (state ==
634                  property->atom(otk::OBProperty::net_wm_state_maximized_vert)){
635         if (!_max_vert) continue;
636         _max_vert = false;
637         // XXX: resize the window etc
638       } else if (state ==
639                  property->atom(otk::OBProperty::net_wm_state_maximized_horz)){
640         if (!_max_horz) continue;
641         _max_horz = false;
642         // XXX: resize the window etc
643       } else if (state ==
644                  property->atom(otk::OBProperty::net_wm_state_shaded)) {
645         if (!_shaded) continue;
646         _shaded = false;
647         // XXX: show the client window
648       } else if (state ==
649                  property->atom(otk::OBProperty::net_wm_state_fullscreen)) {
650         if (!_fullscreen) continue;
651         _fullscreen = false;
652         // XXX: lower the window to its proper layer
653       } else if (state ==
654                  property->atom(otk::OBProperty::net_wm_state_floating)) {
655         if (!_floating) continue;
656         _floating = false;
657         // XXX: lower the window to its proper layer
658       }
659     }
660   }
661 }
662
663
664 void OBClient::toggleClientBorder(bool addborder)
665 {
666   // adjust our idea of where the client is, based on its border. When the
667   // border is removed, the client should now be considered to be in a
668   // different position.
669   // when re-adding the border to the client, the same operation needs to be
670   // reversed.
671   int x = _area.x(), y = _area.y();
672   switch(_gravity) {
673   case NorthWestGravity:
674   case WestGravity:
675   case SouthWestGravity:
676     if (addborder) x += _border_width;
677     else           x -= _border_width;
678     break;
679   case NorthEastGravity:
680   case EastGravity:
681   case SouthEastGravity:
682     if (addborder) x -= _border_width * 2;
683     else           x += _border_width * 2;
684     break;
685   }
686   switch(_gravity) {
687   case NorthWestGravity:
688   case NorthGravity:
689   case NorthEastGravity:
690     if (addborder) y += _border_width;
691     else           y -= _border_width;
692     break;
693   case SouthWestGravity:
694   case SouthGravity:
695   case SouthEastGravity:
696     if (addborder) y -= _border_width * 2;
697     else           y += _border_width * 2;
698     break;
699   default:
700     // no change for StaticGravity etc.
701     break;
702   }
703   _area.setPos(x, y);
704
705   if (addborder) {
706     XSetWindowBorderWidth(otk::OBDisplay::display, _window, _border_width);
707
708     // move the client so it is back it the right spot _with_ its border!
709     XMoveWindow(otk::OBDisplay::display, _window, x, y);
710   } else
711     XSetWindowBorderWidth(otk::OBDisplay::display, _window, 0);
712 }
713
714
715 void OBClient::clientMessageHandler(const XClientMessageEvent &e)
716 {
717   otk::OtkEventHandler::clientMessageHandler(e);
718   
719   if (e.format != 32) return;
720
721   const otk::OBProperty *property = Openbox::instance->property();
722   
723   if (e.message_type == property->atom(otk::OBProperty::wm_change_state)) {
724     // compress changes into a single change
725     bool compress = false;
726     XEvent ce;
727     while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
728       // XXX: it would be nice to compress ALL messages of a type, not just
729       //      messages in a row without other message types between.
730       if (ce.xclient.message_type != e.message_type) {
731         XPutBackEvent(otk::OBDisplay::display, &ce);
732         break;
733       }
734       compress = true;
735     }
736     if (compress)
737       setWMState(ce.xclient.data.l[0]); // use the found event
738     else
739       setWMState(e.data.l[0]); // use the original event
740   } else if (e.message_type ==
741              property->atom(otk::OBProperty::net_wm_desktop)) {
742     // compress changes into a single change 
743     bool compress = false;
744     XEvent ce;
745     while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
746       // XXX: it would be nice to compress ALL messages of a type, not just
747       //      messages in a row without other message types between.
748       if (ce.xclient.message_type != e.message_type) {
749         XPutBackEvent(otk::OBDisplay::display, &ce);
750         break;
751       }
752       compress = true;
753     }
754     if (compress)
755       setDesktop(e.data.l[0]); // use the found event
756     else
757       setDesktop(e.data.l[0]); // use the original event
758   }
759   else if (e.message_type == property->atom(otk::OBProperty::net_wm_state))
760     // can't compress these
761     setState((StateAction)e.data.l[0], e.data.l[1], e.data.l[2]);
762 }
763
764
765 #if defined(SHAPE) || defined(DOXYGEN_IGNORE)
766 void OBClient::shapeHandler(const XShapeEvent &e)
767 {
768   otk::OtkEventHandler::shapeHandler(e);
769   
770   _shaped = e.shaped;
771 }
772 #endif
773
774
775 void OBClient::resize(Corner anchor, int w, int h)
776 {
777   w -= _base_size.x(); 
778   h -= _base_size.y();
779
780   // is the window resizable? if it is not, then don't check its sizes, the
781   // client can do what it wants and the user can't change it anyhow
782   if (_min_size.x() <= _max_size.x() && _min_size.y() <= _max_size.y()) {
783     // smaller than min size or bigger than max size?
784     if (w < _min_size.x()) w = _min_size.x();
785     else if (w > _max_size.x()) w = _max_size.x();
786     if (h < _min_size.y()) h = _min_size.y();
787     else if (h > _max_size.y()) h = _max_size.y();
788   }
789
790   // keep to the increments
791   w /= _size_inc.x();
792   h /= _size_inc.y();
793
794   // store the logical size
795   _logical_size.setPoint(w, h);
796
797   w *= _size_inc.x();
798   h *= _size_inc.y();
799
800   w += _base_size.x();
801   h += _base_size.y();
802
803   int x = _area.x(), y = _area.y();  
804   switch (anchor) {
805   case TopLeft:
806     break;
807   case TopRight:
808     x -= w - _area.width();
809     break;
810   case BottomLeft:
811     y -= h - _area.height();
812     break;
813   case BottomRight:
814     x -= w - _area.width();
815     y -= h - _area.height();
816     break;
817   }
818
819   _area.setSize(w, h);
820   XResizeWindow(otk::OBDisplay::display, _window, w, h);
821
822   // resize the frame to match the request
823   frame->adjustSize();
824   move(x, y);
825 }
826
827
828 void OBClient::move(int x, int y)
829 {
830   _area.setPos(x, y);
831   // move the frame to be in the requested position
832   frame->adjustPosition();
833 }
834
835
836 void OBClient::configureRequestHandler(const XConfigureRequestEvent &e)
837 {
838   OtkEventHandler::configureRequestHandler(e);
839
840   // XXX: if we are iconic (or shaded? (fvwm does that)) ignore the event
841
842   if (e.value_mask & CWBorderWidth)
843     _border_width = e.border_width;
844
845     // resize, then move, as specified in the EWMH section 7.7
846   if (e.value_mask & (CWWidth | CWHeight)) {
847     int w = (e.value_mask & CWWidth) ? e.width : _area.width();
848     int h = (e.value_mask & CWHeight) ? e.height : _area.height();
849
850     Corner corner;
851     switch (_gravity) {
852     case NorthEastGravity:
853     case EastGravity:
854       corner = TopRight;
855       break;
856     case SouthWestGravity:
857     case SouthGravity:
858       corner = BottomLeft;
859       break;
860     case SouthEastGravity:
861       corner = BottomRight;
862       break;
863     default:     // NorthWest, Static, etc
864       corner = TopLeft;
865     }
866
867     resize(corner, w, h);
868   }
869
870   if (e.value_mask & (CWX | CWY)) {
871     int x = (e.value_mask & CWX) ? e.x : _area.x();
872     int y = (e.value_mask & CWY) ? e.y : _area.y();
873     move(x, y);
874   }
875
876   if (e.value_mask & CWStackMode) {
877     switch (e.detail) {
878     case Below:
879     case BottomIf:
880       // XXX: lower the window
881       break;
882
883     case Above:
884     case TopIf:
885     default:
886       // XXX: raise the window
887       break;
888     }
889   }
890 }
891
892
893 void OBClient::unmapHandler(const XUnmapEvent &e)
894 {
895 #ifdef    DEBUG
896   printf("UnmapNotify for 0x%lx\n", e.window);
897 #endif // DEBUG
898
899   if (ignore_unmaps) {
900     ignore_unmaps--;
901     return;
902   }
903   
904   OtkEventHandler::unmapHandler(e);
905
906   // this deletes us etc
907   Openbox::instance->screen(_screen)->unmanageWindow(this);
908 }
909
910
911 void OBClient::destroyHandler(const XDestroyWindowEvent &e)
912 {
913 #ifdef    DEBUG
914   printf("DestroyNotify for 0x%lx\n", e.window);
915 #endif // DEBUG
916
917   OtkEventHandler::destroyHandler(e);
918
919   // this deletes us etc
920   Openbox::instance->screen(_screen)->unmanageWindow(this);
921 }
922
923
924 }