X-Git-Url: https://git.brokenzipper.com/gitweb?a=blobdiff_plain;f=src%2Fclient.cc;h=cdef1f94667b6f9c597783a97947e756965327f6;hb=ef02a0c8ae65f169157c90064a335303e964a4c1;hp=95d1509562d114b6a7861d10807a7973ac10e31c;hpb=b02c91caad1ef6ddaebe8d58a410a089d47f1f59;p=chaz%2Fopenbox

diff --git a/src/client.cc b/src/client.cc
index 95d15095..cdef1f94 100644
--- a/src/client.cc
+++ b/src/client.cc
@@ -23,9 +23,9 @@ extern "C" {
 
 namespace ob {
 
-OBClient::OBClient(int screen, Window window)
-  : otk::OtkEventHandler(),
-    OBWidget(OBWidget::Type_Client),
+Client::Client(int screen, Window window)
+  : otk::EventHandler(),
+    WidgetBase(WidgetBase::Type_Client),
     frame(0), _screen(screen), _window(window)
 {
   assert(screen >= 0);
@@ -41,45 +41,20 @@ OBClient::OBClient(int screen, Window window)
   _decorations = _functions = 0;
   // start unfocused
   _focused = false;
+  // not a transient by default of course
+  _transient_for = 0;
+  // pick a layer to start from
+  _layer = Layer_Normal;
   
   getArea();
   getDesktop();
-  // XXX: updateTransientFor();
-  getType();
 
-  // set the decorations and functions
-  switch (_type) {
-  case Type_Normal:
-    // normal windows retain all of the possible decorations and
-    // functionality
-    _decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
-                   Decor_Iconify | Decor_Maximize;
-    _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
-
-  case Type_Dialog:
-    // dialogs cannot be maximized
-    _decorations &= ~Decor_Maximize;
-    _functions &= ~Func_Maximize;
-    break;
-
-  case Type_Menu:
-  case Type_Toolbar:
-  case Type_Utility:
-    // these windows get less functionality
-    _decorations &= ~(Decor_Iconify | Decor_Handle);
-    _functions &= ~(Func_Iconify | Func_Resize);
-    break;
+  updateTransientFor();
+  getType();
+  getMwmHints();
 
-  case Type_Desktop:
-  case Type_Dock:
-  case Type_Splash:
-    // none of these windows are manipulated by the window manager
-    _decorations = 0;
-    _functions = 0;
-    break;
-  }
+  setupDecorAndFunctions();
   
-  getMwmHints(); // this fucks (in good ways) with the decors and functions
   getState();
   getShaped();
 
@@ -89,78 +64,96 @@ OBClient::OBClient(int screen, Window window)
   updateTitle();
   updateIconTitle();
   updateClass();
+  updateStrut();
 
-  calcLayer();
   changeState();
 }
 
 
-OBClient::~OBClient()
+Client::~Client()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
+  // clean up childrens' references
+  while (!_transients.empty()) {
+    _transients.front()->_transient_for = 0;
+    _transients.pop_front();
+  }
+  
+  // clean up parents reference to this
+  if (_transient_for)
+    _transient_for->_transients.remove(this); // remove from old parent
+  
   if (Openbox::instance->state() != Openbox::State_Exiting) {
     // these values should not be persisted across a window unmapping/mapping
-    property->erase(_window, otk::OBProperty::net_wm_desktop);
-    property->erase(_window, otk::OBProperty::net_wm_state);
+    property->erase(_window, otk::Property::net_wm_desktop);
+    property->erase(_window, otk::Property::net_wm_state);
   }
 }
 
 
-void OBClient::getDesktop()
+void Client::getDesktop()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   // defaults to the current desktop
-  _desktop = 0; // XXX: change this to the current desktop!
-
-  property->get(_window, otk::OBProperty::net_wm_desktop,
-                otk::OBProperty::Atom_Cardinal,
-                &_desktop);
+  _desktop = Openbox::instance->screen(_screen)->desktop();
+
+  if (!property->get(_window, otk::Property::net_wm_desktop,
+                     otk::Property::Atom_Cardinal,
+                     (long unsigned*)&_desktop)) {
+    // make sure the hint exists
+    Openbox::instance->property()->set(_window,
+                                       otk::Property::net_wm_desktop,
+                                       otk::Property::Atom_Cardinal,
+                                       (unsigned)_desktop);
+  }
 }
 
 
-void OBClient::getType()
+void Client::getType()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   _type = (WindowType) -1;
   
   unsigned long *val;
   unsigned long num = (unsigned) -1;
-  if (property->get(_window, otk::OBProperty::net_wm_window_type,
-                    otk::OBProperty::Atom_Atom,
+  if (property->get(_window, otk::Property::net_wm_window_type,
+                    otk::Property::Atom_Atom,
                     &num, &val)) {
     // use the first value that we know about in the array
     for (unsigned long i = 0; i < num; ++i) {
       if (val[i] ==
-          property->atom(otk::OBProperty::net_wm_window_type_desktop))
+          property->atom(otk::Property::net_wm_window_type_desktop))
         _type = Type_Desktop;
       else if (val[i] ==
-               property->atom(otk::OBProperty::net_wm_window_type_dock))
+               property->atom(otk::Property::net_wm_window_type_dock))
         _type = Type_Dock;
       else if (val[i] ==
-               property->atom(otk::OBProperty::net_wm_window_type_toolbar))
+               property->atom(otk::Property::net_wm_window_type_toolbar))
         _type = Type_Toolbar;
       else if (val[i] ==
-               property->atom(otk::OBProperty::net_wm_window_type_menu))
+               property->atom(otk::Property::net_wm_window_type_menu))
         _type = Type_Menu;
       else if (val[i] ==
-               property->atom(otk::OBProperty::net_wm_window_type_utility))
+               property->atom(otk::Property::net_wm_window_type_utility))
         _type = Type_Utility;
       else if (val[i] ==
-               property->atom(otk::OBProperty::net_wm_window_type_splash))
+               property->atom(otk::Property::net_wm_window_type_splash))
         _type = Type_Splash;
       else if (val[i] ==
-               property->atom(otk::OBProperty::net_wm_window_type_dialog))
+               property->atom(otk::Property::net_wm_window_type_dialog))
         _type = Type_Dialog;
       else if (val[i] ==
-               property->atom(otk::OBProperty::net_wm_window_type_normal))
+               property->atom(otk::Property::net_wm_window_type_normal))
         _type = Type_Normal;
 //      else if (val[i] ==
