X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fscreen.cc;h=ff78e57268e6ab8d4db5ecbe5f03647a11b2ce5f;hb=1e47e17d08d72d181edc2bde598ad246055655ad;hp=763931f8b6fef1b177a05e4cfa55673dd2c4b228;hpb=a4d4aaec3f75fb26bae76e8a5f4957378deb2748;p=chaz%2Fopenbox

diff --git a/src/screen.cc b/src/screen.cc
index 763931f8..ff78e572 100644
--- a/src/screen.cc
+++ b/src/screen.cc
@@ -1,18 +1,18 @@
 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
 
-#ifdef HAVE_CONFIG_H
-# include "../config.h"
-#endif
-
-extern "C" {
-#ifdef    HAVE_STDIO_H
-#  include <stdio.h>
-#endif // HAVE_STDIO_H
+#include "config.h"
 
-#ifdef    HAVE_STRING_H
-#  include <string.h>
-#endif // HAVE_STRING_H
+#include "screen.hh"
+#include "client.hh"
+#include "openbox.hh"
+#include "frame.hh"
+#include "bindings.hh"
+#include "python.hh"
+#include "otk/display.hh"
+#include "otk/property.hh"
+#include "otk/util.hh"
 
+extern "C" {
 #ifdef    HAVE_UNISTD_H
 #  include <sys/types.h>
 #  include <unistd.h>
@@ -22,16 +22,10 @@ extern "C" {
 #define _(str) gettext(str)
 }
 
-#include "screen.hh"
-#include "client.hh"
-#include "openbox.hh"
-#include "frame.hh"
-#include "bindings.hh"
-#include "python.hh"
-#include "otk/display.hh"
-
 #include <vector>
 #include <algorithm>
+#include <cstdio>
+#include <cstring>
 
 static bool running;
 static int anotherWMRunning(Display *display, XErrorEvent *) {
@@ -46,102 +40,75 @@ namespace ob {
 
 
 Screen::Screen(int screen)
-  : WidgetBase(WidgetBase::Type_Root),
-    _number(screen)
+  : _number(screen),
+    _config(screen)
 {
-  assert(screen >= 0); assert(screen < ScreenCount(otk::Display::display));
-  _info = otk::Display::screenInfo(screen);
+  assert(screen >= 0); assert(screen < ScreenCount(**otk::display));
+  _info = otk::display->screenInfo(screen);
 
   ::running = false;
   XErrorHandler old = XSetErrorHandler(::anotherWMRunning);
-  XSelectInput(otk::Display::display, _info->rootWindow(),
+  XSelectInput(**otk::display, _info->rootWindow(),
                Screen::event_mask);
-  XSync(otk::Display::display, false);
+  XSync(**otk::display, false);
   XSetErrorHandler(old);
 
   _managed = !::running;
   if (! _managed) return; // was unable to manage the screen
 
+#ifdef DEBUG
   printf(_("Managing screen %d: visual 0x%lx, depth %d\n"),
          _number, XVisualIDFromVisual(_info->visual()), _info->depth());
+#endif
 
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::openbox_pid,
-                                     otk::Property::Atom_Cardinal,
-                                     (unsigned long) getpid());
+  otk::Property::set(_info->rootWindow(), otk::Property::atoms.openbox_pid,
+                     otk::Property::atoms.cardinal, (unsigned long) getpid());
 
   // set the mouse cursor for the root window (the default cursor)
-  XDefineCursor(otk::Display::display, _info->rootWindow(),
-                Openbox::instance->cursors().session);
-
-  // initialize the shit that is used for all drawing on the screen
-  _image_control = new otk::ImageControl(Openbox::instance->timerManager(),
-                                         _info, true);
-  _image_control->installRootColormap();
-  _root_cmap_installed = True;
-
-  // initialize the screen's style
-  _style.setImageControl(_image_control);
-  std::string stylepath;
-  python_get_string("theme", &stylepath);
-  otk::Configuration sconfig(false);
-  sconfig.setFile(otk::expandTilde(stylepath));
-  if (!sconfig.load()) {
-    sconfig.setFile(otk::expandTilde(DEFAULTSTYLE));
-    if (!sconfig.load()) {
-      printf(_("Unable to load default style: %s. Aborting.\n"), DEFAULTSTYLE);
-      ::exit(1);
-    }
-  }
-  _style.load(sconfig);
+  XDefineCursor(**otk::display, _info->rootWindow(),
+                openbox->cursors().session);
 
   // set up notification of netwm support
   changeSupportedAtoms();
 
   // Set the netwm properties for geometry
-  unsigned long geometry[] = { _info->width(),
-                               _info->height() };
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_desktop_geometry,
-                                     otk::Property::Atom_Cardinal,
-                                     geometry, 2);
-
-  // Set the net_desktop_names property
-  std::vector<std::string> names;
-  python_get_stringlist("desktop_names", &names);
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_desktop_names,
-                                     otk::Property::utf8,
-                                     names);
-  // the above set() will cause the updateDesktopNames to fire right away so
-  // we have a list of desktop names
-
-  if (!python_get_long("number_of_desktops", &_num_desktops))
-    _num_desktops = 1;
-  changeNumDesktops(_num_desktops); // set the hint
+  unsigned long geometry[] = { _info->size().width(),
+                               _info->size().height() };
+  otk::Property::set(_info->rootWindow(),
+                     otk::Property::atoms.net_desktop_geometry,
+                     otk::Property::atoms.cardinal, geometry, 2);
 
   _desktop = 0;
+
+  changeNumDesktops(1); // set the hint
   changeDesktop(0); // set the hint
 
+  // don't start in showing-desktop mode
+  _showing_desktop = false;
+  otk::Property::set(_info->rootWindow(),
+                     otk::Property::atoms.net_showing_desktop,
+                     otk::Property::atoms.cardinal, 0);
+
   // create the window which gets focus when no clients get it
   XSetWindowAttributes attr;
   attr.override_redirect = true;
-  _focuswindow = XCreateWindow(otk::Display::display, _info->rootWindow(),
+  _focuswindow = XCreateWindow(**otk::display, _info->rootWindow(),
                                -100, -100, 1, 1, 0, 0, InputOnly,
                                _info->visual(), CWOverrideRedirect, &attr);
-  XMapWindow(otk::Display::display, _focuswindow);
+  XMapRaised(**otk::display, _focuswindow);
   
   // these may be further updated if any pre-existing windows are found in
   // the manageExising() function
   changeClientList();  // initialize the client lists, which will be empty
-  calcArea();          // initialize the available working area
+
+  updateDesktopLayout();
 
   // register this class as the event handler for the root window
-  Openbox::instance->registerHandler(_info->rootWindow(), this);
+  openbox->registerHandler(_info->rootWindow(), this);
 
   // call the python Startup callbacks
-  EventData data(_number, 0, EventShutdown, 0);
-  Openbox::instance->bindings()->fireEvent(&data);
+  EventData data(_number, 0, EventAction::Startup, 0);
+  openbox->bindings()->fireEvent(&data);
 }
 
 
@@ -149,20 +116,18 @@ Screen::~Screen()
 {
   if (! _managed) return;
 
-  XSelectInput(otk::Display::display, _info->rootWindow(), NoEventMask);
+  XSelectInput(**otk::display, _info->rootWindow(), NoEventMask);
   
   // unmanage all windows
   while (!clients.empty())
     unmanageWindow(clients.front());
 
   // call the python Shutdown callbacks
-  EventData data(_number, 0, EventShutdown, 0);
-  Openbox::instance->bindings()->fireEvent(&data);
-
-  XDestroyWindow(otk::Display::display, _focuswindow);
-  XDestroyWindow(otk::Display::display, _supportwindow);
+  EventData data(_number, 0, EventAction::Shutdown, 0);
+  openbox->bindings()->fireEvent(&data);
 
-  delete _image_control;
+  XDestroyWindow(**otk::display, _focuswindow);
+  XDestroyWindow(**otk::display, _supportwindow);
 }
 
 
@@ -170,14 +135,14 @@ void Screen::manageExisting()
 {
   unsigned int i, j, nchild;
   Window r, p, *children;
-  XQueryTree(otk::Display::display, _info->rootWindow(), &r, &p,
+  XQueryTree(**otk::display, _info->rootWindow(), &r, &p,
              &children, &nchild);
 
   // preen the window list of all icon windows... for better dockapp support
   for (i = 0; i < nchild; i++) {
     if (children[i] == None) continue;
 
-    XWMHints *wmhints = XGetWMHints(otk::Display::display,
+    XWMHints *wmhints = XGetWMHints(**otk::display,
                                     children[i]);
 
     if (wmhints) {
@@ -201,7 +166,7 @@ void Screen::manageExisting()
       continue;
 
     XWindowAttributes attrib;
-    if (XGetWindowAttributes(otk::Display::display, children[i], &attrib)) {
+    if (XGetWindowAttributes(**otk::display, children[i], &attrib)) {
       if (attrib.override_redirect) continue;
 
       if (attrib.map_state != IsUnmapped) {
@@ -213,27 +178,108 @@ void Screen::manageExisting()
   XFree(children);
 }
 
+void Screen::updateDesktopLayout()
+{
+  //const unsigned long _NET_WM_ORIENTATION_HORZ = 0;
+  const unsigned long _NET_WM_ORIENTATION_VERT = 1;
+  //const unsigned long _NET_WM_TOPLEFT = 0;
+  const unsigned long _NET_WM_TOPRIGHT = 1;
+  const unsigned long _NET_WM_BOTTOMRIGHT = 2;
+  const unsigned long _NET_WM_BOTTOMLEFT = 3;
+  
+  // defaults
+  _layout.orientation = DesktopLayout::Horizontal;
+  _layout.start_corner = DesktopLayout::TopLeft;
+  _layout.rows = 1;
+  _layout.columns = _num_desktops;
+
+  unsigned long *data, num = 4;
+  if (otk::Property::get(_info->rootWindow(),
+                         otk::Property::atoms.net_desktop_layout,
+                         otk::Property::atoms.cardinal,
+                         &num, &data)) {
+    if (num == 4) {
+      if (data[0] == _NET_WM_ORIENTATION_VERT)
+        _layout.orientation = DesktopLayout::Vertical;
+      if (data[3] == _NET_WM_TOPRIGHT)
+        _layout.start_corner = DesktopLayout::TopRight;
+      else if (data[3] == _NET_WM_BOTTOMRIGHT)
+        _layout.start_corner = DesktopLayout::BottomRight;
+      else if (data[3] == _NET_WM_BOTTOMLEFT)
+        _layout.start_corner = DesktopLayout::BottomLeft;
+
+      // fill in a zero rows/columns
+      if (!(data[1] == 0 && data[2] == 0)) { // both 0's is bad data..
+        if (data[1] == 0) {
+          data[1] = (_num_desktops + _num_desktops % data[2]) / data[2];
+        } else if (data[2] == 0) {
+          data[2] = (_num_desktops + _num_desktops % data[1]) / data[1];
+        }
+        _layout.columns = data[1];
+        _layout.rows = data[2];
+      }
+
+      // bounds checking
+      if (_layout.orientation == DesktopLayout::Horizontal) {
+        if (_layout.rows > _num_desktops) _layout.rows = _num_desktops;
+        if (_layout.columns > (_num_desktops + _num_desktops % _layout.rows) /
+            _layout.rows)
+          _layout.columns = (_num_desktops + _num_desktops % _layout.rows) /
+            _layout.rows;
+      } else {
+        if (_layout.columns > _num_desktops) _layout.columns = _num_desktops;
+        if (_layout.rows > (_num_desktops + _num_desktops % _layout.columns) /
+            _layout.columns)
+          _layout.rows = (_num_desktops + _num_desktops % _layout.columns) /
+            _layout.columns;
+      }
+    }
+    delete [] data;
+  }
+}
 
-void Screen::updateStrut()
+void Screen::updateStruts()
 {
-  _strut.left = _strut.right = _strut.top = _strut.bottom = 0;
+  struct ApplyStrut {
+    void operator()(otk::Strut &self, const otk::Strut &other) {
+      self.left = std::max(self.left, other.left);
+      self.right = std::max(self.right, other.right);
+      self.top = std::max(self.top, other.top);
+      self.bottom = std::max(self.bottom, other.bottom);
+    }
+  } apply;
+
+  StrutList::iterator sit, send = _struts.end();
+  // reset them all
+  for (sit = _struts.begin(); sit != send; ++sit)
+    sit->left = sit->right = sit->top = sit->bottom = 0;
 
-  Client::List::iterator it, end = clients.end();
+  std::list<Client*>::const_iterator it, end = clients.end();
   for (it = clients.begin(); it != end; ++it) {
+    if ((*it)->iconic()) continue; // these dont count in the strut
+    
+    unsigned int desk = (*it)->desktop();
     const otk::Strut &s = (*it)->strut();
-    _strut.left = std::max(_strut.left, s.left);
-    _strut.right = std::max(_strut.right, s.right);
-    _strut.top = std::max(_strut.top, s.top);
-    _strut.bottom = std::max(_strut.bottom, s.bottom);
+
+    if (desk == 0xffffffff)
+      for (unsigned int i = 0, e = _struts.size(); i < e; ++i)
+        apply(_struts[i], s);
+    else if (desk < _struts.size())
+      apply(_struts[desk], s);
+    else
+      assert(false); // invalid desktop otherwise..
+    // apply to the 'all desktops' strut
+    apply(_struts.back(), s);
   }
-  calcArea();
+  changeWorkArea();
 }
 
 
-void Screen::calcArea()
+void Screen::changeWorkArea()
 {
-  otk::Rect old_area = _area;
-
+  unsigned long *dims = new unsigned long[4 * _num_desktops];
+  for (unsigned int i = 0; i < _num_desktops + 1; ++i) {
+    otk::Rect old_area = _area[i];
 /*
 #ifdef    XINERAMA
   // reset to the full areas
@@ -242,10 +288,12 @@ void Screen::calcArea()
 #endif // XINERAMA
 */
   
-  _area.setRect(_strut.left, _strut.top,
-                _info->width() - (_strut.left + _strut.right),
-                _info->height() - (_strut.top + _strut.bottom));
-
+    _area[i] = otk::Rect(_struts[i].left, _struts[i].top,
+                         _info->size().width() - (_struts[i].left +
+                                                  _struts[i].right),
+                         _info->size().height() - (_struts[i].top +
+                                                   _struts[i].bottom));
+    
 /*
 #ifdef    XINERAMA
   if (isXineramaActive()) {
@@ -268,107 +316,118 @@ void Screen::calcArea()
   }
 #endif // XINERAMA
 */
-  
-  if (old_area != _area)
-    // XXX: re-maximize windows
+    if (old_area != _area[i]) {
+      // the area has changed, adjust all the maximized windows
+      std::list<Client*>::iterator it, end = clients.end();
+      for (it = clients.begin(); it != end; ++it)
+        if (i < _num_desktops) {
+          if ((*it)->desktop() == i)
+            (*it)->remaximize();
+        } else {
+          // the 'all desktops' size
+          if ((*it)->desktop() == 0xffffffff)
+            (*it)->remaximize();
+        }
+    }
 
-  changeWorkArea();
+    // don't set these for the 'all desktops' area
+    if (i < _num_desktops) {
+      dims[(i * 4) + 0] = _area[i].x();
+      dims[(i * 4) + 1] = _area[i].y();
+      dims[(i * 4) + 2] = _area[i].width();
+      dims[(i * 4) + 3] = _area[i].height();
+    }
+  }
+  otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_workarea,
+                     otk::Property::atoms.cardinal, dims, 4 * _num_desktops);
+  delete [] dims;
 }
 
 
 void Screen::changeSupportedAtoms()
 {
   // create the netwm support window
-  _supportwindow = XCreateSimpleWindow(otk::Display::display,
+  _supportwindow = XCreateSimpleWindow(**otk::display,
                                        _info->rootWindow(),
                                        0, 0, 1, 1, 0, 0, 0);
 
   // set supporting window
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_supporting_wm_check,
-                                     otk::Property::Atom_Window,
-                                     _supportwindow);
+  otk::Property::set(_info->rootWindow(),
+                     otk::Property::atoms.net_supporting_wm_check,
+                     otk::Property::atoms.window, _supportwindow);
 
   //set properties on the supporting window
-  Openbox::instance->property()->set(_supportwindow,
-                                     otk::Property::net_wm_name,
-                                     otk::Property::utf8,
-                                     "Openbox");
-  Openbox::instance->property()->set(_supportwindow,
-                                     otk::Property::net_supporting_wm_check,
-                                     otk::Property::Atom_Window,
-                                     _supportwindow);
+  otk::Property::set(_supportwindow, otk::Property::atoms.net_wm_name,
+                     otk::Property::utf8, "Openbox");
+  otk::Property::set(_supportwindow,
+                     otk::Property::atoms.net_supporting_wm_check,
+                     otk::Property::atoms.window, _supportwindow);
 
   
   Atom supported[] = {
-      otk::Property::net_current_desktop,
-      otk::Property::net_number_of_desktops,
-      otk::Property::net_desktop_geometry,
-      otk::Property::net_desktop_viewport,
-      otk::Property::net_active_window,
-      otk::Property::net_workarea,
-      otk::Property::net_client_list,
-      otk::Property::net_client_list_stacking,
-      otk::Property::net_desktop_names,
-      otk::Property::net_close_window,
-      otk::Property::net_wm_name,
-      otk::Property::net_wm_visible_name,
-      otk::Property::net_wm_icon_name,
-      otk::Property::net_wm_visible_icon_name,
-/*
-      otk::Property::net_wm_desktop,
-*/
-      otk::Property::net_wm_strut,
-      otk::Property::net_wm_window_type,
-      otk::Property::net_wm_window_type_desktop,
-      otk::Property::net_wm_window_type_dock,
-      otk::Property::net_wm_window_type_toolbar,
-      otk::Property::net_wm_window_type_menu,
-      otk::Property::net_wm_window_type_utility,
-      otk::Property::net_wm_window_type_splash,
-      otk::Property::net_wm_window_type_dialog,
-      otk::Property::net_wm_window_type_normal,
+    otk::Property::atoms.net_current_desktop,
+    otk::Property::atoms.net_number_of_desktops,
+    otk::Property::atoms.net_desktop_geometry,
+    otk::Property::atoms.net_desktop_viewport,
+    otk::Property::atoms.net_active_window,
+    otk::Property::atoms.net_workarea,
+    otk::Property::atoms.net_client_list,
+    otk::Property::atoms.net_client_list_stacking,
+    otk::Property::atoms.net_desktop_names,
+    otk::Property::atoms.net_close_window,
+    otk::Property::atoms.net_desktop_layout,
+    otk::Property::atoms.net_showing_desktop,
+    otk::Property::atoms.net_wm_name,
+    otk::Property::atoms.net_wm_visible_name,
+    otk::Property::atoms.net_wm_icon_name,
+    otk::Property::atoms.net_wm_visible_icon_name,
+    otk::Property::atoms.net_wm_desktop,
+    otk::Property::atoms.net_wm_strut,
+    otk::Property::atoms.net_wm_window_type,
+    otk::Property::atoms.net_wm_window_type_desktop,
+    otk::Property::atoms.net_wm_window_type_dock,
+    otk::Property::atoms.net_wm_window_type_toolbar,
+    otk::Property::atoms.net_wm_window_type_menu,
+    otk::Property::atoms.net_wm_window_type_utility,
+    otk::Property::atoms.net_wm_window_type_splash,
+    otk::Property::atoms.net_wm_window_type_dialog,
+    otk::Property::atoms.net_wm_window_type_normal,
 /*
-      otk::Property::net_wm_moveresize,
-      otk::Property::net_wm_moveresize_size_topleft,
-      otk::Property::net_wm_moveresize_size_topright,
-      otk::Property::net_wm_moveresize_size_bottomleft,
-      otk::Property::net_wm_moveresize_size_bottomright,
-      otk::Property::net_wm_moveresize_move,
+    otk::Property::atoms.net_wm_moveresize,
+    otk::Property::atoms.net_wm_moveresize_size_topleft,
+    otk::Property::atoms.net_wm_moveresize_size_topright,
+    otk::Property::atoms.net_wm_moveresize_size_bottomleft,
+    otk::Property::atoms.net_wm_moveresize_size_bottomright,
+    otk::Property::atoms.net_wm_moveresize_move,
 */
-/*
-      otk::Property::net_wm_allowed_actions,
-      otk::Property::net_wm_action_move,
-      otk::Property::net_wm_action_resize,
-      otk::Property::net_wm_action_shade,
-      otk::Property::net_wm_action_maximize_horz,
-      otk::Property::net_wm_action_maximize_vert,
-      otk::Property::net_wm_action_change_desktop,
-      otk::Property::net_wm_action_close,
-*/
-      otk::Property::net_wm_state,
-      otk::Property::net_wm_state_modal,
-      otk::Property::net_wm_state_maximized_vert,
-      otk::Property::net_wm_state_maximized_horz,
-      otk::Property::net_wm_state_shaded,
-      otk::Property::net_wm_state_skip_taskbar,
-      otk::Property::net_wm_state_skip_pager,
-      otk::Property::net_wm_state_hidden,
-      otk::Property::net_wm_state_fullscreen,
-      otk::Property::net_wm_state_above,
-      otk::Property::net_wm_state_below,
-    };
+    otk::Property::atoms.net_wm_allowed_actions,
+    otk::Property::atoms.net_wm_action_move,
+    otk::Property::atoms.net_wm_action_resize,
+    otk::Property::atoms.net_wm_action_minimize,
+    otk::Property::atoms.net_wm_action_shade,
+/*    otk::Property::atoms.net_wm_action_stick,*/
+    otk::Property::atoms.net_wm_action_maximize_horz,
+    otk::Property::atoms.net_wm_action_maximize_vert,
+    otk::Property::atoms.net_wm_action_fullscreen,
+    otk::Property::atoms.net_wm_action_change_desktop,
+    otk::Property::atoms.net_wm_action_close,
+
+    otk::Property::atoms.net_wm_state,
+    otk::Property::atoms.net_wm_state_modal,
+    otk::Property::atoms.net_wm_state_maximized_vert,
+    otk::Property::atoms.net_wm_state_maximized_horz,
+    otk::Property::atoms.net_wm_state_shaded,
+    otk::Property::atoms.net_wm_state_skip_taskbar,
+    otk::Property::atoms.net_wm_state_skip_pager,
+    otk::Property::atoms.net_wm_state_hidden,
+    otk::Property::atoms.net_wm_state_fullscreen,
+    otk::Property::atoms.net_wm_state_above,
+    otk::Property::atoms.net_wm_state_below,
+  };
   const int num_supported = sizeof(supported)/sizeof(Atom);
 
-  // convert to the atom values
-  for (int i = 0; i < num_supported; ++i)
-    supported[i] =
-      Openbox::instance->property()->atom((otk::Property::Atoms)supported[i]);
-  
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_supported,
-                                     otk::Property::Atom_Atom,
-                                     supported, num_supported);
+  otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_supported,
+                     otk::Property::atoms.atom, supported, num_supported);
 }
 
 
@@ -383,17 +442,15 @@ void Screen::changeClientList()
     
     windows = new Window[size];
     win_it = windows;
-    Client::List::const_iterator it = clients.begin();
-    const Client::List::const_iterator end = clients.end();
+    std::list<Client*>::const_iterator it = clients.begin();
+    const std::list<Client*>::const_iterator end = clients.end();
     for (; it != end; ++it, ++win_it)
       *win_it = (*it)->window();
   } else
     windows = (Window*) 0;
 
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_client_list,
-                                     otk::Property::Atom_Window,
-                                     windows, size);
+  otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_client_list,
+                     otk::Property::atoms.window, windows, size);
 
   if (size)
     delete [] windows;
@@ -410,61 +467,61 @@ void Screen::changeStackingList()
   assert(size == clients.size()); // just making sure.. :)
 
   
-  // create an array of the window ids
+  // create an array of the window ids (from bottom to top, reverse order!)
   if (size > 0) {
     Window *win_it;
     
     windows = new Window[size];
     win_it = windows;
-    Client::List::const_iterator it = _stacking.begin();
-    const Client::List::const_iterator end = _stacking.end();
+    std::list<Client*>::const_reverse_iterator it = _stacking.rbegin();
+    const std::list<Client*>::const_reverse_iterator end = _stacking.rend();
     for (; it != end; ++it, ++win_it)
       *win_it = (*it)->window();
   } else
     windows = (Window*) 0;
 
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_client_list_stacking,
-                                     otk::Property::Atom_Window,
-                                     windows, size);
+  otk::Property::set(_info->rootWindow(),
+                     otk::Property::atoms.net_client_list_stacking,
+                     otk::Property::atoms.window, windows, size);
 
   if (size)
     delete [] windows;
 }
 
 
-void Screen::changeWorkArea() {
-  unsigned long *dims = new unsigned long[4 * _num_desktops];
-  for (long i = 0; i < _num_desktops; ++i) {
-    // XXX: this could be different for each workspace
-    dims[(i * 4) + 0] = _area.x();
-    dims[(i * 4) + 1] = _area.y();
-    dims[(i * 4) + 2] = _area.width();
-    dims[(i * 4) + 3] = _area.height();
-  }
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_workarea,
-                                     otk::Property::Atom_Cardinal,
-                                     dims, 4 * _num_desktops);
-  delete [] dims;
-}
-
-
 void Screen::manageWindow(Window window)
 {
   Client *client = 0;
   XWMHints *wmhint;
   XSetWindowAttributes attrib_set;
+  XEvent e;
+  XWindowAttributes attrib;
 
-  otk::Display::grab();
+  otk::display->grab();
 
+  // check if it has already been unmapped by the time we started mapping
+  // the grab does a sync so we don't have to here
+  if (XCheckTypedWindowEvent(**otk::display, window, DestroyNotify, &e) ||
+      XCheckTypedWindowEvent(**otk::display, window, UnmapNotify, &e)) {
+    XPutBackEvent(**otk::display, &e);
+    
+    otk::display->ungrab();
+    return; // don't manage it
+  }
+  
+  if (!XGetWindowAttributes(**otk::display, window, &attrib) ||
+      attrib.override_redirect) {
+    otk::display->ungrab();
+    return; // don't manage it
+  }
+  
   // is the window a docking app
-  if ((wmhint = XGetWMHints(otk::Display::display, window))) {
+  if ((wmhint = XGetWMHints(**otk::display, window))) {
     if ((wmhint->flags & StateHint) &&
         wmhint->initial_state == WithdrawnState) {
       //slit->addClient(w); // XXX: make dock apps work!
-      otk::Display::ungrab();
 
+      otk::display->ungrab();
       XFree(wmhint);
       return;
     }
@@ -474,76 +531,76 @@ void Screen::manageWindow(Window window)
   // choose the events we want to receive on the CLIENT window
   attrib_set.event_mask = Client::event_mask;
   attrib_set.do_not_propagate_mask = Client::no_propagate_mask;
-  XChangeWindowAttributes(otk::Display::display, window,
+  XChangeWindowAttributes(**otk::display, window,
                           CWEventMask|CWDontPropagate, &attrib_set);
 
   // create the Client class, which gets all of the hints on the window
   client = new Client(_number, window);
   // register for events
-  Openbox::instance->registerHandler(window, client);
+  openbox->registerHandler(window, client);
   // add to the wm's map
-  Openbox::instance->addClient(window, client);
+  openbox->addClient(window, client);
 
   // we dont want a border on the client
   client->toggleClientBorder(false);
   
   // specify that if we exit, the window should not be destroyed and should be
   // reparented back to root automatically
-  XChangeSaveSet(otk::Display::display, window, SetModeInsert);
-
-  if (!(Openbox::instance->state() == Openbox::State_Starting ||
-        client->positionRequested())) {
-    // position the window intelligenty .. hopefully :)
-    // call the python PLACEWINDOW binding
-    EventData data(_number, client, EventPlaceWindow, 0);
-    Openbox::instance->bindings()->fireEvent(&data);
-  }
+  XChangeSaveSet(**otk::display, window, SetModeInsert);
 
   // create the decoration frame for the client window
-  client->frame = new Frame(client, &_style);
+  client->frame = new Frame(client);
+  // register the plate for events (map req's)
+  // this involves removing itself from the handler list first, since it is
+  // auto added to the list, being a widget. we won't get any events on the
+  // plate except for events for the client (SubstructureRedirectMask)
+  openbox->clearHandler(client->frame->plate());
+  openbox->registerHandler(client->frame->plate(), client);
 
   // add to the wm's map
-  Openbox::instance->addClient(client->frame->window(), client);
-  Openbox::instance->addClient(client->frame->plate(), client);
-  Openbox::instance->addClient(client->frame->titlebar(), client);
-  Openbox::instance->addClient(client->frame->label(), client);
-  Openbox::instance->addClient(client->frame->button_max(), client);
-  Openbox::instance->addClient(client->frame->button_iconify(), client);
-  Openbox::instance->addClient(client->frame->button_stick(), client);
-  Openbox::instance->addClient(client->frame->button_close(), client);
-  Openbox::instance->addClient(client->frame->handle(), client);
-  Openbox::instance->addClient(client->frame->grip_left(), client);
-  Openbox::instance->addClient(client->frame->grip_right(), client);
+  Window *w = client->frame->allWindows();
+  for (unsigned int i = 0; w[i]; ++i)
+    openbox->addClient(w[i], client);
+  delete [] w;
 
   // reparent the client to the frame
   client->frame->grabClient();
 
-  // if on the current desktop.. (or all desktops)
-  if (client->desktop() == _desktop ||
-      client->desktop() == (signed)0xffffffff) {
-    client->frame->show();
+  if (openbox->state() != Openbox::State_Starting) {
+    // position the window intelligenty .. hopefully :)
+    // call the python PLACEWINDOW binding
+    EventData data(_number, client, EventAction::PlaceWindow, 0);
+    openbox->bindings()->fireEvent(&data);
   }
- 
-  // XXX: handle any requested states such as maximized
 
-  otk::Display::ungrab();
+  EventData ddata(_number, client, EventAction::DisplayingWindow, 0);
+  openbox->bindings()->fireEvent(&ddata);
+
+  client->showhide();
+
+  client->applyStartupState();
+
+  otk::display->ungrab();
 
   // add to the screen's list
   clients.push_back(client);
+  // once the client is in the list, update our strut to include the new
+  // client's (it is good that this happens after window placement!)
+  updateStruts();
   // this puts into the stacking order, then raises it
   _stacking.push_back(client);
-  restack(true, client);
+  raiseWindow(client);
   // update the root properties
   changeClientList();
 
-  Openbox::instance->bindings()->grabButtons(true, client);
+  openbox->bindings()->grabButtons(true, client);
 
-  // call the python NEWWINDOW binding
-  EventData data(_number, client, EventNewWindow, 0);
-  Openbox::instance->bindings()->fireEvent(&data);
+  EventData ndata(_number, client, EventAction::NewWindow, 0);
+  openbox->bindings()->fireEvent(&ndata);
 
 #ifdef DEBUG
-  printf("Managed window 0x%lx\n", window);
+  printf("Managed window 0x%lx frame 0x%lx\n",
+         window, client->frame->window());
 #endif
 }
 
@@ -553,32 +610,25 @@ void Screen::unmanageWindow(Client *client)
   Frame *frame = client->frame;
 
   // call the python CLOSEWINDOW binding 
-  EventData data(_number, client, EventCloseWindow, 0);
-  Openbox::instance->bindings()->fireEvent(&data);
+  EventData data(_number, client, EventAction::CloseWindow, 0);
+  openbox->bindings()->fireEvent(&data);
 
-  Openbox::instance->bindings()->grabButtons(false, client);
+  openbox->bindings()->grabButtons(false, client);
 
   // remove from the wm's map
-  Openbox::instance->removeClient(client->window());
-  Openbox::instance->removeClient(frame->window());
-  Openbox::instance->removeClient(frame->plate());
-  Openbox::instance->removeClient(frame->titlebar());
-  Openbox::instance->removeClient(frame->label());
-  Openbox::instance->removeClient(frame->button_max());
-  Openbox::instance->removeClient(frame->button_iconify());
-  Openbox::instance->removeClient(frame->button_stick());
-  Openbox::instance->removeClient(frame->button_close());
-  Openbox::instance->removeClient(frame->handle());
-  Openbox::instance->removeClient(frame->grip_left());
-  Openbox::instance->removeClient(frame->grip_right());
+  openbox->removeClient(client->window());
+  Window *w = frame->allWindows();
+  for (unsigned int i = 0; w[i]; ++i)
+    openbox->addClient(w[i], client);
+  delete [] w;
   // unregister for handling events
-  Openbox::instance->clearHandler(client->window());
+  openbox->clearHandler(client->window());
   
   // remove the window from our save set
-  XChangeSaveSet(otk::Display::display, client->window(), SetModeDelete);
+  XChangeSaveSet(**otk::display, client->window(), SetModeDelete);
 
   // we dont want events no more
-  XSelectInput(otk::Display::display, client->window(), NoEventMask);
+  XSelectInput(**otk::display, client->window(), NoEventMask);
 
   frame->hide();
 
@@ -588,6 +638,9 @@ void Screen::unmanageWindow(Client *client)
   // reparent the window out of the frame
   frame->releaseClient();
 
+#ifdef DEBUG
+  Window framewin = client->frame->window();
+#endif
   delete client->frame;
   client->frame = 0;
 
@@ -597,11 +650,18 @@ void Screen::unmanageWindow(Client *client)
   // remove from the screen's list
   clients.remove(client);
 
+  // once the client is out of the list, update our strut to remove it's
+  // influence
+  updateStruts();
+
+  // unset modal before dropping our focus
+  client->_modal = false;
+  
   // unfocus the client (calls the focus callbacks)
-  client->unfocus();
+  if (client->focused()) client->unfocus();
 
 #ifdef DEBUG
-  printf("Unmanaged window 0x%lx\n", client->window());
+  printf("Unmanaged window 0x%lx frame 0x%lx\n", client->window(), framewin);
 #endif
   
   delete client;
@@ -610,140 +670,240 @@ void Screen::unmanageWindow(Client *client)
   changeClientList();
 }
 
-void Screen::restack(bool raise, Client *client)
+void Screen::lowerWindow(Client *client)
+{
+  Window wins[2];  // only ever restack 2 windows.
+
+  assert(!_stacking.empty()); // this would be bad
+
+  std::list<Client*>::iterator it = --_stacking.end();
+  const std::list<Client*>::iterator end = _stacking.begin();
+
+  if (client->modal() && client->transientFor()) {
+    // don't let a modal window lower below its transient_for
+    it = std::find(_stacking.begin(), _stacking.end(), client->transientFor());
+    assert(it != _stacking.end());
+
+    wins[0] = (it == _stacking.begin() ? _focuswindow :
+               ((*(--std::list<Client*>::const_iterator(it)))->
+                frame->window()));
+    wins[1] = client->frame->window();
+    if (wins[0] == wins[1]) return; // already right above the window
+
+    _stacking.remove(client);
+    _stacking.insert(it, client);
+  } else {
+    for (; it != end && (*it)->layer() < client->layer(); --it);
+    if (*it == client) return;          // already the bottom, return
+
+    wins[0] = (*it)->frame->window();
+    wins[1] = client->frame->window();
+
+    _stacking.remove(client);
+    _stacking.insert(++it, client);
+  }
+
+  XRestackWindows(**otk::display, wins, 2);
+  changeStackingList();
+}
+
+void Screen::raiseWindow(Client *client)
 {
-  const int layer = client->layer();
-  std::vector<Window> wins;
+  Window wins[2];  // only ever restack 2 windows.
 
+  assert(!_stacking.empty()); // this would be bad
+
+  Client *m = client->findModalChild();
+  // if we have a modal child, raise it instead, we'll go along tho later
+  if (m) raiseWindow(m);
+  
+  // remove the client before looking so we can't run into ourselves
   _stacking.remove(client);
+  
+  std::list<Client*>::iterator it = _stacking.begin();
+  const std::list<Client*>::iterator end = _stacking.end();
 
   // the stacking list is from highest to lowest
-  
-  Client::List::iterator it = _stacking.begin(), end = _stacking.end();
-  // insert the windows above this window
-  for (; it != end; ++it) {
-    if ((*it)->layer() < layer || (raise && (*it)->layer() == layer))
-      break;
-    wins.push_back((*it)->frame->window());
-  }
-  // insert our client
-  wins.push_back(client->frame->window());
+  for (; it != end && ((*it)->layer() > client->layer() || m == *it); ++it);
+
+  /*
+    if our new position is the top, we want to stack under the _focuswindow
+    otherwise, we want to stack under the previous window in the stack.
+  */
+  wins[0] = (it == _stacking.begin() ? _focuswindow :
+             ((*(--std::list<Client*>::const_iterator(it)))->frame->window()));
+  wins[1] = client->frame->window();
+
   _stacking.insert(it, client);
-  // insert the remaining below this window
-  for (; it != end; ++it)
-    wins.push_back((*it)->frame->window());
 
-  XRestackWindows(otk::Display::display, &wins[0], wins.size());
-  changeStackingList();
+  XRestackWindows(**otk::display, wins, 2);
+
+  changeStackingList(); 
 }
 
-void Screen::changeDesktop(long desktop)
+void Screen::changeDesktop(unsigned int desktop)
 {
-  if (!(desktop >= 0 && desktop < _num_desktops)) return;
+  if (desktop >= _num_desktops) return;
 
-  printf("Moving to desktop %ld\n", desktop);
+  printf("Moving to desktop %u\n", desktop);
   
-  long old = _desktop;
+  unsigned int old = _desktop;
   
   _desktop = desktop;
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_current_desktop,
-                                     otk::Property::Atom_Cardinal,
-                                     _desktop);
+  otk::Property::set(_info->rootWindow(),
+                     otk::Property::atoms.net_current_desktop,
+                     otk::Property::atoms.cardinal, _desktop);
 
   if (old == _desktop) return;
 
-  Client::List::iterator it, end = clients.end();
-  for (it = clients.begin(); it != end; ++it) {
-    if ((*it)->desktop() == old) {
-      (*it)->frame->hide();
-    } else if ((*it)->desktop() == _desktop) {
-      (*it)->frame->show();
-    }
-  }
+  std::list<Client*>::iterator it, end = clients.end();
+  for (it = clients.begin(); it != end; ++it)
+    (*it)->showhide();
 
   // force the callbacks to fire
-  if (!Openbox::instance->focusedClient())
-    Openbox::instance->setFocusedClient(0);
+  if (!openbox->focusedClient())
+    openbox->setFocusedClient(0);
 }
 
-void Screen::changeNumDesktops(long num)
+void Screen::changeNumDesktops(unsigned int num)
 {
   assert(num > 0);
   
   if (!(num > 0)) return;
 
-  // XXX: move windows on desktops that will no longer exist!
-  
+  // move windows on desktops that will no longer exist!
+  std::list<Client*>::iterator it, end = clients.end();
+  for (it = clients.begin(); it != end; ++it) {
+    unsigned int d = (*it)->desktop();
+    if (d >= num && d != 0xffffffff) {
+      XEvent ce;
+      ce.xclient.type = ClientMessage;
+      ce.xclient.message_type = otk::Property::atoms.net_wm_desktop;
+      ce.xclient.display = **otk::display;
+      ce.xclient.window = (*it)->window();
+      ce.xclient.format = 32;
+      ce.xclient.data.l[0] = num - 1;
+      XSendEvent(**otk::display, _info->rootWindow(), false,
+                 SubstructureNotifyMask | SubstructureRedirectMask, &ce);
+    }
+  }
+
   _num_desktops = num;
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_number_of_desktops,
-                                     otk::Property::Atom_Cardinal,
-                                     _num_desktops);
+  otk::Property::set(_info->rootWindow(),
+                     otk::Property::atoms.net_number_of_desktops,
+                     otk::Property::atoms.cardinal, _num_desktops);
 
   // set the viewport hint
   unsigned long *viewport = new unsigned long[_num_desktops * 2];
   memset(viewport, 0, sizeof(unsigned long) * _num_desktops * 2);
-  Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::Property::net_desktop_viewport,
-                                     otk::Property::Atom_Cardinal,
-                                     viewport, _num_desktops * 2);
+  otk::Property::set(_info->rootWindow(),
+                     otk::Property::atoms.net_desktop_viewport,
+                     otk::Property::atoms.cardinal,
+                     viewport, _num_desktops * 2);
   delete [] viewport;
 
-  // update the work area hint
-  changeWorkArea();
+  // change our struts/area to match
+  _area.resize(_num_desktops + 1);
+  _struts.resize(_num_desktops + 1);
+  updateStruts();
+
+  // the number of rows/columns will differ
+  updateDesktopLayout();
+
+  // may be some unnamed desktops that we need to fill in with names
+  updateDesktopNames();
+
+  // change our desktop if we're on one that no longer exists!
+  if (_desktop >= _num_desktops)
+    changeDesktop(_num_desktops - 1);
 }
 
 
 void Screen::updateDesktopNames()
 {
-  const otk::Property *property = Openbox::instance->property();
-
-  unsigned long num = (unsigned) -1;
+  unsigned long num;
   
-  if (!property->get(_info->rootWindow(),
-                     otk::Property::net_desktop_names,
-                     otk::Property::utf8, &num, &_desktop_names))
+  if (!otk::Property::get(_info->rootWindow(),
+                          otk::Property::atoms.net_desktop_names,
+                          otk::Property::utf8, &num, &_desktop_names))
     _desktop_names.clear();
-  while ((long)_desktop_names.size() < _num_desktops)
+  while (_desktop_names.size() < _num_desktops)
     _desktop_names.push_back("Unnamed");
 }
 
 
