X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fclient.cc;h=b36ba9aff2a6fe9bdf701b5f1de4f848b7396f56;hb=6871cff3face4486055444a6c6218a552ddad461;hp=231992f14fbb3dcfc443105aff7527b85cf42f39;hpb=9e77a88d269bfafb78e56a646bfacebdd6ff4c5a;p=chaz%2Fopenbox

diff --git a/src/client.cc b/src/client.cc
index 231992f1..b36ba9af 100644
--- a/src/client.cc
+++ b/src/client.cc
@@ -14,6 +14,7 @@
 extern "C" {
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
+#include <X11/Xatom.h>
 
 #include <assert.h>
 
@@ -59,7 +60,8 @@ Client::Client(int screen, Window window)
   getShaped();
 
   updateProtocols();
-  updateNormalHints();
+  getGravity(); // get the attribute gravity
+  updateNormalHints(); // this may override the attribute gravity
   updateWMHints();
   updateTitle();
   updateIconTitle();
@@ -72,8 +74,6 @@ Client::Client(int screen, Window window)
 
 Client::~Client()
 {
-  const otk::Property *property = openbox->property();
-
   // clean up childrens' references
   while (!_transients.empty()) {
     _transients.front()->_transient_for = 0;
@@ -86,72 +86,67 @@ Client::~Client()
   
   if (openbox->state() != Openbox::State_Exiting) {
     // these values should not be persisted across a window unmapping/mapping
-    property->erase(_window, otk::Property::net_wm_desktop);
-    property->erase(_window, otk::Property::net_wm_state);
+    otk::Property::erase(_window, otk::Property::atoms.net_wm_desktop);
+    otk::Property::erase(_window, otk::Property::atoms.net_wm_state);
   }
 }
 
 
-void Client::getDesktop()
+void Client::getGravity()
 {
-  const otk::Property *property = openbox->property();
+  XWindowAttributes wattrib;
+  Status ret;
 
+  ret = XGetWindowAttributes(**otk::display, _window, &wattrib);
+  assert(ret != BadWindow);
+  _gravity = wattrib.win_gravity;
+}
+
+
+void Client::getDesktop()
+{
   // defaults to the current desktop
   _desktop = openbox->screen(_screen)->desktop();
 
-  if (!property->get(_window, otk::Property::net_wm_desktop,
-                     otk::Property::Atom_Cardinal,
-                     (long unsigned*)&_desktop)) {
+  if (!otk::Property::get(_window, otk::Property::atoms.net_wm_desktop,
+                          otk::Property::atoms.cardinal,
+                          (long unsigned*)&_desktop)) {
     // make sure the hint exists
-    openbox->property()->set(_window,
-                                       otk::Property::net_wm_desktop,
-                                       otk::Property::Atom_Cardinal,
-                                       (unsigned)_desktop);
+    otk::Property::set(_window, otk::Property::atoms.net_wm_desktop,
+                       otk::Property::atoms.cardinal, (unsigned)_desktop);
   }
 }
 
 
 void Client::getType()
 {
-  const otk::Property *property = openbox->property();
-
   _type = (WindowType) -1;
   
   unsigned long *val;
   unsigned long num = (unsigned) -1;
-  if (property->get(_window, otk::Property::net_wm_window_type,
-                    otk::Property::Atom_Atom,
-                    &num, &val)) {
+  if (otk::Property::get(_window, otk::Property::atoms.net_wm_window_type,
+                         otk::Property::atoms.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::Property::net_wm_window_type_desktop))
+      if (val[i] == otk::Property::atoms.net_wm_window_type_desktop)
         _type = Type_Desktop;
-      else if (val[i] ==
-               property->atom(otk::Property::net_wm_window_type_dock))
+      else if (val[i] == otk::Property::atoms.net_wm_window_type_dock)
         _type = Type_Dock;
-      else if (val[i] ==
-               property->atom(otk::Property::net_wm_window_type_toolbar))
+      else if (val[i] == otk::Property::atoms.net_wm_window_type_toolbar)
         _type = Type_Toolbar;
-      else if (val[i] ==
-               property->atom(otk::Property::net_wm_window_type_menu))
+      else if (val[i] == otk::Property::atoms.net_wm_window_type_menu)
         _type = Type_Menu;
-      else if (val[i] ==
-               property->atom(otk::Property::net_wm_window_type_utility))
+      else if (val[i] == otk::Property::atoms.net_wm_window_type_utility)
         _type = Type_Utility;
-      else if (val[i] ==
-               property->atom(otk::Property::net_wm_window_type_splash))
+      else if (val[i] == otk::Property::atoms.net_wm_window_type_splash)
         _type = Type_Splash;
-      else if (val[i] ==
-               property->atom(otk::Property::net_wm_window_type_dialog))
+      else if (val[i] == otk::Property::atoms.net_wm_window_type_dialog)
         _type = Type_Dialog;
-      else if (val[i] ==
-               property->atom(otk::Property::net_wm_window_type_normal))
+      else if (val[i] == otk::Property::atoms.net_wm_window_type_normal)
         _type = Type_Normal;
-//      else if (val[i] ==
-//               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
+//    XXX: make this work again
+//    else if (val[i] == otk::Property::atoms.kde_net_wm_window_type_override)
+//      mwm_decorations = 0; // prevent this window from getting any decor
       if (_type != (WindowType) -1)
         break; // grab the first known type
     }
@@ -173,15 +168,17 @@ void Client::getType()
 
 void Client::setupDecorAndFunctions()
 {
-  // start with everything
+  // start with everything (cept fullscreen)
   _decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
     Decor_Iconify | Decor_Maximize;
-  _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
+  _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
+    Func_Shade;
   
   switch (_type) {
   case Type_Normal:
     // normal windows retain all of the possible decorations and
-    // functionality
+    // functionality, and are the only windows that you can fullscreen
+    _functions |= Func_Fullscreen;
 
   case Type_Dialog:
     // dialogs cannot be maximized
@@ -214,8 +211,11 @@ void Client::setupDecorAndFunctions()
         _decorations &= ~Decor_Border;
       if (! (_mwmhints.decorations & MwmDecor_Handle))
         _decorations &= ~Decor_Handle;
-      if (! (_mwmhints.decorations & MwmDecor_Title))
+      if (! (_mwmhints.decorations & MwmDecor_Title)) {
         _decorations &= ~Decor_Titlebar;
+        // if we don't have a titlebar, then we cannot shade!
+        _functions &= ~Func_Shade;
+      }
       if (! (_mwmhints.decorations & MwmDecor_Iconify))
         _decorations &= ~Decor_Iconify;
       if (! (_mwmhints.decorations & MwmDecor_Maximize))
@@ -239,22 +239,20 @@ void Client::setupDecorAndFunctions()
     }
   }
 
-  // XXX: changeAllowedActions();
+  changeAllowedActions();
 }
 
 
 void Client::getMwmHints()
 {
-  const otk::Property *property = openbox->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))
+  if (!otk::Property::get(_window, otk::Property::atoms.motif_wm_hints,
+                          otk::Property::atoms.motif_wm_hints, &num,
+                          (unsigned long **)&hints))
     return;
   
   if (num >= MwmHints::elements) {
@@ -273,7 +271,7 @@ void Client::getArea()
   XWindowAttributes wattrib;
   Status ret;
   
-  ret = XGetWindowAttributes(otk::Display::display, _window, &wattrib);
+  ret = XGetWindowAttributes(**otk::display, _window, &wattrib);
   assert(ret != BadWindow);
 
   _area.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
@@ -283,43 +281,32 @@ void Client::getArea()
 
 void Client::getState()
 {
-  const otk::Property *property = openbox->property();
-
   _modal = _shaded = _max_horz = _max_vert = _fullscreen = _above = _below =
     _skip_taskbar = _skip_pager = false;
   
   unsigned long *state;
   unsigned long num = (unsigned) -1;
   
-  if (property->get(_window, otk::Property::net_wm_state,
-                    otk::Property::Atom_Atom, &num, &state)) {
+  if (otk::Property::get(_window, otk::Property::atoms.net_wm_state,
+                         otk::Property::atoms.atom, &num, &state)) {
     for (unsigned long i = 0; i < num; ++i) {
-      if (state[i] == property->atom(otk::Property::net_wm_state_modal))
+      if (state[i] == otk::Property::atoms.net_wm_state_modal)
         _modal = true;
-      else if (state[i] ==
-               property->atom(otk::Property::net_wm_state_shaded)) {
+      else if (state[i] == otk::Property::atoms.net_wm_state_shaded)
         _shaded = true;
-        _wmstate = IconicState;
-      } else if (state[i] ==
-               property->atom(otk::Property::net_wm_state_skip_taskbar))
+      else if (state[i] == otk::Property::atoms.net_wm_state_skip_taskbar)
         _skip_taskbar = true;
-      else if (state[i] ==
-               property->atom(otk::Property::net_wm_state_skip_pager))
+      else if (state[i] == otk::Property::atoms.net_wm_state_skip_pager)
         _skip_pager = true;
-      else if (state[i] ==
-               property->atom(otk::Property::net_wm_state_fullscreen))
+      else if (state[i] == otk::Property::atoms.net_wm_state_fullscreen)
         _fullscreen = true;
-      else if (state[i] ==
-               property->atom(otk::Property::net_wm_state_maximized_vert))
+      else if (state[i] == otk::Property::atoms.net_wm_state_maximized_vert)
         _max_vert = true;
-      else if (state[i] ==
-               property->atom(otk::Property::net_wm_state_maximized_horz))
+      else if (state[i] == otk::Property::atoms.net_wm_state_maximized_horz)
         _max_horz = true;
-      else if (state[i] ==
-               property->atom(otk::Property::net_wm_state_above))
+      else if (state[i] == otk::Property::atoms.net_wm_state_above)
         _above = true;
-      else if (state[i] ==
-               property->atom(otk::Property::net_wm_state_below))
+      else if (state[i] == otk::Property::atoms.net_wm_state_below)
         _below = true;
     }
 
@@ -332,14 +319,14 @@ void Client::getShaped()
 {
   _shaped = false;
 #ifdef   SHAPE
-  if (otk::Display::shape()) {
+  if (otk::display->shape()) {
     int foo;
     unsigned int ufoo;
     int s;
 
-    XShapeSelectInput(otk::Display::display, _window, ShapeNotifyMask);
+    XShapeSelectInput(**otk::display, _window, ShapeNotifyMask);
 
-    XShapeQueryExtents(otk::Display::display, _window, &s, &foo,
+    XShapeQueryExtents(**otk::display, _window, &s, &foo,
                        &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo);
     _shaped = (s != 0);
   }
@@ -368,7 +355,7 @@ void Client::calcLayer() {
         if we don't have a frame, then we aren't mapped yet (and this would
         SIGSEGV :)
       */
-      openbox->screen(_screen)->restack(true, this); // raise
+      openbox->screen(_screen)->raiseWindow(this);
     }
   }
 }
@@ -376,8 +363,6 @@ void Client::calcLayer() {
 
 void Client::updateProtocols()
 {
-  const otk::Property *property = openbox->property();
-
   Atom *proto;
   int num_return = 0;
 
@@ -385,14 +370,14 @@ void Client::updateProtocols()
   _decorations &= ~Decor_Close;
   _functions &= ~Func_Close;
 
-  if (XGetWMProtocols(otk::Display::display, _window, &proto, &num_return)) {
+  if (XGetWMProtocols(**otk::display, _window, &proto, &num_return)) {
     for (int i = 0; i < num_return; ++i) {
-      if (proto[i] == property->atom(otk::Property::wm_delete_window)) {
+      if (proto[i] == otk::Property::atoms.wm_delete_window) {
         _decorations |= Decor_Close;
         _functions |= Func_Close;
         if (frame)
           frame->adjustSize(); // update the decorations
-      } else if (proto[i] == property->atom(otk::Property::wm_take_focus))
+      } else if (proto[i] == otk::Property::atoms.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;
@@ -409,7 +394,6 @@ void Client::updateNormalHints()
   int oldgravity = _gravity;
 
   // defaults
-  _gravity = NorthWestGravity;
   _size_inc.setPoint(1, 1);
   _base_size.setPoint(0, 0);
   _min_size.setPoint(0, 0);
@@ -419,11 +403,21 @@ void Client::updateNormalHints()
   // point..
 
   // get the hints from the window
-  if (XGetWMNormalHints(otk::Display::display, _window, &size, &ret)) {
+  if (XGetWMNormalHints(**otk::display, _window, &size, &ret)) {
     _positioned = (size.flags & (PPosition|USPosition));
 
-    if (size.flags & PWinGravity)
+    if (size.flags & PWinGravity) {
       _gravity = size.win_gravity;
+      
+      // if the client has a frame, i.e. has already been mapped and is
+      // changing its gravity
+      if (frame && _gravity != oldgravity) {
+        // move our idea of the client's position based on its new gravity
+        int x, y;
+        frame->frameGravity(x, y);
+        _area.setPos(x, y);
+      }
+    }
 
     if (size.flags & PMinSize)
       _min_size.setPoint(size.min_width, size.min_height);
@@ -437,15 +431,6 @@ void Client::updateNormalHints()
     if (size.flags & PResizeInc)
       _size_inc.setPoint(size.width_inc, size.height_inc);
   }
-
-  // if the client has a frame, i.e. has already been mapped and is
-  // changing its gravity
-  if (frame && _gravity != oldgravity) {
-    // move our idea of the client's position based on its new gravity
-    int x, y;
-    frame->frameGravity(x, y);
-    _area.setPos(x, y);
-  }
 }
 
 
@@ -457,7 +442,7 @@ void Client::updateWMHints()
   _can_focus = true;
   _urgent = false;
   
-  if ((hints = XGetWMHints(otk::Display::display, _window)) != NULL) {
+  if ((hints = XGetWMHints(**otk::display, _window)) != NULL) {
     if (hints->flags & InputHint)
       _can_focus = hints->input;
 
@@ -480,16 +465,14 @@ void Client::updateWMHints()
 
 void Client::updateTitle()
 {
-  const otk::Property *property = openbox->property();
-
   _title = "";
   
   // try netwm
-  if (! property->get(_window, otk::Property::net_wm_name,
-                      otk::Property::utf8, &_title)) {
+  if (!otk::Property::get(_window, otk::Property::atoms.net_wm_name,
+                          otk::Property::utf8, &_title)) {
     // try old x stuff
-    property->get(_window, otk::Property::wm_name,
-                  otk::Property::ascii, &_title);
+    otk::Property::get(_window, otk::Property::atoms.wm_name,
+                       otk::Property::ascii, &_title);
   }
 
   if (_title.empty())
@@ -502,16 +485,14 @@ void Client::updateTitle()
 
 void Client::updateIconTitle()
 {
-  const otk::Property *property = openbox->property();
-
   _icon_title = "";
   
   // try netwm
-  if (! property->get(_window, otk::Property::net_wm_icon_name,
-                      otk::Property::utf8, &_icon_title)) {
+  if (!otk::Property::get(_window, otk::Property::atoms.net_wm_icon_name,
+                          otk::Property::utf8, &_icon_title)) {
     // try old x stuff
-    property->get(_window, otk::Property::wm_icon_name,
-                  otk::Property::ascii, &_icon_title);
+    otk::Property::get(_window, otk::Property::atoms.wm_icon_name,
+                       otk::Property::ascii, &_icon_title);
   }
 
   if (_title.empty())
@@ -521,24 +502,22 @@ void Client::updateIconTitle()
 
 void Client::updateClass()
 {
-  const otk::Property *property = openbox->property();
-
   // set the defaults
   _app_name = _app_class = _role = "";
 
   otk::Property::StringVect v;
   unsigned long num = 2;
 
-  if (property->get(_window, otk::Property::wm_class,
-                    otk::Property::ascii, &num, &v)) {
+  if (otk::Property::get(_window, otk::Property::atoms.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 (otk::Property::get(_window, otk::Property::atoms.wm_window_role,
+                         otk::Property::ascii, &num, &v)) {
     if (num > 0) _role = v[0].c_str();
   }
 }
@@ -548,10 +527,8 @@ void Client::updateStrut()
 {
   unsigned long num = 4;
   unsigned long *data;
-  if (!openbox->property()->get(_window,
-                                          otk::Property::net_wm_strut,
-                                          otk::Property::Atom_Cardinal,
-                                          &num, &data))
+  if (!otk::Property::get(_window, otk::Property::atoms.net_wm_strut,
+                          otk::Property::atoms.cardinal, &num, &data))
     return;
 
   if (num == 4) {
@@ -572,7 +549,7 @@ void Client::updateTransientFor()
   Window t = 0;
   Client *c = 0;
 
-  if (XGetTransientForHint(otk::Display::display, _window, &t) &&
+  if (XGetTransientForHint(**otk::display, _window, &t) &&
       t != _window) { // cant be transient to itself!
     c = openbox->findClient(t);
     assert(c != this); // if this happens then we need to check for it
@@ -581,7 +558,7 @@ void Client::updateTransientFor()
       // 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()) {
+        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!
@@ -606,15 +583,13 @@ void Client::propertyHandler(const XPropertyEvent &e)
 {
   otk::EventHandler::propertyHandler(e);
   
-  const otk::Property *property = openbox->property();
-
   // compress changes to a single property into a single change
   XEvent ce;
-  while (XCheckTypedEvent(otk::Display::display, e.type, &ce)) {
+  while (XCheckTypedEvent(**otk::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::Display::display, &ce);
+      XPutBackEvent(**otk::display, &ce);
       break;
     }
   }
@@ -630,17 +605,17 @@ void Client::propertyHandler(const XPropertyEvent &e)
     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))
+  else if (e.atom == otk::Property::atoms.net_wm_name ||
+           e.atom == otk::Property::atoms.wm_name)
     updateTitle();
-  else if (e.atom == property->atom(otk::Property::net_wm_icon_name) ||
-           e.atom == property->atom(otk::Property::wm_icon_name))
+  else if (e.atom == otk::Property::atoms.net_wm_icon_name ||
+           e.atom == otk::Property::atoms.wm_icon_name)
     updateIconTitle();
-  else if (e.atom == property->atom(otk::Property::wm_class))
+  else if (e.atom == otk::Property::atoms.wm_class)
     updateClass();
-  else if (e.atom == property->atom(otk::Property::wm_protocols))
+  else if (e.atom == otk::Property::atoms.wm_protocols)
     updateProtocols();
-  else if (e.atom == property->atom(otk::Property::net_wm_strut))
+  else if (e.atom == otk::Property::atoms.net_wm_strut)
     updateStrut();
 }
 
@@ -671,10 +646,8 @@ void Client::setDesktop(long target)
   
   _desktop = target;
 
-  openbox->property()->set(_window,
-                                     otk::Property::net_wm_desktop,
-                                     otk::Property::Atom_Cardinal,
-                                     (unsigned)_desktop);
+  otk::Property::set(_window, otk::Property::atoms.net_wm_desktop,
+                     otk::Property::atoms.cardinal, (unsigned)_desktop);
   
   // 'move' the window to the new desktop
   if (_desktop == openbox->screen(_screen)->desktop() ||
@@ -687,8 +660,8 @@ void Client::setDesktop(long target)
 
 void Client::setState(StateAction action, long data1, long data2)
 {
-  const otk::Property *property = openbox->property();
   bool shadestate = _shaded;
+  bool fsstate = _fullscreen;
 
   if (!(action == State_Add || action == State_Remove ||
         action == State_Toggle))
@@ -701,111 +674,88 @@ void Client::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::Property::net_wm_state_modal))
+      if (state == otk::Property::atoms.net_wm_state_modal)
         action = _modal ? State_Remove : State_Add;
-      else if (state ==
-               property->atom(otk::Property::net_wm_state_maximized_vert))
+      else if (state == otk::Property::atoms.net_wm_state_maximized_vert)
         action = _max_vert ? State_Remove : State_Add;
-      else if (state ==
-               property->atom(otk::Property::net_wm_state_maximized_horz))
+      else if (state == otk::Property::atoms.net_wm_state_maximized_horz)
         action = _max_horz ? State_Remove : State_Add;
-      else if (state == property->atom(otk::Property::net_wm_state_shaded))
+      else if (state == otk::Property::atoms.net_wm_state_shaded)
         action = _shaded ? State_Remove : State_Add;
-      else if (state ==
-               property->atom(otk::Property::net_wm_state_skip_taskbar))
+      else if (state == otk::Property::atoms.net_wm_state_skip_taskbar)
         action = _skip_taskbar ? State_Remove : State_Add;
-      else if (state ==
-               property->atom(otk::Property::net_wm_state_skip_pager))
+      else if (state == otk::Property::atoms.net_wm_state_skip_pager)
         action = _skip_pager ? State_Remove : State_Add;
-      else if (state ==
-               property->atom(otk::Property::net_wm_state_fullscreen))
+      else if (state == otk::Property::atoms.net_wm_state_fullscreen)
         action = _fullscreen ? State_Remove : State_Add;
-      else if (state == property->atom(otk::Property::net_wm_state_above))
+      else if (state == otk::Property::atoms.net_wm_state_above)
         action = _above ? State_Remove : State_Add;
-      else if (state == property->atom(otk::Property::net_wm_state_below))
+      else if (state == otk::Property::atoms.net_wm_state_below)
         action = _below ? State_Remove : State_Add;
     }
     
     if (action == State_Add) {
-      if (state == property->atom(otk::Property::net_wm_state_modal)) {
+      if (state == otk::Property::atoms.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::Property::net_wm_state_maximized_vert)){
+      } else if (state == otk::Property::atoms.net_wm_state_maximized_vert) {
         if (_max_vert) continue;
         _max_vert = true;
         // XXX: resize the window etc
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_maximized_horz)){
+      } else if (state == otk::Property::atoms.net_wm_state_maximized_horz) {
         if (_max_horz) continue;
         _max_horz = true;
         // XXX: resize the window etc
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_shaded)) {
-        if (_shaded) continue;
-        // shade when we're all thru here
+      } else if (state == otk::Property::atoms.net_wm_state_shaded) {
         shadestate = true;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_skip_taskbar)) {
+      } else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) {
         _skip_taskbar = true;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_skip_pager)) {
+      } else if (state == otk::Property::atoms.net_wm_state_skip_pager) {
         _skip_pager = true;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_fullscreen)) {
-        if (_fullscreen) continue;
-        _fullscreen = true;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_above)) {
+      } else if (state == otk::Property::atoms.net_wm_state_fullscreen) {
+        fsstate = true;
+      } else if (state == otk::Property::atoms.net_wm_state_above) {
         if (_above) continue;
         _above = true;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_below)) {
+      } else if (state == otk::Property::atoms.net_wm_state_below) {
         if (_below) continue;
         _below = true;
       }
 
     } else { // action == State_Remove
-      if (state == property->atom(otk::Property::net_wm_state_modal)) {
+      if (state == otk::Property::atoms.net_wm_state_modal) {
         if (!_modal) continue;
         _modal = false;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_maximized_vert)){
+      } else if (state == otk::Property::atoms.net_wm_state_maximized_vert) {
         if (!_max_vert) continue;
         _max_vert = false;
         // XXX: resize the window etc
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_maximized_horz)){
+      } else if (state == otk::Property::atoms.net_wm_state_maximized_horz) {
         if (!_max_horz) continue;
         _max_horz = false;
         // XXX: resize the window etc
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_shaded)) {
-        if (!_shaded) continue;
-        // unshade when we're all thru here
+      } else if (state == otk::Property::atoms.net_wm_state_shaded) {
         shadestate = false;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_skip_taskbar)) {
+      } else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) {
         _skip_taskbar = false;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_skip_pager)) {
+      } else if (state == otk::Property::atoms.net_wm_state_skip_pager) {
         _skip_pager = false;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_fullscreen)) {
-        if (!_fullscreen) continue;
-        _fullscreen = false;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_above)) {
+      } else if (state == otk::Property::atoms.net_wm_state_fullscreen) {
+        fsstate = false;
+      } else if (state == otk::Property::atoms.net_wm_state_above) {
         if (!_above) continue;
         _above = false;
-      } else if (state ==
-                 property->atom(otk::Property::net_wm_state_below)) {
+      } else if (state == otk::Property::atoms.net_wm_state_below) {
         if (!_below) continue;
         _below = false;
       }
     }
   }
+  // change fullscreen state before shading, as it will affect if the window
+  // can shade or not
+  if (fsstate != _fullscreen)
+    fullscreen(fsstate);
   if (shadestate != _shaded)
     shade(shadestate);
   calcLayer();
@@ -821,6 +771,7 @@ void Client::toggleClientBorder(bool addborder)
   // reversed.
   int x = _area.x(), y = _area.y();
   switch(_gravity) {
+  default:
   case NorthWestGravity:
   case WestGravity:
   case SouthWestGravity:
@@ -831,8 +782,17 @@ void Client::toggleClientBorder(bool addborder)
     if (addborder) x -= _border_width * 2;
     else           x += _border_width * 2;
     break;
+  case NorthGravity:
+  case SouthGravity:
+  case CenterGravity:
+  case ForgetGravity:
+  case StaticGravity:
+    if (addborder) x -= _border_width;
+    else           x += _border_width;
+    break;
   }
   switch(_gravity) {
+  default:
   case NorthWestGravity:
   case NorthGravity:
   case NorthEastGravity:
@@ -843,19 +803,24 @@ void Client::toggleClientBorder(bool addborder)
     if (addborder) y -= _border_width * 2;
     else           y += _border_width * 2;
     break;
-  default:
-    // no change for StaticGravity etc.
+  case WestGravity:
+  case EastGravity:
+  case CenterGravity:
+  case ForgetGravity:
+  case StaticGravity:
+    if (addborder) y -= _border_width;
+    else           y += _border_width;
     break;
   }
   _area.setPos(x, y);
 
   if (addborder) {
-    XSetWindowBorderWidth(otk::Display::display, _window, _border_width);
+    XSetWindowBorderWidth(**otk::display, _window, _border_width);
 
     // move the client so it is back it the right spot _with_ its border!
-    XMoveWindow(otk::Display::display, _window, x, y);
+    XMoveWindow(**otk::display, _window, x, y);
   } else
-    XSetWindowBorderWidth(otk::Display::display, _window, 0);
+    XSetWindowBorderWidth(**otk::display, _window, 0);
 }
 
 
@@ -865,17 +830,15 @@ void Client::clientMessageHandler(const XClientMessageEvent &e)
   
   if (e.format != 32) return;
 
-  const otk::Property *property = openbox->property();
-  
-  if (e.message_type == property->atom(otk::Property::wm_change_state)) {
+  if (e.message_type == otk::Property::atoms.wm_change_state) {
     // compress changes into a single change
     bool compress = false;
     XEvent ce;
-    while (XCheckTypedEvent(otk::Display::display, e.type, &ce)) {
+    while (XCheckTypedEvent(**otk::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::Display::display, &ce);
+        XPutBackEvent(**otk::display, &ce);
         break;
       }
       compress = true;
@@ -884,16 +847,15 @@ void Client::clientMessageHandler(const XClientMessageEvent &e)
       setWMState(ce.xclient.data.l[0]); // use the found event
     else
       setWMState(e.data.l[0]); // use the original event
-  } else if (e.message_type ==
-             property->atom(otk::Property::net_wm_desktop)) {
+  } else if (e.message_type == otk::Property::atoms.net_wm_desktop) {
     // compress changes into a single change 
     bool compress = false;
     XEvent ce;
-    while (XCheckTypedEvent(otk::Display::display, e.type, &ce)) {
+    while (XCheckTypedEvent(**otk::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::Display::display, &ce);
+        XPutBackEvent(**otk::display, &ce);
         break;
       }
       compress = true;
@@ -902,7 +864,7 @@ void Client::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::Property::net_wm_state)) {
+  } else if (e.message_type == otk::Property::atoms.net_wm_state) {
     // can't compress these
 #ifdef DEBUG
     printf("net_wm_state %s %ld %ld for 0x%lx\n",
@@ -911,14 +873,12 @@ void Client::clientMessageHandler(const XClientMessageEvent &e)
            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::Property::net_close_window)) {
+  } else if (e.message_type == otk::Property::atoms.net_close_window) {
 #ifdef DEBUG
     printf("net_close_window for 0x%lx\n", _window);
 #endif
     close();
-  } else if (e.message_type ==
-             property->atom(otk::Property::net_active_window)) {
+  } else if (e.message_type == otk::Property::atoms.net_active_window) {
 #ifdef DEBUG
     printf("net_active_window for 0x%lx\n", _window);
 #endif
@@ -926,7 +886,7 @@ void Client::clientMessageHandler(const XClientMessageEvent &e)
       shade(false);
     // XXX: deiconify
     focus();
-    openbox->screen(_screen)->restack(true, this); // raise
+    openbox->screen(_screen)->raiseWindow(this);
   }
 }
 
@@ -944,7 +904,14 @@ void Client::shapeHandler(const XShapeEvent &e)
 #endif
 
 
-void Client::resize(Corner anchor, int w, int h, int x, int y)
+void Client::resize(Corner anchor, int w, int h)
+{
+  if (!(_functions & Func_Resize)) return;
+  internal_resize(anchor, w, h);
+}
+
+
+void Client::internal_resize(Corner anchor, int w, int h, int x, int y)
 {
   w -= _base_size.x(); 
   h -= _base_size.y();
@@ -968,6 +935,10 @@ void Client::resize(Corner anchor, int w, int h, int x, int y)
   w /= _size_inc.x();
   h /= _size_inc.y();
 
+  // you cannot resize to nothing
+  if (w < 1) w = 1;
+  if (h < 1) h = 1;
+  
   // store the logical size
   _logical_size.setPoint(w, h);
 
@@ -998,15 +969,22 @@ void Client::resize(Corner anchor, int w, int h, int x, int y)
 
   _area.setSize(w, h);
 
-  XResizeWindow(otk::Display::display, _window, w, h);
+  XResizeWindow(**otk::display, _window, w, h);
 
   // resize the frame to match the request
   frame->adjustSize();
-  move(x, y);
+  internal_move(x, y);
 }
 
 
 void Client::move(int x, int y)
+{
+  if (!(_functions & Func_Move)) return;
+  internal_move(x, y);
+}
+
+
+void Client::internal_move(int x, int y)
 {
   _area.setPos(x, y);
 
@@ -1018,7 +996,7 @@ void Client::move(int x, int y)
     // yet)
     XEvent event;
     event.type = ConfigureNotify;
-    event.xconfigure.display = otk::Display::display;
+    event.xconfigure.display = **otk::display;
     event.xconfigure.event = _window;
     event.xconfigure.window = _window;
     event.xconfigure.x = x;
@@ -1037,7 +1015,6 @@ void Client::move(int x, int y)
 void Client::close()
 {
   XEvent ce;
-  const otk::Property *property = openbox->property();
 
   if (!(_functions & Func_Close)) return;
 
@@ -1048,64 +1025,113 @@ void Client::close()
   // explicitly killed.
 
   ce.xclient.type = ClientMessage;
-  ce.xclient.message_type =  property->atom(otk::Property::wm_protocols);
-  ce.xclient.display = otk::Display::display;
+  ce.xclient.message_type =  otk::Property::atoms.wm_protocols;
+  ce.xclient.display = **otk::display;
   ce.xclient.window = _window;
   ce.xclient.format = 32;
-  ce.xclient.data.l[0] = property->atom(otk::Property::wm_delete_window);
+  ce.xclient.data.l[0] = otk::Property::atoms.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::Display::display, _window, false, NoEventMask, &ce);
+  XSendEvent(**otk::display, _window, false, NoEventMask, &ce);
 }
 
 
 void Client::changeState()
 {
-  const otk::Property *property = openbox->property();
-
   unsigned long state[2];
   state[0] = _wmstate;
   state[1] = None;
-  property->set(_window, otk::Property::wm_state, otk::Property::wm_state,
-                state, 2);
+  otk::Property::set(_window, otk::Property::atoms.wm_state,
+                     otk::Property::atoms.wm_state, state, 2);
   
   Atom netstate[10];
   int num = 0;
   if (_modal)
-    netstate[num++] = property->atom(otk::Property::net_wm_state_modal);
+    netstate[num++] = otk::Property::atoms.net_wm_state_modal;
   if (_shaded)
-    netstate[num++] = property->atom(otk::Property::net_wm_state_shaded);
+    netstate[num++] = otk::Property::atoms.net_wm_state_shaded;
   if (_iconic)
-    netstate[num++] = property->atom(otk::Property::net_wm_state_hidden);
+    netstate[num++] = otk::Property::atoms.net_wm_state_hidden;
   if (_skip_taskbar)
-    netstate[num++] =
-      property->atom(otk::Property::net_wm_state_skip_taskbar);
+    netstate[num++] = otk::Property::atoms.net_wm_state_skip_taskbar;
   if (_skip_pager)
-    netstate[num++] = property->atom(otk::Property::net_wm_state_skip_pager);
+    netstate[num++] = otk::Property::atoms.net_wm_state_skip_pager;
   if (_fullscreen)
-    netstate[num++] = property->atom(otk::Property::net_wm_state_fullscreen);
+    netstate[num++] = otk::Property::atoms.net_wm_state_fullscreen;
   if (_max_vert)
-    netstate[num++] =
-      property->atom(otk::Property::net_wm_state_maximized_vert);
+    netstate[num++] = otk::Property::atoms.net_wm_state_maximized_vert;
   if (_max_horz)
-    netstate[num++] =
-      property->atom(otk::Property::net_wm_state_maximized_horz);
+    netstate[num++] = otk::Property::atoms.net_wm_state_maximized_horz;
   if (_above)
-    netstate[num++] = property->atom(otk::Property::net_wm_state_above);
+    netstate[num++] = otk::Property::atoms.net_wm_state_above;
   if (_below)
-    netstate[num++] = property->atom(otk::Property::net_wm_state_below);
-  property->set(_window, otk::Property::net_wm_state,
-                otk::Property::Atom_Atom, netstate, num);
+    netstate[num++] = otk::Property::atoms.net_wm_state_below;
+  otk::Property::set(_window, otk::Property::atoms.net_wm_state,
+                     otk::Property::atoms.atom, netstate, num);
 
   calcLayer();
 }
 
 
+void Client::changeAllowedActions(void)
+{
+  Atom actions[9];
+  int num = 0;
+
+  actions[num++] = otk::Property::atoms.net_wm_action_change_desktop;
+
+  if (_functions & Func_Shade)
+    actions[num++] = otk::Property::atoms.net_wm_action_shade;
+  if (_functions & Func_Close)
+    actions[num++] = otk::Property::atoms.net_wm_action_close;
+  if (_functions & Func_Move)
+    actions[num++] = otk::Property::atoms.net_wm_action_move;
+  if (_functions & Func_Iconify)
+    actions[num++] = otk::Property::atoms.net_wm_action_minimize;
+  if (_functions & Func_Resize)
+    actions[num++] = otk::Property::atoms.net_wm_action_resize;
+  if (_functions & Func_Fullscreen)
+    actions[num++] = otk::Property::atoms.net_wm_action_fullscreen;
+  if (_functions & Func_Maximize) {
+    actions[num++] = otk::Property::atoms.net_wm_action_maximize_horz;
+    actions[num++] = otk::Property::atoms.net_wm_action_maximize_vert;
+  }
+
+  otk::Property::set(_window, otk::Property::atoms.net_wm_allowed_actions,
+                     otk::Property::atoms.atom, actions, num);
+}
+
+
+void Client::applyStartupState()
+{
+  // these are in a carefully crafted order..
+  
+  if (_fullscreen) {
+    _fullscreen = false;
+    fullscreen(true);
+  }
+  if (_shaded) {
+    _shaded = false;
+    shade(true);
+  }
+  
+  if (_max_vert); // XXX: incomplete
+  if (_max_horz); // XXX: incomplete
+
+  if (_skip_taskbar); // nothing to do for this
+  if (_skip_pager);   // nothing to do for this
+  if (_modal);        // nothing to do for this
+  if (_above);        // nothing to do for this
+  if (_below);        // nothing to do for this
+}
+
+
 void Client::shade(bool shade)
 {
-  if (shade == _shaded) return; // already done
+  if (!(_functions & Func_Shade) || // can't
+      _shaded == shade) return;     // already done
 
   _wmstate = shade ? IconicState : NormalState;
   _shaded = shade;
@@ -1114,6 +1140,54 @@ void Client::shade(bool shade)
 }
 
 
+void Client::fullscreen(bool fs)
+{
+  static FunctionFlags saved_func;
+  static DecorationFlags saved_decor;
+  static otk::Rect saved_area;
+  static otk::Point saved_logical_size;
+
+  if (!(_functions & Func_Fullscreen) || // can't
+      _fullscreen == fs) return;         // already done
+
+  _fullscreen = fs;
+  changeState(); // change the state hints on the client
+
+  if (fs) {
+    // save the functions and remove them
+    saved_func = _functions;
+    _functions = _functions & (Func_Close | Func_Fullscreen | Func_Iconify);
+    // save the decorations and remove them
+    saved_decor = _decorations;
+    _decorations = 0;
+    // save the area and adjust it (we don't call internal resize here for
+    // constraints on the size, etc, we just make it fullscreen).
+    saved_area = _area;
+    const otk::ScreenInfo *info = otk::display->screenInfo(_screen);
+    _area.setRect(0, 0, info->width(), info->height());
+    saved_logical_size = _logical_size;
+    _logical_size.setPoint((info->width() - _base_size.x()) / _size_inc.x(),
+                           (info->height() - _base_size.y()) / _size_inc.y());
+  } else {
+    _functions = saved_func;
+    _decorations = saved_decor;
+    _area = saved_area;
+    _logical_size = saved_logical_size;
+  }
+  
+  changeAllowedActions();  // based on the new _functions
+  
+  frame->adjustSize();     // drop/replace the decor's and resize
+  frame->adjustPosition(); // get (back) in position!
+
+  // raise (back) into our stacking layer
+  openbox->screen(_screen)->raiseWindow(this);
+
+  // try focus us when we go into fullscreen mode
+  if (fs) focus();
+}
+
+
 bool Client::focus() const
 {
   // won't try focus if the client doesn't want it, or if the window isn't
@@ -1123,24 +1197,22 @@ bool Client::focus() const
   if (_focused) return true;
 
   if (_can_focus)
-    XSetInputFocus(otk::Display::display, _window,
+    XSetInputFocus(**otk::display, _window,
                    RevertToNone, CurrentTime);
 
   if (_focus_notify) {
     XEvent ce;
-    const otk::Property *property = openbox->property();
-    
     ce.xclient.type = ClientMessage;
-    ce.xclient.message_type =  property->atom(otk::Property::wm_protocols);
-    ce.xclient.display = otk::Display::display;
+    ce.xclient.message_type = otk::Property::atoms.wm_protocols;
+    ce.xclient.display = **otk::display;
     ce.xclient.window = _window;
     ce.xclient.format = 32;
-    ce.xclient.data.l[0] = property->atom(otk::Property::wm_take_focus);
+    ce.xclient.data.l[0] = otk::Property::atoms.wm_take_focus;
     ce.xclient.data.l[1] = openbox->lastTime();
     ce.xclient.data.l[2] = 0l;
     ce.xclient.data.l[3] = 0l;
     ce.xclient.data.l[4] = 0l;
-    XSendEvent(otk::Display::display, _window, False, NoEventMask, &ce);
+    XSendEvent(**otk::display, _window, False, NoEventMask, &ce);
   }
 
   return true;
@@ -1226,26 +1298,26 @@ void Client::configureRequestHandler(const XConfigureRequestEvent &e)
     if (e.value_mask & (CWX | CWY)) {
       int x = (e.value_mask & CWX) ? e.x : _area.x();
       int y = (e.value_mask & CWY) ? e.y : _area.y();
-      resize(corner, w, h, x, y);
+      internal_resize(corner, w, h, x, y);
     } else // if JUST resizing...
-      resize(corner, w, h);
+      internal_resize(corner, w, h);
   } else if (e.value_mask & (CWX | CWY)) { // if JUST moving...
     int x = (e.value_mask & CWX) ? e.x : _area.x();
     int y = (e.value_mask & CWY) ? e.y : _area.y();
-    move(x, y);
+    internal_move(x, y);
   }
 
   if (e.value_mask & CWStackMode) {
     switch (e.detail) {
     case Below:
     case BottomIf:
-      openbox->screen(_screen)->restack(false, this); // lower
+      openbox->screen(_screen)->lowerWindow(this);
       break;
 
     case Above:
     case TopIf:
     default:
-      openbox->screen(_screen)->restack(true, this); // raise
+      openbox->screen(_screen)->raiseWindow(this);
       break;
     }
   }
@@ -1308,7 +1380,7 @@ void Client::reparentHandler(const XReparentEvent &e)
   // server to deal with after we unmanage the window
   XEvent ev;
   ev.xreparent = e;
-  XPutBackEvent(otk::Display::display, &ev);
+  XPutBackEvent(**otk::display, &ev);
   
   // this deletes us etc
   openbox->screen(_screen)->unmanageWindow(this);