-//               property->atom(otk::OBProperty::kde_net_wm_window_type_override))
+//               property->atom(otk::Property::kde_net_wm_window_type_override))
 //        mwm_decorations = 0; // prevent this window from getting any decor
       // XXX: make this work again
+      if (_type != (WindowType) -1)
+        break; // grab the first known type
     }
     delete val;
   }
@@ -170,76 +163,117 @@ void OBClient::getType()
      * the window type hint was not set, which means we either classify ourself
      * as a normal window or a dialog, depending on if we are a transient.
      */
-    // XXX: make this code work!
-    //if (isTransient())
-    //  _type = Type_Dialog;
-    //else
+    if (_transient_for)
+      _type = Type_Dialog;
+    else
       _type = Type_Normal;
   }
 }
 
 
-void OBClient::getMwmHints()
+void Client::setupDecorAndFunctions()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  // start with everything
+  _decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
+    Decor_Iconify | Decor_Maximize;
+  _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
+  
+  switch (_type) {
+  case Type_Normal:
+    // normal windows retain all of the possible decorations and
+    // functionality
 
-  unsigned long num;
-  MwmHints *hints;
+  case Type_Dialog:
+    // dialogs cannot be maximized
+    _decorations &= ~Decor_Maximize;
+    _functions &= ~Func_Maximize;
+    break;
 
-  num = MwmHints::elements;
-  if (!property->get(_window, otk::OBProperty::motif_wm_hints,
-                     otk::OBProperty::motif_wm_hints, &num,
-                     (unsigned long **)&hints))
-    return;
-  
-  if (num < MwmHints::elements) {
-    delete [] hints;
-    return;
+  case Type_Menu:
+  case Type_Toolbar:
+  case Type_Utility:
+    // these windows get less functionality
+    _decorations &= ~(Decor_Iconify | Decor_Handle);
+    _functions &= ~(Func_Iconify | Func_Resize);
+    break;
+
+  case Type_Desktop:
+  case Type_Dock:
+  case Type_Splash:
+    // none of these windows are manipulated by the window manager
+    _decorations = 0;
+    _functions = 0;
+    break;
   }
 
-  // retrieved the hints
   // Mwm Hints are applied subtractively to what has already been chosen for
   // decor and functionality
-
-  if (hints->flags & MwmFlag_Decorations) {
-    if (! (hints->decorations & MwmDecor_All)) {
-      if (! (hints->decorations & MwmDecor_Border))
+  if (_mwmhints.flags & MwmFlag_Decorations) {
+    if (! (_mwmhints.decorations & MwmDecor_All)) {
+      if (! (_mwmhints.decorations & MwmDecor_Border))
         _decorations &= ~Decor_Border;
-      if (! (hints->decorations & MwmDecor_Handle))
+      if (! (_mwmhints.decorations & MwmDecor_Handle))
         _decorations &= ~Decor_Handle;
-      if (! (hints->decorations & MwmDecor_Title))
+      if (! (_mwmhints.decorations & MwmDecor_Title))
         _decorations &= ~Decor_Titlebar;
-      if (! (hints->decorations & MwmDecor_Iconify))
+      if (! (_mwmhints.decorations & MwmDecor_Iconify))
         _decorations &= ~Decor_Iconify;
-      if (! (hints->decorations & MwmDecor_Maximize))
+      if (! (_mwmhints.decorations & MwmDecor_Maximize))
         _decorations &= ~Decor_Maximize;
     }
   }
 
-  if (hints->flags & MwmFlag_Functions) {
-    if (! (hints->functions & MwmFunc_All)) {
-      if (! (hints->functions & MwmFunc_Resize))
+  if (_mwmhints.flags & MwmFlag_Functions) {
+    if (! (_mwmhints.functions & MwmFunc_All)) {
+      if (! (_mwmhints.functions & MwmFunc_Resize))
         _functions &= ~Func_Resize;
-      if (! (hints->functions & MwmFunc_Move))
+      if (! (_mwmhints.functions & MwmFunc_Move))
         _functions &= ~Func_Move;
-      if (! (hints->functions & MwmFunc_Iconify))
+      if (! (_mwmhints.functions & MwmFunc_Iconify))
         _functions &= ~Func_Iconify;
-      if (! (hints->functions & MwmFunc_Maximize))
+      if (! (_mwmhints.functions & MwmFunc_Maximize))
         _functions &= ~Func_Maximize;
-      //if (! (hints->functions & MwmFunc_Close))
+      // dont let mwm hints kill the close button
+      //if (! (_mwmhints.functions & MwmFunc_Close))
       //  _functions &= ~Func_Close;
     }
   }
+
+  // XXX: changeAllowedActions();
+}
+
+
+void Client::getMwmHints()
+{
+  const otk::Property *property = Openbox::instance->property();
+
+  unsigned long num = MwmHints::elements;
+  unsigned long *hints;
+
+  _mwmhints.flags = 0; // default to none
+  
+  if (!property->get(_window, otk::Property::motif_wm_hints,
+                     otk::Property::motif_wm_hints, &num,
+                     (unsigned long **)&hints))
+    return;
+  
+  if (num >= MwmHints::elements) {
+    // retrieved the hints
+    _mwmhints.flags = hints[0];
+    _mwmhints.functions = hints[1];
+    _mwmhints.decorations = hints[2];
+  }
+
   delete [] hints;
 }
 
 
-void OBClient::getArea()
+void Client::getArea()
 {
   XWindowAttributes wattrib;
   Status ret;
   
-  ret = XGetWindowAttributes(otk::OBDisplay::display, _window, &wattrib);
+  ret = XGetWindowAttributes(otk::Display::display, _window, &wattrib);
   assert(ret != BadWindow);
 
   _area.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
@@ -247,9 +281,9 @@ void OBClient::getArea()
 }
 
 
-void OBClient::getState()
+void Client::getState()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   _modal = _shaded = _max_horz = _max_vert = _fullscreen = _above = _below =
     _skip_taskbar = _skip_pager = false;
@@ -257,34 +291,35 @@ void OBClient::getState()
   unsigned long *state;
   unsigned long num = (unsigned) -1;
   
-  if (property->get(_window, otk::OBProperty::net_wm_state,
-                    otk::OBProperty::Atom_Atom, &num, &state)) {
+  if (property->get(_window, otk::Property::net_wm_state,
+                    otk::Property::Atom_Atom, &num, &state)) {
     for (unsigned long i = 0; i < num; ++i) {
-      if (state[i] == property->atom(otk::OBProperty::net_wm_state_modal))
+      if (state[i] == property->atom(otk::Property::net_wm_state_modal))
         _modal = true;
       else if (state[i] ==
-               property->atom(otk::OBProperty::net_wm_state_shaded))
+               property->atom(otk::Property::net_wm_state_shaded)) {
         _shaded = true;
-      else if (state[i] ==
-               property->atom(otk::OBProperty::net_wm_state_skip_taskbar))
+        _wmstate = IconicState;
+      } else if (state[i] ==
+               property->atom(otk::Property::net_wm_state_skip_taskbar))
         _skip_taskbar = true;
       else if (state[i] ==
-               property->atom(otk::OBProperty::net_wm_state_skip_pager))
+               property->atom(otk::Property::net_wm_state_skip_pager))
         _skip_pager = true;
       else if (state[i] ==
-               property->atom(otk::OBProperty::net_wm_state_fullscreen))
+               property->atom(otk::Property::net_wm_state_fullscreen))
         _fullscreen = true;
       else if (state[i] ==
-               property->atom(otk::OBProperty::net_wm_state_maximized_vert))
+               property->atom(otk::Property::net_wm_state_maximized_vert))
         _max_vert = true;
       else if (state[i] ==
-               property->atom(otk::OBProperty::net_wm_state_maximized_horz))
+               property->atom(otk::Property::net_wm_state_maximized_horz))
         _max_horz = true;
       else if (state[i] ==
-               property->atom(otk::OBProperty::net_wm_state_above))
+               property->atom(otk::Property::net_wm_state_above))
         _above = true;
       else if (state[i] ==
-               property->atom(otk::OBProperty::net_wm_state_below))
+               property->atom(otk::Property::net_wm_state_below))
         _below = true;
     }
 