-void Screen::setDesktopName(long i, const std::string &name)
+const otk::Rect& Screen::area(unsigned int desktop) const {
+  assert(desktop < _num_desktops || desktop == 0xffffffff);
+  if (desktop < _num_desktops)
+    return _area[desktop];
+  else
+    return _area[_num_desktops];
+}
+
+void Screen::installColormap(bool install) const
 {
-  assert(i >= 0);
+  if (install)
+    XInstallColormap(**otk::display, _info->colormap());
+  else
+    XUninstallColormap(**otk::display, _info->colormap());
+}
 
-  if (i >= _num_desktops) return;
+void Screen::showDesktop(bool show)
+{
+  if (show == _showing_desktop) return; // no change
 
-  const otk::Property *property = Openbox::instance->property();
+  // save the window focus, and restore it when leaving the show-desktop mode
+  static Window saved_focus = 0;
+  if (show) {
+    Client *c = openbox->focusedClient();
+    if (c) saved_focus = c->window();
+  }
   
-  otk::Property::StringVect newnames = _desktop_names;
-  newnames[i] = name;
-  property->set(_info->rootWindow(), otk::Property::net_desktop_names,
-                otk::Property::utf8, newnames);
-}
+  _showing_desktop = show;
 
+  std::list<Client*>::iterator it, end = clients.end();
+  for (it = clients.begin(); it != end; ++it) {
+    if ((*it)->type() == Client::Type_Desktop) {
+      if (show)
+        (*it)->focus();
+    } else
+      (*it)->showhide();
+  }
+
+  if (!show) {
+    Client *f = openbox->focusedClient();
+    if (!f || f->type() == Client::Type_Desktop) {
+      Client *c = openbox->findClient(saved_focus);
+      if (c) c->focus();
+    }
+  }
+
+  otk::Property::set(_info->rootWindow(),
+                     otk::Property::atoms.net_showing_desktop,
+                     otk::Property::atoms.cardinal,
+                     show ? 1 : 0);
+}
 
 void Screen::propertyHandler(const XPropertyEvent &e)
 {
   otk::EventHandler::propertyHandler(e);
 
-  const otk::Property *property = Openbox::instance->property();
-
   // compress changes to a single property into a single change
   XEvent ce;
-  while (XCheckTypedEvent(otk::Display::display, e.type, &ce)) {
+  while (XCheckTypedWindowEvent(**otk::display, _info->rootWindow(),
+                                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;
     }
   }
 
-  if (e.atom == property->atom(otk::Property::net_desktop_names)) 
+  if (e.atom == otk::Property::atoms.net_desktop_names)
     updateDesktopNames();
+  else if (e.atom == otk::Property::atoms.net_desktop_layout)
+    updateDesktopLayout();
 }
 
 
@@ -753,15 +913,13 @@ void Screen::clientMessageHandler(const XClientMessageEvent &e)
 
   if (e.format != 32) return;
 
-  const otk::Property *property = Openbox::instance->property();
-
-  if (e.message_type == property->atom(otk::Property::net_current_desktop)) {
+  if (e.message_type == otk::Property::atoms.net_current_desktop) {
     changeDesktop(e.data.l[0]);
-  } else if (e.message_type ==
-             property->atom(otk::Property::net_number_of_desktops)) {
+  } else if (e.message_type == otk::Property::atoms.net_number_of_desktops) {
     changeNumDesktops(e.data.l[0]);
+  } else if (e.message_type == otk::Property::atoms.net_showing_desktop) {
+    showDesktop(e.data.l[0] != 0);
   }
-  // XXX: so many client messages to handle here! ..or not.. they go to clients
 }
 
 
@@ -773,31 +931,16 @@ void Screen::mapRequestHandler(const XMapRequestEvent &e)
   printf("MapRequest for 0x%lx\n", e.window);
 #endif // DEBUG
 
-  /*
-    MapRequest events come here even after the window exists instead of going
-    right to the client window, because of how they are sent and their struct
-    layout.
-  */
-  Client *c = Openbox::instance->findClient(e.window);
-
+  Client *c = openbox->findClient(e.window);
   if (c) {
-    // send a net_active_window message
-    XEvent ce;
-    ce.xclient.type = ClientMessage;
-    ce.xclient.message_type =
-      Openbox::instance->property()->atom(otk::Property::net_active_window);
-    ce.xclient.display = otk::Display::display;
-    ce.xclient.window = c->window();
-    ce.xclient.format = 32;
-    ce.xclient.data.l[0] = 0l;
-    ce.xclient.data.l[1] = 0l;
-    ce.xclient.data.l[2] = 0l;
-    ce.xclient.data.l[3] = 0l;
-    ce.xclient.data.l[4] = 0l;
-    XSendEvent(otk::Display::display, _info->rootWindow(), false,
-               SubstructureRedirectMask | SubstructureNotifyMask,
-               &ce);
-  } else
+#ifdef DEBUG
+    printf("DEBUG: MAP REQUEST CAUGHT IN SCREEN. IGNORED.\n");
+#endif
+  } else {
+    if (_showing_desktop)
+      showDesktop(false); // leave showing-the-desktop mode
     manageWindow(e.window);
+  }
 }
+
 }