@@ -293,18 +328,18 @@ void OBClient::getState()
 }
 
 
-void OBClient::getShaped()
+void Client::getShaped()
 {
   _shaped = false;
 #ifdef   SHAPE
-  if (otk::OBDisplay::shape()) {
+  if (otk::Display::shape()) {
     int foo;
     unsigned int ufoo;
     int s;
 
-    XShapeSelectInput(otk::OBDisplay::display, _window, ShapeNotifyMask);
+    XShapeSelectInput(otk::Display::display, _window, ShapeNotifyMask);
 
-    XShapeQueryExtents(otk::OBDisplay::display, _window, &s, &foo,
+    XShapeQueryExtents(otk::Display::display, _window, &s, &foo,
                        &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo);
     _shaped = (s != 0);
   }
@@ -312,20 +347,36 @@ void OBClient::getShaped()
 }
 
 
-void OBClient::calcLayer() {
-  if (_iconic) _layer = OBScreen::Layer_Icon;
-  else if (_type == Type_Desktop) _layer = OBScreen::Layer_Desktop;
-  else if (_type == Type_Dock) _layer = OBScreen::Layer_Top;
-  else if (_fullscreen) _layer = OBScreen::Layer_Fullscreen;
-  else if (_above) _layer = OBScreen::Layer_Above;
-  else if (_below) _layer = OBScreen::Layer_Below;
-  else _layer = OBScreen::Layer_Normal;
+void Client::calcLayer() {
+  StackLayer l;
+
+  if (_iconic) l = Layer_Icon;
+  else if (_fullscreen) l = Layer_Fullscreen;
+  else if (_type == Type_Desktop) l = Layer_Desktop;
+  else if (_type == Type_Dock) {
+    if (!_below) l = Layer_Top;
+    else l = Layer_Normal;
+  }
+  else if (_above) l = Layer_Above;
+  else if (_below) l = Layer_Below;
+  else l = Layer_Normal;
+
+  if (l != _layer) {
+    _layer = l;
+    if (frame) {
+      /*
+        if we don't have a frame, then we aren't mapped yet (and this would
+        SIGSEGV :)
+      */
+      Openbox::instance->screen(_screen)->restack(true, this); // raise
+    }
+  }
 }
 
 
-void OBClient::updateProtocols()
+void Client::updateProtocols()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   Atom *proto;
   int num_return = 0;
@@ -334,14 +385,14 @@ void OBClient::updateProtocols()
   _decorations &= ~Decor_Close;
   _functions &= ~Func_Close;
 
-  if (XGetWMProtocols(otk::OBDisplay::display, _window, &proto, &num_return)) {
+  if (XGetWMProtocols(otk::Display::display, _window, &proto, &num_return)) {
     for (int i = 0; i < num_return; ++i) {
-      if (proto[i] == property->atom(otk::OBProperty::wm_delete_window)) {
+      if (proto[i] == property->atom(otk::Property::wm_delete_window)) {
         _decorations |= Decor_Close;
         _functions |= Func_Close;
         if (frame)
           frame->adjustSize(); // update the decorations
-      } else if (proto[i] == property->atom(otk::OBProperty::wm_take_focus))
+      } else if (proto[i] == property->atom(otk::Property::wm_take_focus))
         // if this protocol is requested, then the window will be notified
         // by the window manager whenever it receives focus
         _focus_notify = true;
@@ -351,7 +402,7 @@ void OBClient::updateProtocols()
 }
 
 
-void OBClient::updateNormalHints()
+void Client::updateNormalHints()
 {
   XSizeHints size;
   long ret;
@@ -368,7 +419,7 @@ void OBClient::updateNormalHints()
   // point..
 
   // get the hints from the window
-  if (XGetWMNormalHints(otk::OBDisplay::display, _window, &size, &ret)) {
+  if (XGetWMNormalHints(otk::Display::display, _window, &size, &ret)) {
     _positioned = (size.flags & (PPosition|USPosition));
 
     if (size.flags & PWinGravity)
@@ -398,7 +449,7 @@ void OBClient::updateNormalHints()
 }
 
 
-void OBClient::updateWMHints()
+void Client::updateWMHints()
 {
   XWMHints *hints;
 
@@ -406,7 +457,7 @@ void OBClient::updateWMHints()
   _can_focus = true;
   _urgent = false;
   
-  if ((hints = XGetWMHints(otk::OBDisplay::display, _window)) != NULL) {
+  if ((hints = XGetWMHints(otk::Display::display, _window)) != NULL) {
     if (hints->flags & InputHint)
       _can_focus = hints->input;
 
@@ -427,18 +478,18 @@ void OBClient::updateWMHints()
 }
 
 
-void OBClient::updateTitle()
+void Client::updateTitle()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   _title = "";
   
   // try netwm
-  if (! property->get(_window, otk::OBProperty::net_wm_name,
-                      otk::OBProperty::utf8, &_title)) {
+  if (! property->get(_window, otk::Property::net_wm_name,
+                      otk::Property::utf8, &_title)) {
     // try old x stuff
-    property->get(_window, otk::OBProperty::wm_name,
-                  otk::OBProperty::ascii, &_title);
+    property->get(_window, otk::Property::wm_name,
+                  otk::Property::ascii, &_title);
   }
 
   if (_title.empty())
@@ -449,18 +500,18 @@ void OBClient::updateTitle()
 }
 
 
-void OBClient::updateIconTitle()
+void Client::updateIconTitle()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   _icon_title = "";
   
   // try netwm
-  if (! property->get(_window, otk::OBProperty::net_wm_icon_name,
-                      otk::OBProperty::utf8, &_icon_title)) {
+  if (! property->get(_window, otk::Property::net_wm_icon_name,
+                      otk::Property::utf8, &_icon_title)) {
     // try old x stuff
-    property->get(_window, otk::OBProperty::wm_icon_name,
-                  otk::OBProperty::ascii, &_icon_title);
+    property->get(_window, otk::Property::wm_icon_name,
+                  otk::Property::ascii, &_icon_title);
   }
 
   if (_title.empty())
@@ -468,38 +519,102 @@ void OBClient::updateIconTitle()
 }
 
 
-void OBClient::updateClass()
+void Client::updateClass()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   // set the defaults
-  _app_name = _app_class = "";
+  _app_name = _app_class = _role = "";
 
-  otk::OBProperty::StringVect v;
+  otk::Property::StringVect v;
   unsigned long num = 2;
 
-  if (! property->get(_window, otk::OBProperty::wm_class,
-                      otk::OBProperty::ascii, &num, &v))
+  if (property->get(_window, otk::Property::wm_class,
+                    otk::Property::ascii, &num, &v)) {
+    if (num > 0) _app_name = v[0].c_str();
+    if (num > 1) _app_class = v[1].c_str();
+  }
+
+  v.clear();
+  num = 1;
+  if (property->get(_window, otk::Property::wm_window_role,
+                    otk::Property::ascii, &num, &v)) {
+    if (num > 0) _role = v[0].c_str();
+  }
+}
+
+
+void Client::updateStrut()
+{
+  unsigned long num = 4;
+  unsigned long *data;
+  if (!Openbox::instance->property()->get(_window,
+                                          otk::Property::net_wm_strut,
+                                          otk::Property::Atom_Cardinal,
+                                          &num, &data))
     return;
 
-  if (num > 0) _app_name = v[0];
-  if (num > 1) _app_class = v[1];
+  if (num == 4) {
+    _strut.left = data[0];
+    _strut.right = data[1];
+    _strut.top = data[2];
+    _strut.bottom = data[3];
+    
+    Openbox::instance->screen(_screen)->updateStrut();
+  }
+
+  delete [] data;
 }
 
 
-void OBClient::propertyHandler(const XPropertyEvent &e)
+void Client::updateTransientFor()
 {
-  otk::OtkEventHandler::propertyHandler(e);
+  Window t = 0;
+  Client *c = 0;
+
+  if (XGetTransientForHint(otk::Display::display, _window, &t) &&
+      t != _window) { // cant be transient to itself!
+    c = Openbox::instance->findClient(t);
+    assert(c != this); // if this happens then we need to check for it
+
+    if (!c /*XXX: && _group*/) {
+      // not transient to a client, see if it is transient for a group
+      if (//t == _group->leader() ||
+        t == None ||
+        t == otk::Display::screenInfo(_screen)->rootWindow()) {
+        // window is a transient for its group!
+        // XXX: for now this is treated as non-transient.
+        //      this needs to be fixed!
+      }
+    }
+  }
+
+  // if anything has changed...
+  if (c != _transient_for) {
+    if (_transient_for)
+      _transient_for->_transients.remove(this); // remove from old parent
+    _transient_for = c;
+    if (_transient_for)
+      _transient_for->_transients.push_back(this); // add to new parent
+
+    // XXX: change decor status?
+  }
+}
+
+
+void Client::propertyHandler(const XPropertyEvent &e)
+{
+  otk::EventHandler::propertyHandler(e);
   
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   // compress changes to a single property into a single change
   XEvent ce;
-  while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
+  while (XCheckTypedEvent(otk::Display::display, e.type, &ce)) {
     // XXX: it would be nice to compress ALL changes to a property, not just
     //      changes in a row without other props between.
     if (ce.xproperty.atom != e.atom) {
-      XPutBackEvent(otk::OBDisplay::display, &ce);
+      XPutBackEvent(otk::Display::display, &ce);
       break;
     }
   }
@@ -508,26 +623,34 @@ void OBClient::propertyHandler(const XPropertyEvent &e)
     updateNormalHints();
   else if (e.atom == XA_WM_HINTS)
     updateWMHints();
-  else if (e.atom == property->atom(otk::OBProperty::net_wm_name) ||
-           e.atom == property->atom(otk::OBProperty::wm_name))
+  else if (e.atom == XA_WM_TRANSIENT_FOR) {
+    updateTransientFor();
+    getType();
+    calcLayer(); // type may have changed, so update the layer
+    setupDecorAndFunctions();
+    frame->adjustSize(); // this updates the frame for any new decor settings
+  }
+  else if (e.atom == property->atom(otk::Property::net_wm_name) ||
+           e.atom == property->atom(otk::Property::wm_name))
     updateTitle();
-  else if (e.atom == property->atom(otk::OBProperty::net_wm_icon_name) ||
-           e.atom == property->atom(otk::OBProperty::wm_icon_name))
+  else if (e.atom == property->atom(otk::Property::net_wm_icon_name) ||
+           e.atom == property->atom(otk::Property::wm_icon_name))
     updateIconTitle();
-  else if (e.atom == property->atom(otk::OBProperty::wm_class))
+  else if (e.atom == property->atom(otk::Property::wm_class))
     updateClass();
-  else if (e.atom == property->atom(otk::OBProperty::wm_protocols))
+  else if (e.atom == property->atom(otk::Property::wm_protocols))
     updateProtocols();
-  // XXX: transient for hint
-  // XXX: strut hint
+  else if (e.atom == property->atom(otk::Property::net_wm_strut))
+    updateStrut();
 }
 
 
-void OBClient::setWMState(long state)
+void Client::setWMState(long state)
 {
   if (state == _wmstate) return; // no change
   
-  switch (state) {
+  _wmstate = state;
+  switch (_wmstate) {
   case IconicState:
     // XXX: cause it to iconify
     break;
@@ -535,25 +658,37 @@ void OBClient::setWMState(long state)
     // XXX: cause it to uniconify
     break;
   }
-  _wmstate = state;
 }
 
 
-void OBClient::setDesktop(long target)
+void Client::setDesktop(long target)
 {
+  if (target == _desktop) return;
+  
   printf("Setting desktop %ld\n", target);
-  assert(target >= 0 || target == (signed)0xffffffff);
-  //assert(target == 0xffffffff || target < MAX);
 
-  // XXX: move the window to the new desktop (and set root property)
+  if (!(target >= 0 || target == (signed)0xffffffff)) return;
+  
   _desktop = target;
+
+  Openbox::instance->property()->set(_window,
+                                     otk::Property::net_wm_desktop,
+                                     otk::Property::Atom_Cardinal,
+                                     (unsigned)_desktop);
+  
+  // 'move' the window to the new desktop
+  if (_desktop == Openbox::instance->screen(_screen)->desktop() ||
+      _desktop == (signed)0xffffffff)
+    frame->show();
+  else
+    frame->hide();
 }
 
 
-void OBClient::setState(StateAction action, long data1, long data2)
+void Client::setState(StateAction action, long data1, long data2)
 {
-  const otk::OBProperty *property = Openbox::instance->property();
-  bool restack = false, shadestate = _shaded;
+  const otk::Property *property = Openbox::instance->property();
+  bool shadestate = _shaded;
 
   if (!(action == State_Add || action == State_Remove ||
         action == State_Toggle))
@@ -566,127 +701,118 @@ void OBClient::setState(StateAction action, long data1, long data2)
 
     // if toggling, then pick whether we're adding or removing
     if (action == State_Toggle) {
-      if (state == property->atom(otk::OBProperty::net_wm_state_modal))
+      if (state == property->atom(otk::Property::net_wm_state_modal))
         action = _modal ? State_Remove : State_Add;
       else if (state ==
-               property->atom(otk::OBProperty::net_wm_state_maximized_vert))
+               property->atom(otk::Property::net_wm_state_maximized_vert))
         action = _max_vert ? State_Remove : State_Add;
       else if (state ==
-               property->atom(otk::OBProperty::net_wm_state_maximized_horz))
+               property->atom(otk::Property::net_wm_state_maximized_horz))
         action = _max_horz ? State_Remove : State_Add;
-      else if (state == property->atom(otk::OBProperty::net_wm_state_shaded))
+      else if (state == property->atom(otk::Property::net_wm_state_shaded))
         action = _shaded ? State_Remove : State_Add;
       else if (state ==
-               property->atom(otk::OBProperty::net_wm_state_skip_taskbar))
+               property->atom(otk::Property::net_wm_state_skip_taskbar))
         action = _skip_taskbar ? State_Remove : State_Add;
       else if (state ==
-               property->atom(otk::OBProperty::net_wm_state_skip_pager))
+               property->atom(otk::Property::net_wm_state_skip_pager))
         action = _skip_pager ? State_Remove : State_Add;
       else if (state ==
-               property->atom(otk::OBProperty::net_wm_state_fullscreen))
+               property->atom(otk::Property::net_wm_state_fullscreen))
         action = _fullscreen ? State_Remove : State_Add;
-      else if (state == property->atom(otk::OBProperty::net_wm_state_above))
+      else if (state == property->atom(otk::Property::net_wm_state_above))
         action = _above ? State_Remove : State_Add;
-      else if (state == property->atom(otk::OBProperty::net_wm_state_below))
+      else if (state == property->atom(otk::Property::net_wm_state_below))
         action = _below ? State_Remove : State_Add;
     }
     
     if (action == State_Add) {
-      if (state == property->atom(otk::OBProperty::net_wm_state_modal)) {
+      if (state == property->atom(otk::Property::net_wm_state_modal)) {
         if (_modal) continue;
         _modal = true;
         // XXX: give it focus if another window has focus that shouldnt now
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_maximized_vert)){
+                 property->atom(otk::Property::net_wm_state_maximized_vert)){
         if (_max_vert) continue;
         _max_vert = true;
         // XXX: resize the window etc
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_maximized_horz)){
+                 property->atom(otk::Property::net_wm_state_maximized_horz)){
         if (_max_horz) continue;
         _max_horz = true;
         // XXX: resize the window etc
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_shaded)) {
+                 property->atom(otk::Property::net_wm_state_shaded)) {
         if (_shaded) continue;
         // shade when we're all thru here
         shadestate = true;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_skip_taskbar)) {
+                 property->atom(otk::Property::net_wm_state_skip_taskbar)) {
         _skip_taskbar = true;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_skip_pager)) {
+                 property->atom(otk::Property::net_wm_state_skip_pager)) {
         _skip_pager = true;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_fullscreen)) {
+                 property->atom(otk::Property::net_wm_state_fullscreen)) {
         if (_fullscreen) continue;
         _fullscreen = true;
-        restack = false;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_above)) {
+                 property->atom(otk::Property::net_wm_state_above)) {
         if (_above) continue;
         _above = true;
-        restack = true;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_below)) {
+                 property->atom(otk::Property::net_wm_state_below)) {
         if (_below) continue;
         _below = true;
-        restack = true;
       }
 
     } else { // action == State_Remove
-      if (state == property->atom(otk::OBProperty::net_wm_state_modal)) {
+      if (state == property->atom(otk::Property::net_wm_state_modal)) {
         if (!_modal) continue;
         _modal = false;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_maximized_vert)){
+                 property->atom(otk::Property::net_wm_state_maximized_vert)){
         if (!_max_vert) continue;
         _max_vert = false;
         // XXX: resize the window etc
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_maximized_horz)){
+                 property->atom(otk::Property::net_wm_state_maximized_horz)){
         if (!_max_horz) continue;
         _max_horz = false;
         // XXX: resize the window etc
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_shaded)) {
+                 property->atom(otk::Property::net_wm_state_shaded)) {
         if (!_shaded) continue;
         // unshade when we're all thru here
         shadestate = false;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_skip_taskbar)) {
+                 property->atom(otk::Property::net_wm_state_skip_taskbar)) {
         _skip_taskbar = false;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_skip_pager)) {
+                 property->atom(otk::Property::net_wm_state_skip_pager)) {
         _skip_pager = false;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_fullscreen)) {
+                 property->atom(otk::Property::net_wm_state_fullscreen)) {
         if (!_fullscreen) continue;
         _fullscreen = false;
-        restack = true;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_above)) {
+                 property->atom(otk::Property::net_wm_state_above)) {
         if (!_above) continue;
         _above = false;
-        restack = true;
       } else if (state ==
-                 property->atom(otk::OBProperty::net_wm_state_below)) {
+                 property->atom(otk::Property::net_wm_state_below)) {
         if (!_below) continue;
         _below = false;
-        restack = true;
       }
     }
   }
   if (shadestate != _shaded)
     shade(shadestate);
-  if (restack) {
-    calcLayer();
-    Openbox::instance->screen(_screen)->restack(true, this); // raise
-  }
+  calcLayer();
 }
 
 
-void OBClient::toggleClientBorder(bool addborder)
+void Client::toggleClientBorder(bool addborder)
 {
   // adjust our idea of where the client is, based on its border. When the
   // border is removed, the client should now be considered to be in a
@@ -724,32 +850,32 @@ void OBClient::toggleClientBorder(bool addborder)
   _area.setPos(x, y);
 
   if (addborder) {
-    XSetWindowBorderWidth(otk::OBDisplay::display, _window, _border_width);
+    XSetWindowBorderWidth(otk::Display::display, _window, _border_width);
 
     // move the client so it is back it the right spot _with_ its border!
-    XMoveWindow(otk::OBDisplay::display, _window, x, y);
+    XMoveWindow(otk::Display::display, _window, x, y);
   } else
-    XSetWindowBorderWidth(otk::OBDisplay::display, _window, 0);
+    XSetWindowBorderWidth(otk::Display::display, _window, 0);
 }
 
 
-void OBClient::clientMessageHandler(const XClientMessageEvent &e)
+void Client::clientMessageHandler(const XClientMessageEvent &e)
 {
-  otk::OtkEventHandler::clientMessageHandler(e);
+  otk::EventHandler::clientMessageHandler(e);
   
   if (e.format != 32) return;
 
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
   
-  if (e.message_type == property->atom(otk::OBProperty::wm_change_state)) {
+  if (e.message_type == property->atom(otk::Property::wm_change_state)) {
     // compress changes into a single change
     bool compress = false;
     XEvent ce;
-    while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
+    while (XCheckTypedEvent(otk::Display::display, e.type, &ce)) {
       // XXX: it would be nice to compress ALL messages of a type, not just
       //      messages in a row without other message types between.
       if (ce.xclient.message_type != e.message_type) {
-        XPutBackEvent(otk::OBDisplay::display, &ce);
+        XPutBackEvent(otk::Display::display, &ce);
         break;
       }
       compress = true;
@@ -759,15 +885,15 @@ void OBClient::clientMessageHandler(const XClientMessageEvent &e)
     else
       setWMState(e.data.l[0]); // use the original event
   } else if (e.message_type ==
-             property->atom(otk::OBProperty::net_wm_desktop)) {
+             property->atom(otk::Property::net_wm_desktop)) {
     // compress changes into a single change 
     bool compress = false;
     XEvent ce;
-    while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
+    while (XCheckTypedEvent(otk::Display::display, e.type, &ce)) {
       // XXX: it would be nice to compress ALL messages of a type, not just
       //      messages in a row without other message types between.
       if (ce.xclient.message_type != e.message_type) {
-        XPutBackEvent(otk::OBDisplay::display, &ce);
+        XPutBackEvent(otk::Display::display, &ce);
         break;
       }
       compress = true;
@@ -776,33 +902,49 @@ void OBClient::clientMessageHandler(const XClientMessageEvent &e)
       setDesktop(e.data.l[0]); // use the found event
     else
       setDesktop(e.data.l[0]); // use the original event
-  } else if (e.message_type == property->atom(otk::OBProperty::net_wm_state)) {
+  } else if (e.message_type == property->atom(otk::Property::net_wm_state)) {
     // can't compress these
+#ifdef DEBUG
+    printf("net_wm_state %s %ld %ld for 0x%lx\n",
+           (e.data.l[0] == 0 ? "Remove" : e.data.l[0] == 1 ? "Add" :
+            e.data.l[0] == 2 ? "Toggle" : "INVALID"),
+           e.data.l[1], e.data.l[2], _window);
+#endif
     setState((StateAction)e.data.l[0], e.data.l[1], e.data.l[2]);
   } else if (e.message_type ==
-             property->atom(otk::OBProperty::net_close_window)) {
+             property->atom(otk::Property::net_close_window)) {
+#ifdef DEBUG
+    printf("net_close_window for 0x%lx\n", _window);
+#endif
     close();
   } else if (e.message_type ==
-             property->atom(otk::OBProperty::net_active_window)) {
+             property->atom(otk::Property::net_active_window)) {
+#ifdef DEBUG
+    printf("net_active_window for 0x%lx\n", _window);
+#endif
+    if (_shaded)
+      shade(false);
+    // XXX: deiconify
     focus();
     Openbox::instance->screen(_screen)->restack(true, this); // raise
-  } else {
   }
 }
 
 
 #if defined(SHAPE)
-void OBClient::shapeHandler(const XShapeEvent &e)
+void Client::shapeHandler(const XShapeEvent &e)
 {
-  otk::OtkEventHandler::shapeHandler(e);
-  
-  _shaped = e.shaped;
-  frame->adjustShape();
+  otk::EventHandler::shapeHandler(e);
+
+  if (e.kind == ShapeBounding) {
+    _shaped = e.shaped;
+    frame->adjustShape();
+  }
 }
 #endif
 
 
-void OBClient::resize(Corner anchor, int w, int h, int x, int y)
+void Client::resize(Corner anchor, int w, int h, int x, int y)
 {
   w -= _base_size.x(); 
   h -= _base_size.y();
@@ -856,7 +998,7 @@ void OBClient::resize(Corner anchor, int w, int h, int x, int y)
 
   _area.setSize(w, h);
 
-  XResizeWindow(otk::OBDisplay::display, _window, w, h);
+  XResizeWindow(otk::Display::display, _window, w, h);
 
   // resize the frame to match the request
   frame->adjustSize();
@@ -864,19 +1006,38 @@ void OBClient::resize(Corner anchor, int w, int h, int x, int y)
 }
 
 
-void OBClient::move(int x, int y)
+void Client::move(int x, int y)
 {
   _area.setPos(x, y);
 
   // move the frame to be in the requested position
-  frame->adjustPosition();
+  if (frame) { // this can be called while mapping, before frame exists
+    frame->adjustPosition();
+
+    // send synthetic configure notify (we don't need to if we aren't mapped
+    // yet)
+    XEvent event;
+    event.type = ConfigureNotify;
+    event.xconfigure.display = otk::Display::display;
+    event.xconfigure.event = _window;
+    event.xconfigure.window = _window;
+    event.xconfigure.x = x;
+    event.xconfigure.y = y;
+    event.xconfigure.width = _area.width();
+    event.xconfigure.height = _area.height();
+    event.xconfigure.border_width = _border_width;
+    event.xconfigure.above = frame->window();
+    event.xconfigure.override_redirect = False;
+    XSendEvent(event.xconfigure.display, event.xconfigure.window, False,
+               StructureNotifyMask, &event);
+  }
 }
 
 
-void OBClient::close()
+void Client::close()
 {
   XEvent ce;
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   if (!(_functions & Func_Close)) return;
 
@@ -887,60 +1048,62 @@ void OBClient::close()
   // explicitly killed.
 
   ce.xclient.type = ClientMessage;
-  ce.xclient.message_type =  property->atom(otk::OBProperty::wm_protocols);
-  ce.xclient.display = otk::OBDisplay::display;
+  ce.xclient.message_type =  property->atom(otk::Property::wm_protocols);
+  ce.xclient.display = otk::Display::display;
   ce.xclient.window = _window;
   ce.xclient.format = 32;
-  ce.xclient.data.l[0] = property->atom(otk::OBProperty::wm_delete_window);
+  ce.xclient.data.l[0] = property->atom(otk::Property::wm_delete_window);
   ce.xclient.data.l[1] = CurrentTime;
   ce.xclient.data.l[2] = 0l;
   ce.xclient.data.l[3] = 0l;
   ce.xclient.data.l[4] = 0l;
-  XSendEvent(otk::OBDisplay::display, _window, False, NoEventMask, &ce);
+  XSendEvent(otk::Display::display, _window, false, NoEventMask, &ce);
 }
 
 
-void OBClient::changeState()
+void Client::changeState()
 {
-  const otk::OBProperty *property = Openbox::instance->property();
+  const otk::Property *property = Openbox::instance->property();
 
   unsigned long state[2];
   state[0] = _wmstate;
   state[1] = None;
-  property->set(_window, otk::OBProperty::wm_state, otk::OBProperty::wm_state,
+  property->set(_window, otk::Property::wm_state, otk::Property::wm_state,
                 state, 2);
   
   Atom netstate[10];
   int num = 0;
   if (_modal)
-    netstate[num++] = property->atom(otk::OBProperty::net_wm_state_modal);
+    netstate[num++] = property->atom(otk::Property::net_wm_state_modal);
   if (_shaded)
-    netstate[num++] = property->atom(otk::OBProperty::net_wm_state_shaded);
+    netstate[num++] = property->atom(otk::Property::net_wm_state_shaded);
   if (_iconic)
-    netstate[num++] = property->atom(otk::OBProperty::net_wm_state_hidden);
+    netstate[num++] = property->atom(otk::Property::net_wm_state_hidden);
   if (_skip_taskbar)
     netstate[num++] =
-      property->atom(otk::OBProperty::net_wm_state_skip_taskbar);
+      property->atom(otk::Property::net_wm_state_skip_taskbar);
   if (_skip_pager)
-    netstate[num++] = property->atom(otk::OBProperty::net_wm_state_skip_pager);
+    netstate[num++] = property->atom(otk::Property::net_wm_state_skip_pager);
   if (_fullscreen)
-    netstate[num++] = property->atom(otk::OBProperty::net_wm_state_fullscreen);
+    netstate[num++] = property->atom(otk::Property::net_wm_state_fullscreen);
   if (_max_vert)
     netstate[num++] =
-      property->atom(otk::OBProperty::net_wm_state_maximized_vert);
+      property->atom(otk::Property::net_wm_state_maximized_vert);
   if (_max_horz)
     netstate[num++] =
-      property->atom(otk::OBProperty::net_wm_state_maximized_horz);
+      property->atom(otk::Property::net_wm_state_maximized_horz);
   if (_above)
-    netstate[num++] = property->atom(otk::OBProperty::net_wm_state_above);
+    netstate[num++] = property->atom(otk::Property::net_wm_state_above);
   if (_below)
-    netstate[num++] = property->atom(otk::OBProperty::net_wm_state_below);
-  property->set(_window, otk::OBProperty::net_wm_state,
-                otk::OBProperty::Atom_Atom, netstate, num);
-  
+    netstate[num++] = property->atom(otk::Property::net_wm_state_below);
+  property->set(_window, otk::Property::net_wm_state,
+                otk::Property::Atom_Atom, netstate, num);
+
+  calcLayer();
 }
 
-void OBClient::shade(bool shade)
+
+void Client::shade(bool shade)
 {
   if (shade == _shaded) return; // already done
 
@@ -951,35 +1114,40 @@ void OBClient::shade(bool shade)
 }
 
 
-bool OBClient::focus()
+bool Client::focus() const
 {
-  if (!(_can_focus || _focus_notify) || _focused) return false;
+  // won't try focus if the client doesn't want it, or if the window isn't
+  // visible on the screen
+  if (!(frame->isVisible() && (_can_focus || _focus_notify))) return false;
+
+  if (_focused) return true;
 
   if (_can_focus)
-    XSetInputFocus(otk::OBDisplay::display, _window, RevertToNone, CurrentTime);
+    XSetInputFocus(otk::Display::display, _window,
+                   RevertToNone, CurrentTime);
 
   if (_focus_notify) {
     XEvent ce;
-    const otk::OBProperty *property = Openbox::instance->property();
+    const otk::Property *property = Openbox::instance->property();
     
     ce.xclient.type = ClientMessage;
-    ce.xclient.message_type =  property->atom(otk::OBProperty::wm_protocols);
-    ce.xclient.display = otk::OBDisplay::display;
+    ce.xclient.message_type =  property->atom(otk::Property::wm_protocols);
+    ce.xclient.display = otk::Display::display;
     ce.xclient.window = _window;
     ce.xclient.format = 32;
-    ce.xclient.data.l[0] = property->atom(otk::OBProperty::wm_take_focus);
+    ce.xclient.data.l[0] = property->atom(otk::Property::wm_take_focus);
     ce.xclient.data.l[1] = Openbox::instance->lastTime();
     ce.xclient.data.l[2] = 0l;
     ce.xclient.data.l[3] = 0l;
     ce.xclient.data.l[4] = 0l;
-    XSendEvent(otk::OBDisplay::display, _window, False, NoEventMask, &ce);
+    XSendEvent(otk::Display::display, _window, False, NoEventMask, &ce);
   }
 
   return true;
 }
 
 
-void OBClient::unfocus()
+void Client::unfocus() const
 {
   if (!_focused) return;
 
@@ -988,13 +1156,13 @@ void OBClient::unfocus()
 }
 
 
-void OBClient::focusHandler(const XFocusChangeEvent &e)
+void Client::focusHandler(const XFocusChangeEvent &e)
 {
 #ifdef    DEBUG
-  printf("FocusIn for 0x%lx\n", e.window);
+//  printf("FocusIn for 0x%lx\n", e.window);
 #endif // DEBUG
   
-  OtkEventHandler::focusHandler(e);
+  otk::EventHandler::focusHandler(e);
 
   frame->focus();
   _focused = true;
@@ -1003,31 +1171,29 @@ void OBClient::focusHandler(const XFocusChangeEvent &e)
 }
 
 
-void OBClient::unfocusHandler(const XFocusChangeEvent &e)
+void Client::unfocusHandler(const XFocusChangeEvent &e)
 {
 #ifdef    DEBUG
-  printf("FocusOut for 0x%lx\n", e.window);
+//  printf("FocusOut for 0x%lx\n", e.window);
 #endif // DEBUG
   
-  OtkEventHandler::unfocusHandler(e);
+  otk::EventHandler::unfocusHandler(e);
 
   frame->unfocus();
   _focused = false;
 
-  if (Openbox::instance->focusedClient() == this) {
-    printf("UNFOCUSED!\n");
-    Openbox::instance->setFocusedClient(this);
-  }
+  if (Openbox::instance->focusedClient() == this)
+    Openbox::instance->setFocusedClient(0);
 }
 
 
-void OBClient::configureRequestHandler(const XConfigureRequestEvent &e)
+void Client::configureRequestHandler(const XConfigureRequestEvent &e)
 {
 #ifdef    DEBUG
   printf("ConfigureRequest for 0x%lx\n", e.window);
 #endif // DEBUG
   
-  OtkEventHandler::configureRequestHandler(e);
+  otk::EventHandler::configureRequestHandler(e);
 
   // XXX: if we are iconic (or shaded? (fvwm does that)) ignore the event
 
@@ -1073,51 +1239,54 @@ void OBClient::configureRequestHandler(const XConfigureRequestEvent &e)
     switch (e.detail) {
     case Below:
     case BottomIf:
-      // XXX: lower the window
+      Openbox::instance->screen(_screen)->restack(false, this); // lower
       break;
 
     case Above:
     case TopIf:
     default:
-      // XXX: raise the window
+      Openbox::instance->screen(_screen)->restack(true, this); // raise
       break;
     }
   }
 }
 
 
-void OBClient::unmapHandler(const XUnmapEvent &e)
+void Client::unmapHandler(const XUnmapEvent &e)
 {
+  if (ignore_unmaps) {
 #ifdef    DEBUG
-  printf("UnmapNotify for 0x%lx\n", e.window);
+    printf("Ignored UnmapNotify for 0x%lx (event 0x%lx)\n", e.window, e.event);
 #endif // DEBUG
-
-  if (ignore_unmaps) {
     ignore_unmaps--;
     return;
   }
   
-  OtkEventHandler::unmapHandler(e);
+#ifdef    DEBUG
+  printf("UnmapNotify for 0x%lx\n", e.window);
+#endif // DEBUG
+
+  otk::EventHandler::unmapHandler(e);
 
   // this deletes us etc
   Openbox::instance->screen(_screen)->unmanageWindow(this);
 }
 
 
-void OBClient::destroyHandler(const XDestroyWindowEvent &e)
+void Client::destroyHandler(const XDestroyWindowEvent &e)
 {
 #ifdef    DEBUG
   printf("DestroyNotify for 0x%lx\n", e.window);
 #endif // DEBUG
 
-  OtkEventHandler::destroyHandler(e);
+  otk::EventHandler::destroyHandler(e);
 
   // this deletes us etc
   Openbox::instance->screen(_screen)->unmanageWindow(this);
 }
 
 
-void OBClient::reparentHandler(const XReparentEvent &e)
+void Client::reparentHandler(const XReparentEvent &e)
 {
   // this is when the client is first taken captive in the frame
   if (e.parent == frame->plate()) return;
@@ -1126,7 +1295,7 @@ void OBClient::reparentHandler(const XReparentEvent &e)
   printf("ReparentNotify for 0x%lx\n", e.window);
 #endif // DEBUG
 
-  OtkEventHandler::reparentHandler(e);
+  otk::EventHandler::reparentHandler(e);
 
   /*
     This event is quite rare and is usually handled in unmapHandler.
@@ -1135,6 +1304,12 @@ void OBClient::reparentHandler(const XReparentEvent &e)
     to an already unmapped window.
   */
 
+  // we don't want the reparent event, put it back on the stack for the X
+  // server to deal with after we unmanage the window
+  XEvent ev;
+  ev.xreparent = e;
+  XPutBackEvent(otk::Display::display, &ev);
+  
   // this deletes us etc
   Openbox::instance->screen(_screen)->unmanageWindow(this);
 }