X-Git-Url: https://git.brokenzipper.com/gitweb?a=blobdiff_plain;f=src%2FWindow.cc;h=680943e214d5eb3c3e8453b8043f4573ad086064;hb=87e63d53af67d5ea98f55a27007663d4c9c8fc6c;hp=243bfa485d9c3b063f34f367e3f793218a9a30ca;hpb=bc3268b6f9f86e6aebe0d06ce174b2d603d09c1e;p=chaz%2Fopenbox

diff --git a/src/Window.cc b/src/Window.cc
index 243bfa48..680943e2 100644
--- a/src/Window.cc
+++ b/src/Window.cc
@@ -40,7 +40,7 @@ extern "C" {
 #endif // DEBUG
 
 #ifdef HAVE_STDLIB_H
-   #include <stdlib.h>
+#  include <stdlib.h>
 #endif // HAVE_STDLIB_H
 }
 
@@ -62,11 +62,6 @@ extern "C" {
 using std::string;
 using std::abs;
 
-// change this to change what modifier keys openbox uses for mouse bindings
-// for example: Mod1Mask | ControlMask
-//          or: ControlMask| ShiftMask
-const unsigned int ModMask = Mod1Mask;
-
 /*
  * Initializes the class with default values/the window's set initial values.
  */
@@ -126,28 +121,28 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
 
   blackbox_attrib.workspace = window_number = BSENTINEL;
 
-  blackbox_attrib.flags = blackbox_attrib.attrib = blackbox_attrib.stack
-    = blackbox_attrib.decoration = 0l;
+  blackbox_attrib.flags = blackbox_attrib.attrib = blackbox_attrib.stack = 0l;
+  blackbox_attrib.decoration = DecorNormal;
   blackbox_attrib.premax_x = blackbox_attrib.premax_y = 0;
   blackbox_attrib.premax_w = blackbox_attrib.premax_h = 0;
 
   frame.border_w = 1;
   frame.window = frame.plate = frame.title = frame.handle = None;
-  frame.close_button = frame.iconify_button = frame.maximize_button = None;
+  frame.close_button = frame.iconify_button = frame.maximize_button =
+    frame.stick_button = None;
   frame.right_grip = frame.left_grip = None;
 
   frame.ulabel_pixel = frame.flabel_pixel = frame.utitle_pixel =
   frame.ftitle_pixel = frame.uhandle_pixel = frame.fhandle_pixel =
-    frame.ubutton_pixel = frame.fbutton_pixel = frame.pbutton_pixel =
-    frame.uborder_pixel = frame.fborder_pixel = frame.ugrip_pixel =
-    frame.fgrip_pixel = 0;
+    frame.ubutton_pixel = frame.fbutton_pixel = frame.uborder_pixel =
+    frame.fborder_pixel = frame.ugrip_pixel = frame.fgrip_pixel = 0;
   frame.utitle = frame.ftitle = frame.uhandle = frame.fhandle = None;
   frame.ulabel = frame.flabel = frame.ubutton = frame.fbutton = None;
-  frame.pbutton = frame.ugrip = frame.fgrip = None;
+  frame.ugrip = frame.fgrip = None;
 
-  decorations = Decor_Titlebar | Decor_Border | Decor_Handle |
-                Decor_Iconify | Decor_Maximize;
   functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
+  mwm_decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
+                    Decor_Iconify | Decor_Maximize;
 
   client.normal_hint_flags = 0;
   client.window_group = None;
@@ -158,7 +153,7 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
   windowmenu = 0;
 
   /*
-    get the initial size and location of client window (relative to the
+    set the initial size and location of client window (relative to the
     _root window_). This position is the reference point used with the
     window's gravity to find the window's initial position.
   */
@@ -173,10 +168,8 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
   // get size, aspect, minimum/maximum size and other hints set by the
   // client
 
-  if (! getBlackboxHints()) {
-    getMWMHints();
+  if (! getBlackboxHints())
     getNetWMHints();
-  }
 
   getWMProtocols();
   getWMHints();
@@ -186,7 +179,7 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
 
   blackbox->saveWindowSearch(frame.window, this);
   
-  frame.plate = createChildWindow(frame.window);
+  frame.plate = createChildWindow(frame.window, ExposureMask);
   blackbox->saveWindowSearch(frame.plate, this);
 
   // determine if this is a transient window
@@ -194,52 +187,51 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
 
   // determine the window's type, so we can decide its decorations and
   // functionality, or if we should not manage it at all
-  getWindowType();
-
-  // adjust the window decorations/behavior based on the window type
-
-  switch (window_type) {
-  case Type_Desktop:
-  case Type_Dock:
-  case Type_Menu:
-    blackbox_attrib.workspace = 0;  // we do need to belong to a workspace
-    flags.stuck = True;             // we show up on all workspaces
-  case Type_Splash:
-    // none of these windows are decorated or manipulated by the window manager
-    decorations = 0;
-    functions = 0;
-    break;
+  if (getWindowType()) {
+    // adjust the window decorations/behavior based on the window type
+    switch (window_type) {
+    case Type_Desktop:
+    case Type_Dock:
+    case Type_Menu:
+      blackbox_attrib.workspace = 0;  // we do need to belong to a workspace
+      flags.stuck = True;             // we show up on all workspaces
+    case Type_Splash:
+      // none of these windows are manipulated by the window manager
+      functions = 0;
+      break;
 
-  case Type_Toolbar:
-  case Type_Utility:
-    // these windows get less decorations and functionality
-    decorations &= ~(Decor_Maximize | Decor_Handle | Decor_Iconify |
-                     Decor_Border);
-    functions &= ~(Func_Maximize | Func_Resize | Func_Iconify);
-    break;
+    case Type_Toolbar:
+    case Type_Utility:
+      // these windows get less functionality
+      functions &= ~(Func_Maximize | Func_Resize | Func_Iconify);
+      break;
 
-  case Type_Dialog:
-    // dialogs cannot be maximized, and don't display a handle
-    decorations &= ~(Decor_Maximize | Decor_Handle);
-    functions &= ~Func_Maximize;
-    break;
+    case Type_Dialog:
+      // dialogs cannot be maximized
+      functions &= ~Func_Maximize;
+      break;
 
-  case Type_Normal:
-    // normal windows retain all of the possible decorations and functionality
-    break;
+    case Type_Normal:
+      // normal windows retain all of the possible decorations and
+      // functionality
+      break;
+    }
+  } else {
+    getMWMHints();
   }
   
-  setAllowedActions();
-
   // further adjeust the window's decorations/behavior based on window sizes
   if ((client.normal_hint_flags & PMinSize) &&
       (client.normal_hint_flags & PMaxSize) &&
       client.max_width <= client.min_width &&
       client.max_height <= client.min_height) {
-    decorations &= ~(Decor_Maximize | Decor_Handle);
     functions &= ~(Func_Resize | Func_Maximize);
   }
   
+  setAllowedActions();
+
+  setupDecor();
+  
   if (decorations & Decor_Titlebar)
     createTitlebar();
 
@@ -409,6 +401,66 @@ BlackboxWindow::~BlackboxWindow(void) {
 }
 
 
+void BlackboxWindow::enableDecor(bool enable) {
+  blackbox_attrib.flags |= AttribDecoration;
+  blackbox_attrib.decoration = enable ? DecorNormal : DecorNone;
+  setupDecor();
+    
+  // we can not be shaded if we lack a titlebar
+  if (! (decorations & Decor_Titlebar) && flags.shaded)
+    shade();
+    
+  if (flags.visible && frame.window) {
+    XMapSubwindows(blackbox->getXDisplay(), frame.window);
+    XMapWindow(blackbox->getXDisplay(), frame.window);
+  }
+
+  reconfigure();
+  setState(current_state);
+}
+
+
+void BlackboxWindow::setupDecor() {
+  if (blackbox_attrib.decoration != DecorNone) {
+    // start with everything on
+    decorations = Decor_Close |
+      (mwm_decorations & Decor_Titlebar ? Decor_Titlebar : 0) |
+      (mwm_decorations & Decor_Border ? Decor_Border : 0) |
+      (mwm_decorations & Decor_Handle ? Decor_Handle : 0) |
+      (mwm_decorations & Decor_Iconify ? Decor_Iconify : 0) |
+      (mwm_decorations & Decor_Maximize ? Decor_Maximize : 0);
+
+    if (! (functions & Func_Close)) decorations &= ~Decor_Close;
+    if (! (functions & Func_Maximize)) decorations &= ~Decor_Maximize;
+    if (! (functions & Func_Iconify)) decorations &= ~Decor_Iconify;
+    if (! (functions & Func_Resize)) decorations &= ~Decor_Handle;
+
+    switch (window_type) {
+    case Type_Desktop:
+    case Type_Dock:
+    case Type_Menu:
+    case Type_Splash:
+      // none of these windows are decorated by the window manager at all
+      decorations = 0;
+      break;
+
+    case Type_Toolbar:
+    case Type_Utility:
+      decorations &= ~(Decor_Border);
+      break;
+
+    case Type_Dialog:
+      decorations &= ~Decor_Handle;
+      break;
+
+    case Type_Normal:
+      break;
+    }
+  } else {
+    decorations = 0;
+  }
+}
+
 /*
  * Creates a new top level window, with a given location, size, and border
  * width.
@@ -422,9 +474,13 @@ Window BlackboxWindow::createToplevelWindow(void) {
   attrib_create.background_pixmap = None;
   attrib_create.colormap = screen->getColormap();
   attrib_create.override_redirect = True;
-  attrib_create.event_mask = ButtonPressMask | ButtonReleaseMask |
-                             ButtonMotionMask |
-                             EnterWindowMask | LeaveWindowMask;
+  attrib_create.event_mask = EnterWindowMask | LeaveWindowMask |
+                             ButtonPress;
+  /*
+    We catch button presses because other wise they get passed down to the
+    root window, which will then cause root menus to show when you click the
+    window's frame.
+  */
 
   return XCreateWindow(blackbox->getXDisplay(), screen->getRootWindow(),
                        0, 0, 1, 1, frame.border_w, screen->getDepth(),
@@ -437,14 +493,15 @@ Window BlackboxWindow::createToplevelWindow(void) {
  * Creates a child window, and optionally associates a given cursor with
  * the new window.
  */
-Window BlackboxWindow::createChildWindow(Window parent, Cursor cursor) {
+Window BlackboxWindow::createChildWindow(Window parent,
+                                         unsigned long event_mask,
+                                         Cursor cursor) {
   XSetWindowAttributes attrib_create;
   unsigned long create_mask = CWBackPixmap | CWBorderPixel |
                               CWEventMask;
 
   attrib_create.background_pixmap = None;
-  attrib_create.event_mask = ButtonPressMask | ButtonReleaseMask |
-                             ButtonMotionMask | ExposureMask;
+  attrib_create.event_mask = event_mask;
 
   if (cursor) {
     create_mask |= CWCursor;
@@ -513,11 +570,50 @@ void BlackboxWindow::decorate(void) {
   if (! frame.ubutton)
     frame.ubutton_pixel = texture->color().pixel();
 
-  texture = &(screen->getWindowStyle()->b_pressed);
-  frame.pbutton = texture->render(frame.button_w, frame.button_w,
-                                  frame.pbutton);
-  if (! frame.pbutton)
-    frame.pbutton_pixel = texture->color().pixel();
+  unsigned char needsPressed = 0;
+
+  texture = &(screen->getWindowStyle()->b_pressed_focus);
+  
+  if (texture->texture() != BTexture::NoTexture) {
+    frame.pfbutton = texture->render(frame.button_w, frame.button_w,
+                                     frame.pfbutton);
+    if (! frame.pfbutton)
+      frame.pfbutton_pixel = texture->color().pixel();
+  } else {
+    needsPressed = 0x1;
+  }
+
+  texture = &(screen->getWindowStyle()->b_pressed_unfocus);
+  
+  if (texture->texture() != BTexture::NoTexture) {
+    frame.pubutton = texture->render(frame.button_w, frame.button_w,
+                                     frame.pubutton);
+    if (! frame.pubutton)
+      frame.pubutton = texture->color().pixel();
+  } else {
+    needsPressed |= 0x2;
+  }
+
+  // if we either pressed unfocused, or pressed focused were undefined,
+  // make them inherit from the old resource. It's a hack for sure, but
+  // it allows for some backwards and forwards compatibility.
+  if (needsPressed) {
+    texture = &(screen->getWindowStyle()->b_pressed);
+    
+    if (needsPressed & 0x1) {
+      frame.pfbutton = texture->render(frame.button_w, frame.button_w,
+                                       frame.pfbutton);
+      if (! frame.pfbutton)
+        frame.pfbutton_pixel = texture->color().pixel();
+    }
+    if (needsPressed & 0x2) {
+      frame.pubutton = texture->render(frame.button_w, frame.button_w,
+                                       frame.pubutton);
+      if (! frame.pubutton)
+        frame.pubutton = texture->color().pixel();
+    }
+    
+  }
 
   if (decorations & Decor_Titlebar) {
     texture = &(screen->getWindowStyle()->t_focus);
@@ -539,13 +635,8 @@ void BlackboxWindow::decorate(void) {
   }
 
   if (decorations & Decor_Border) {
-    frame.fborder_pixel = screen->getWindowStyle()->f_focus.pixel();
-    frame.uborder_pixel = screen->getWindowStyle()->f_unfocus.pixel();
-    blackbox_attrib.flags |= AttribDecoration;
-    blackbox_attrib.decoration = DecorNormal;
-  } else {
-    blackbox_attrib.flags |= AttribDecoration;
-    blackbox_attrib.decoration = DecorNone;
+    frame.fborder_pixel = screen->getWindowStyle()->f_focus.color().pixel();
+    frame.uborder_pixel = screen->getWindowStyle()->f_unfocus.color().pixel();
   }
 
   if (decorations & Decor_Handle) {
@@ -600,15 +691,23 @@ void BlackboxWindow::decorateLabel(void) {
 
 
 void BlackboxWindow::createHandle(void) {
-  frame.handle = createChildWindow(frame.window);
+  frame.handle = createChildWindow(frame.window,
+                                   ButtonPressMask | ButtonReleaseMask |
+                                   ButtonMotionMask | ExposureMask);
   blackbox->saveWindowSearch(frame.handle, this);
 
   frame.left_grip =
-    createChildWindow(frame.handle, blackbox->getLowerLeftAngleCursor());
+    createChildWindow(frame.handle,
+                      ButtonPressMask | ButtonReleaseMask |
+                      ButtonMotionMask | ExposureMask,
+                      blackbox->getLowerLeftAngleCursor());
   blackbox->saveWindowSearch(frame.left_grip, this);
 
   frame.right_grip =
-    createChildWindow(frame.handle, blackbox->getLowerRightAngleCursor());
+    createChildWindow(frame.handle,
+                      ButtonPressMask | ButtonReleaseMask |
+                      ButtonMotionMask | ExposureMask,
+                      blackbox->getLowerRightAngleCursor());
   blackbox->saveWindowSearch(frame.right_grip, this);
 }
 
@@ -640,8 +739,12 @@ void BlackboxWindow::destroyHandle(void) {
 
 
 void BlackboxWindow::createTitlebar(void) {
-  frame.title = createChildWindow(frame.window);
-  frame.label = createChildWindow(frame.title);
+  frame.title = createChildWindow(frame.window,
+                                  ButtonPressMask | ButtonReleaseMask |
+                                  ButtonMotionMask | ExposureMask);
+  frame.label = createChildWindow(frame.title,
+                                  ButtonPressMask | ButtonReleaseMask |
+                                  ButtonMotionMask | ExposureMask);
   blackbox->saveWindowSearch(frame.title, this);
   blackbox->saveWindowSearch(frame.label, this);
 
@@ -661,6 +764,9 @@ void BlackboxWindow::destroyTitlebar(void) {
   if (frame.maximize_button)
     destroyMaximizeButton();
 
+  if (frame.stick_button)
+    destroyStickyButton();
+
   if (frame.ftitle)
     screen->getImageControl()->removeImage(frame.ftitle);
 
@@ -679,9 +785,6 @@ void BlackboxWindow::destroyTitlebar(void) {
   if (frame.ubutton)
     screen->getImageControl()->removeImage(frame.ubutton);
 
-  if (frame.pbutton)
-    screen->getImageControl()->removeImage(frame.pbutton);
-
   blackbox->removeWindowSearch(frame.title);
   blackbox->removeWindowSearch(frame.label);
 
@@ -693,7 +796,10 @@ void BlackboxWindow::destroyTitlebar(void) {
 
 void BlackboxWindow::createCloseButton(void) {
   if (frame.title != None) {
-    frame.close_button = createChildWindow(frame.title);
+    frame.close_button = createChildWindow(frame.title,
+                                           ButtonPressMask |
+                                           ButtonReleaseMask |
+                                           ButtonMotionMask | ExposureMask);
     blackbox->saveWindowSearch(frame.close_button, this);
   }
 }
@@ -708,7 +814,10 @@ void BlackboxWindow::destroyCloseButton(void) {
 
 void BlackboxWindow::createIconifyButton(void) {
   if (frame.title != None) {
-    frame.iconify_button = createChildWindow(frame.title);
+    frame.iconify_button = createChildWindow(frame.title,
+                                             ButtonPressMask |
+                                             ButtonReleaseMask |
+                                             ButtonMotionMask | ExposureMask);
     blackbox->saveWindowSearch(frame.iconify_button, this);
   }
 }
@@ -723,7 +832,10 @@ void BlackboxWindow::destroyIconifyButton(void) {
 
 void BlackboxWindow::createMaximizeButton(void) {
   if (frame.title != None) {
-    frame.maximize_button = createChildWindow(frame.title);
+    frame.maximize_button = createChildWindow(frame.title,
+                                              ButtonPressMask |
+                                              ButtonReleaseMask |
+                                              ButtonMotionMask | ExposureMask);
     blackbox->saveWindowSearch(frame.maximize_button, this);
   }
 }
@@ -735,13 +847,28 @@ void BlackboxWindow::destroyMaximizeButton(void) {
   frame.maximize_button = None;
 }
 
+void BlackboxWindow::createStickyButton(void) {
+  if (frame.title != None) {
+    frame.stick_button = createChildWindow(frame.title,
+                                           ButtonPressMask |
+                                           ButtonReleaseMask |
+                                           ButtonMotionMask | ExposureMask);
+    blackbox->saveWindowSearch(frame.stick_button, this);
+  }
+}
+
+void BlackboxWindow::destroyStickyButton(void) {
+  blackbox->removeWindowSearch(frame.stick_button);
+  XDestroyWindow(blackbox->getXDisplay(), frame.stick_button);
+  frame.stick_button = None;
+}
 
 void BlackboxWindow::positionButtons(bool redecorate_label) {
   string layout = blackbox->getTitlebarLayout();
   string parsed;
 
-  bool hasclose, hasiconify, hasmaximize, haslabel;
-  hasclose = hasiconify = hasmaximize = haslabel = false;
+  bool hasclose, hasiconify, hasmaximize, haslabel, hasstick;
+  hasclose = hasiconify = hasmaximize = haslabel = hasstick = false;
 
   string::const_iterator it, end;
   for (it = layout.begin(), end = layout.end(); it != end; ++it) {
@@ -758,6 +885,12 @@ void BlackboxWindow::positionButtons(bool redecorate_label) {
         parsed += *it;
       }
       break;
+    case 'S':
+      if (!hasstick) {
+        hasstick = true;
+        parsed += *it;
+      }
+      break;
     case 'M':
       if (! hasmaximize && (decorations & Decor_Maximize)) {
         hasmaximize = true;
@@ -769,14 +902,18 @@ void BlackboxWindow::positionButtons(bool redecorate_label) {
         haslabel = true;
         parsed += *it;
       }
+      break;
     }
   }
+  
   if (! hasclose && frame.close_button)
     destroyCloseButton();
   if (! hasiconify && frame.iconify_button)
     destroyIconifyButton();
   if (! hasmaximize && frame.maximize_button)
     destroyMaximizeButton();
+  if (! hasstick && frame.stick_button)
+    destroyStickyButton();
   if (! haslabel)
     parsed += 'L';      // require that the label be in the layout
 
@@ -802,6 +939,12 @@ void BlackboxWindow::positionButtons(bool redecorate_label) {
                         frame.button_w, frame.button_w);
       x += frame.button_w + bsep;
       break;
+    case 'S':
+      if (! frame.stick_button) createStickyButton();
+      XMoveResizeWindow(blackbox->getXDisplay(), frame.stick_button, x, by,
+                        frame.button_w, frame.button_w);
+      x += frame.button_w + bsep;
+      break;
     case 'M':
       if (! frame.maximize_button) createMaximizeButton();
       XMoveResizeWindow(blackbox->getXDisplay(), frame.maximize_button, x, by,
@@ -841,6 +984,8 @@ void BlackboxWindow::reconfigure(void) {
 
 
 void BlackboxWindow::grabButtons(void) {
+  mod_mask = blackbox->getMouseModMask();
+
   if (! screen->isSloppyFocus() || screen->doClickRaise())
     // grab button 1 for changing focus/raising
     blackbox->grabButton(Button1, 0, frame.plate, True, ButtonPressMask,
@@ -848,28 +993,27 @@ void BlackboxWindow::grabButtons(void) {
                          screen->allowScrollLock());
   
   if (functions & Func_Move)
-    blackbox->grabButton(Button1, ModMask, frame.window, True,
+    blackbox->grabButton(Button1, mod_mask, frame.window, True,
                          ButtonReleaseMask | ButtonMotionMask, GrabModeAsync,
                          GrabModeAsync, frame.window, None,
                          screen->allowScrollLock());
   if (functions & Func_Resize)
-    blackbox->grabButton(Button3, ModMask, frame.window, True,
+    blackbox->grabButton(Button3, mod_mask, frame.window, True,
                          ButtonReleaseMask | ButtonMotionMask, GrabModeAsync,
                          GrabModeAsync, frame.window, None,
                          screen->allowScrollLock());
   // alt+middle lowers the window
-  blackbox->grabButton(Button2, ModMask, frame.window, True,
+  blackbox->grabButton(Button2, mod_mask, frame.window, True,
                        ButtonReleaseMask, GrabModeAsync, GrabModeAsync,
-                       frame.window, None,
-                       screen->allowScrollLock());
+                       frame.window, None, screen->allowScrollLock());
 }
 
 
 void BlackboxWindow::ungrabButtons(void) {
   blackbox->ungrabButton(Button1, 0, frame.plate);
-  blackbox->ungrabButton(Button1, ModMask, frame.window);
-  blackbox->ungrabButton(Button2, ModMask, frame.window);
-  blackbox->ungrabButton(Button3, ModMask, frame.window);
+  blackbox->ungrabButton(Button1, mod_mask, frame.window);
+  blackbox->ungrabButton(Button2, mod_mask, frame.window);
+  blackbox->ungrabButton(Button3, mod_mask, frame.window);
 }
 
 
@@ -956,37 +1100,51 @@ void BlackboxWindow::updateStrut(void) {
 }
 
 
-void BlackboxWindow::getWindowType(void) {
-  unsigned long val;
+bool BlackboxWindow::getWindowType(void) {
+  window_type = (WindowType) -1;
+
+  unsigned long *val;
+  unsigned long num = (unsigned) -1;
   if (xatom->getValue(client.window, XAtom::net_wm_window_type, XAtom::atom,
-                      val)) {
-    if (val == xatom->getAtom(XAtom::net_wm_window_type_desktop))
-      window_type = Type_Desktop;
-    else if (val == xatom->getAtom(XAtom::net_wm_window_type_dock))
-      window_type = Type_Dock;
-    else if (val == xatom->getAtom(XAtom::net_wm_window_type_toolbar))
-      window_type = Type_Toolbar;
-    else if (val == xatom->getAtom(XAtom::net_wm_window_type_menu))
-      window_type = Type_Menu;
-    else if (val == xatom->getAtom(XAtom::net_wm_window_type_utility))
-      window_type = Type_Utility;
-    else if (val == xatom->getAtom(XAtom::net_wm_window_type_splash))
-      window_type = Type_Splash;
-    else if (val == xatom->getAtom(XAtom::net_wm_window_type_dialog))
+                        num, &val)) {
+    for (unsigned long i = 0; i < num; ++i) {
+      if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_desktop))
+        window_type = Type_Desktop;
+      else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_dock))
+        window_type = Type_Dock;
+      else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_toolbar))
+        window_type = Type_Toolbar;
+      else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_menu))
+        window_type = Type_Menu;
+      else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_utility))
+        window_type = Type_Utility;
+      else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_splash))
+        window_type = Type_Splash;
+      else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_dialog))
+        window_type = Type_Dialog;
+      else if (val[i] == xatom->getAtom(XAtom::net_wm_window_type_normal))
+        window_type = Type_Normal;
+      else if (val[i] ==
+               xatom->getAtom(XAtom::kde_net_wm_window_type_override))
+        mwm_decorations = 0; // prevent this window from getting any decor
+    }
+    delete val;
+  }
+    
+  if (window_type == (WindowType) -1) {
+    /*
+     * 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.
+     */
+    if (isTransient())
       window_type = Type_Dialog;
-    else //if (val[0] == xatom->getAtom(XAtom::net_wm_window_type_normal))
+    else
       window_type = Type_Normal;
-    return;
-  }
 
-  /*
-   * 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.
-   */
-  if (isTransient())
-    window_type = Type_Dialog;
+    return False;
+  }
 
-  window_type = Type_Normal;
+  return True;
 }
 
 
@@ -1007,6 +1165,14 @@ void BlackboxWindow::getWMName(void) {
   client.title = i18n(WindowSet, WindowUnnamed, "Unnamed");
   xatom->setValue(client.window, XAtom::net_wm_visible_name, XAtom::utf8,
                   client.title);
+
+#ifdef DEBUG_WITH_ID
+  // the 16 is the 8 chars of the debug text plus the number
+  char *tmp = new char[client.title.length() + 16];
+  sprintf(tmp, "%s; id: 0x%lx", client.title.c_str(), client.window);
+  client.title = tmp;
+  delete tmp;
+#endif
 }
 
 
@@ -1127,14 +1293,11 @@ void BlackboxWindow::getWMNormalHints(void) {
     client.max_aspect_x = client.max_aspect_y = 1;
 #endif
 
-  /*
-    use the full screen, not the strut modified size. otherwise when the
-    availableArea changes max_width/height will be incorrect and lead to odd
-    rendering bugs.
-  */
-  const Rect& screen_area = screen->getRect();
-  client.max_width = screen_area.width();
-  client.max_height = screen_area.height();
+  // don't limit the size of a window, the default max width is the biggest
+  // possible
+  client.max_width = (unsigned) -1;
+  client.max_height = (unsigned) -1;
+
 
   if (! XGetWMNormalHints(blackbox->getXDisplay(), client.window,
                           &sizehint, &icccm_mask))
@@ -1258,21 +1421,21 @@ void BlackboxWindow::getMWMHints(void) {
 
   if (mwm_hint->flags & MwmHintsDecorations) {
     if (mwm_hint->decorations & MwmDecorAll) {
-      decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
-                    Decor_Iconify | Decor_Maximize | Decor_Close;
+      mwm_decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
+                        Decor_Iconify | Decor_Maximize;
     } else {
-      decorations = 0;
+      mwm_decorations = 0;
 
       if (mwm_hint->decorations & MwmDecorBorder)
-        decorations |= Decor_Border;
+        mwm_decorations |= Decor_Border;
       if (mwm_hint->decorations & MwmDecorHandle)
-        decorations |= Decor_Handle;
+        mwm_decorations |= Decor_Handle;
       if (mwm_hint->decorations & MwmDecorTitle)
-        decorations |= Decor_Titlebar;
+        mwm_decorations |= Decor_Titlebar;
       if (mwm_hint->decorations & MwmDecorIconify)
-        decorations |= Decor_Iconify;
+        mwm_decorations |= Decor_Iconify;
       if (mwm_hint->decorations & MwmDecorMaximize)
-        decorations |= Decor_Maximize;
+        mwm_decorations |= Decor_Maximize;
     }
   }
 
@@ -1345,31 +1508,16 @@ bool BlackboxWindow::getBlackboxHints(void) {
   if (blackbox_hint->flags & AttribDecoration) {
     switch (blackbox_hint->decoration) {
     case DecorNone:
-      decorations = 0;
+      blackbox_attrib.decoration = DecorNone;
       break;
 
     case DecorTiny:
-      decorations |= Decor_Titlebar | Decor_Iconify;
-      decorations &= ~(Decor_Border | Decor_Handle | Decor_Maximize);
-      functions &= ~(Func_Resize | Func_Maximize);
-
-      break;
-
     case DecorTool:
-      decorations |= Decor_Titlebar;
-      decorations &= ~(Decor_Iconify | Decor_Border | Decor_Handle);
-      functions &= ~(Func_Resize | Func_Maximize | Func_Iconify);
-
-      break;
-
     case DecorNormal:
     default:
-      decorations |= Decor_Titlebar | Decor_Border | Decor_Handle |
-                     Decor_Iconify | Decor_Maximize;
+      // blackbox_attrib.decoration defaults to DecorNormal
       break;
     }
-
-    reconfigure();
   }
   
   delete [] blackbox_hint;
@@ -1386,7 +1534,7 @@ void BlackboxWindow::getTransientInfo(void) {
   }
 
   // we have no transient_for until we find a new one
-  client.transient_for = 0;
+  client.transient_for = (BlackboxWindow *) 0;
 
   Window trans_for;
   if (! XGetTransientForHint(blackbox->getXDisplay(), client.window,
@@ -1558,6 +1706,14 @@ void BlackboxWindow::configureShape(void) {
                           ShapeBounding, 0, 0, xrect, num,
                           ShapeUnion, Unsorted);
 }
+
+
+void BlackboxWindow::clearShape(void) {
+  XShapeCombineMask(blackbox->getXDisplay(), frame.window, ShapeBounding,
+                    frame.margin.left - frame.border_w,
+                    frame.margin.top - frame.border_w,
+                    None, ShapeSet);
+}
 #endif // SHAPE
 
 
@@ -1621,7 +1777,7 @@ bool BlackboxWindow::setInputFocus(void) {
 
 
 void BlackboxWindow::iconify(void) {
-  if (flags.iconic) return;
+  if (flags.iconic || ! (functions & Func_Iconify)) return;
 
   // We don't need to worry about resizing because resizing always grabs the X
   // server. This should only ever happen if using opaque moving.
@@ -1725,6 +1881,8 @@ void BlackboxWindow::deiconify(bool reassoc, bool raise) {
 
 
 void BlackboxWindow::close(void) {
+  if (! (functions & Func_Close)) return;
+
   XEvent ce;
   ce.xclient.type = ClientMessage;
   ce.xclient.message_type =  xatom->getAtom(XAtom::wm_protocols);
@@ -1770,6 +1928,8 @@ void BlackboxWindow::withdraw(void) {
 
 
 void BlackboxWindow::maximize(unsigned int button) {
+  if (! (functions & Func_Maximize)) return;
+
   // We don't need to worry about resizing because resizing always grabs the X
   // server. This should only ever happen if using opaque moving.
   if (flags.moving)
@@ -1992,6 +2152,9 @@ void BlackboxWindow::stick(void) {
 
     setState(current_state);
   }
+
+  redrawAllButtons();
+  
   // go up the chain
   if (isTransient() && client.transient_for != (BlackboxWindow *) ~0ul &&
       client.transient_for->isStuck() != flags.stuck)
@@ -2278,51 +2441,19 @@ void BlackboxWindow::restoreAttributes(void) {
   if (net->flags & AttribDecoration) {
     switch (net->decoration) {
     case DecorNone:
-      decorations = 0;
-
+      enableDecor(False);
       break;
 
+    /* since tools only let you toggle this anyways, we'll just make that all
+       it supports for now.
+     */
     default:
     case DecorNormal:
-      decorations |= Decor_Titlebar | Decor_Handle | Decor_Border |
-        Decor_Iconify | Decor_Maximize;
-
-      break;
-
     case DecorTiny:
-      decorations |= Decor_Titlebar | Decor_Iconify;
-      decorations &= ~(Decor_Border | Decor_Handle | Decor_Maximize);
-
-      break;
-
     case DecorTool:
-      decorations |= Decor_Titlebar;
-      decorations &= ~(Decor_Iconify | Decor_Border | Decor_Handle);
-
+      enableDecor(True);
       break;
     }
-
-    // sanity check the new decor
-    if (! (functions & Func_Resize) || isTransient())
-      decorations &= ~(Decor_Maximize | Decor_Handle);
-    if (! (functions & Func_Maximize))
-      decorations &= ~Decor_Maximize;
-
-    if (decorations & Decor_Titlebar) {
-      if (functions & Func_Close)   // close button is controlled by function
-        decorations |= Decor_Close; // not decor type
-    } else { 
-      if (flags.shaded) // we can not be shaded if we lack a titlebar
-        shade();
-    }
-
-    if (flags.visible && frame.window) {
-      XMapSubwindows(blackbox->getXDisplay(), frame.window);
-      XMapWindow(blackbox->getXDisplay(), frame.window);
-    }
-
-    reconfigure();
-    setState(current_state);
   }
 
   // with the state set it will then be the map event's job to read the
@@ -2489,114 +2620,189 @@ void BlackboxWindow::redrawAllButtons(void) const {
   if (frame.iconify_button) redrawIconifyButton(False);
   if (frame.maximize_button) redrawMaximizeButton(flags.maximized);
   if (frame.close_button) redrawCloseButton(False);
+  if (frame.stick_button) redrawStickyButton(flags.stuck);
 }
 
 
-void BlackboxWindow::redrawIconifyButton(bool pressed) const {
-  if (! pressed) {
+void BlackboxWindow::redrawButton(bool pressed, Window win,
+                                  Pixmap fppix, unsigned long fppixel,
+                                  Pixmap uppix, unsigned long uppixel,
+                                  Pixmap fpix, unsigned long fpixel,
+                                  Pixmap upix, unsigned long upixel) const {
+  Pixmap p;
+  unsigned long pix;
+  
+  if (pressed) {
     if (flags.focused) {
-      if (frame.fbutton)
-        XSetWindowBackgroundPixmap(blackbox->getXDisplay(),
-                                   frame.iconify_button, frame.fbutton);
-      else
-        XSetWindowBackground(blackbox->getXDisplay(),
-                             frame.iconify_button, frame.fbutton_pixel);
+      p = fppix;
+      pix = fppixel;
     } else {
-      if (frame.ubutton)
-        XSetWindowBackgroundPixmap(blackbox->getXDisplay(),
-                                   frame.iconify_button, frame.ubutton);
-      else
-        XSetWindowBackground(blackbox->getXDisplay(), frame.iconify_button,
-                             frame.ubutton_pixel);
+      p = uppix;
+      pix = uppixel;
     }
   } else {
-    if (frame.pbutton)
-      XSetWindowBackgroundPixmap(blackbox->getXDisplay(),
-                                 frame.iconify_button, frame.pbutton);
-    else
-      XSetWindowBackground(blackbox->getXDisplay(),
-                           frame.iconify_button, frame.pbutton_pixel);
+    if (flags.focused) {
+      p = fpix;
+      pix = fpixel;
+    } else {
+      p = upix;
+      pix = upixel;
+    }
   }
-  XClearWindow(blackbox->getXDisplay(), frame.iconify_button);
+  
+  if (p)
+    XSetWindowBackgroundPixmap(blackbox->getXDisplay(), win, p);
+  else
+    XSetWindowBackground(blackbox->getXDisplay(), win, pix);
 
-  BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
-           screen->getWindowStyle()->b_pic_unfocus);
-  XDrawRectangle(blackbox->getXDisplay(), frame.iconify_button, pen.gc(),
-                 2, (frame.button_w - 5), (frame.button_w - 5), 2);
 }
 
+void BlackboxWindow::redrawIconifyButton(bool pressed) const {
+  redrawButton(pressed, frame.iconify_button, 
+               frame.pfbutton, frame.pfbutton_pixel,
+               frame.pubutton, frame.pubutton_pixel,
+               frame.fbutton, frame.fbutton_pixel,
+               frame.ubutton, frame.ubutton_pixel);
 
-void BlackboxWindow::redrawMaximizeButton(bool pressed) const {
-  if (! pressed) {
-    if (flags.focused) {
-      if (frame.fbutton)
-        XSetWindowBackgroundPixmap(blackbox->getXDisplay(),
-                                   frame.maximize_button, frame.fbutton);
-      else
-        XSetWindowBackground(blackbox->getXDisplay(), frame.maximize_button,
-                             frame.fbutton_pixel);
-    } else {
-      if (frame.ubutton)
-        XSetWindowBackgroundPixmap(blackbox->getXDisplay(),
-                                   frame.maximize_button, frame.ubutton);
-      else
-        XSetWindowBackground(blackbox->getXDisplay(), frame.maximize_button,
-                             frame.ubutton_pixel);
-    }
+  XClearWindow(blackbox->getXDisplay(), frame.iconify_button);
+  BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
+             screen->getWindowStyle()->b_pic_unfocus);
+
+#ifdef    BITMAPBUTTONS
+  PixmapMask pm = screen->getWindowStyle()->icon_button;
+  
+  if (screen->getWindowStyle()->icon_button.mask != None) {
+    XSetClipMask(blackbox->getXDisplay(), pen.gc(), pm.mask);
+    XSetClipOrigin(blackbox->getXDisplay(), pen.gc(),
+                   (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
+
+    XFillRectangle(blackbox->getXDisplay(), frame.iconify_button, pen.gc(),
+                   (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
+                   (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
+
+    XSetClipMask(blackbox->getXDisplay(), pen.gc(), None);
+    XSetClipOrigin(blackbox->getXDisplay(), pen.gc(), 0, 0);
   } else {
-    if (frame.pbutton)
-      XSetWindowBackgroundPixmap(blackbox->getXDisplay(),
-                                 frame.maximize_button, frame.pbutton);
-    else
-      XSetWindowBackground(blackbox->getXDisplay(), frame.maximize_button,
-                           frame.pbutton_pixel);
+#endif // BITMAPBUTTONS
+    XDrawRectangle(blackbox->getXDisplay(), frame.iconify_button, pen.gc(),
+                   2, (frame.button_w - 5), (frame.button_w - 5), 2);
+#ifdef    BITMAPBUTTONS
   }
+#endif // BITMAPBUTTONS
+}
+
+
+void BlackboxWindow::redrawMaximizeButton(bool pressed) const {
+  redrawButton(pressed, frame.maximize_button, 
+               frame.pfbutton, frame.pfbutton_pixel,
+               frame.pubutton, frame.pubutton_pixel,
+               frame.fbutton, frame.fbutton_pixel,
+               frame.ubutton, frame.ubutton_pixel);
+
   XClearWindow(blackbox->getXDisplay(), frame.maximize_button);
 
   BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
            screen->getWindowStyle()->b_pic_unfocus);
-  XDrawRectangle(blackbox->getXDisplay(), frame.maximize_button, pen.gc(),
-                 2, 2, (frame.button_w - 5), (frame.button_w - 5));
-  XDrawLine(blackbox->getXDisplay(), frame.maximize_button, pen.gc(),
-            2, 3, (frame.button_w - 3), 3);
+  
+#ifdef    BITMAPBUTTONS
+  PixmapMask pm = screen->getWindowStyle()->max_button;
+    
+  if (pm.mask != None) {
+    XSetClipMask(blackbox->getXDisplay(), pen.gc(), pm.mask);
+    XSetClipOrigin(blackbox->getXDisplay(), pen.gc(),
+                   (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
+
+    XFillRectangle(blackbox->getXDisplay(), frame.maximize_button, pen.gc(),
+                   (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
+                   (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
+    
+    XSetClipOrigin(blackbox->getXDisplay(), pen.gc(), 0, 0 );
+    XSetClipMask( blackbox->getXDisplay(), pen.gc(), None );
+  } else {
+#endif // BITMAPBUTTONS
+    XDrawRectangle(blackbox->getXDisplay(), frame.maximize_button, pen.gc(),
+                   2, 2, (frame.button_w - 5), (frame.button_w - 5));
+    XDrawLine(blackbox->getXDisplay(), frame.maximize_button, pen.gc(),
+              2, 3, (frame.button_w - 3), 3);
+#ifdef    BITMAPBUTTONS
+  }
+#endif // BITMAPBUTTONS
 }
 
 
 void BlackboxWindow::redrawCloseButton(bool pressed) const {
-  if (! pressed) {
-    if (flags.focused) {
-      if (frame.fbutton)
-        XSetWindowBackgroundPixmap(blackbox->getXDisplay(), frame.close_button,
-                                   frame.fbutton);
-      else
-        XSetWindowBackground(blackbox->getXDisplay(), frame.close_button,
-                             frame.fbutton_pixel);
-    } else {
-      if (frame.ubutton)
-        XSetWindowBackgroundPixmap(blackbox->getXDisplay(), frame.close_button,
-                                   frame.ubutton);
-      else
-        XSetWindowBackground(blackbox->getXDisplay(), frame.close_button,
-                             frame.ubutton_pixel);
-    }
-  } else {
-    if (frame.pbutton)
-      XSetWindowBackgroundPixmap(blackbox->getXDisplay(),
-                                 frame.close_button, frame.pbutton);
-    else
-      XSetWindowBackground(blackbox->getXDisplay(),
-                           frame.close_button, frame.pbutton_pixel);
-  }
+  redrawButton(pressed, frame.close_button, 
+               frame.pfbutton, frame.pfbutton_pixel,
+               frame.pubutton, frame.pubutton_pixel,
+               frame.fbutton, frame.fbutton_pixel,
+               frame.ubutton, frame.ubutton_pixel);
+
   XClearWindow(blackbox->getXDisplay(), frame.close_button);
 
   BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
            screen->getWindowStyle()->b_pic_unfocus);
-  XDrawLine(blackbox->getXDisplay(), frame.close_button, pen.gc(),
-            2, 2, (frame.button_w - 3), (frame.button_w - 3));
-  XDrawLine(blackbox->getXDisplay(), frame.close_button, pen.gc(),
-            2, (frame.button_w - 3), (frame.button_w - 3), 2);
+  
+#ifdef    BITMAPBUTTONS
+  PixmapMask pm = screen->getWindowStyle()->close_button;
+
+  if (pm.mask != None) {
+    XSetClipMask(blackbox->getXDisplay(), pen.gc(), pm.mask);
+    XSetClipOrigin(blackbox->getXDisplay(), pen.gc(),
+                   (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
+    
+    XFillRectangle(blackbox->getXDisplay(), frame.close_button, pen.gc(),
+                   (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
+                   (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
+
+  
+    XSetClipOrigin(blackbox->getXDisplay(), pen.gc(), 0, 0 );
+    XSetClipMask( blackbox->getXDisplay(), pen.gc(), None );
+  } else {
+#endif // BITMAPBUTTONS
+    XDrawLine(blackbox->getXDisplay(), frame.close_button, pen.gc(),
+              2, 2, (frame.button_w - 3), (frame.button_w - 3));
+    XDrawLine(blackbox->getXDisplay(), frame.close_button, pen.gc(),
+              2, (frame.button_w - 3), (frame.button_w - 3), 2);
+#ifdef    BITMAPBUTTONS
+  }
+#endif // BITMAPBUTTONS
 }
 
+void BlackboxWindow::redrawStickyButton(bool pressed) const {
+  redrawButton(pressed, frame.stick_button, 
+               frame.pfbutton, frame.pfbutton_pixel,
+               frame.pubutton, frame.pubutton_pixel,
+               frame.fbutton, frame.fbutton_pixel,
+               frame.ubutton, frame.ubutton_pixel);
+
+  XClearWindow(blackbox->getXDisplay(), frame.stick_button);
+
+  BPen pen((flags.focused) ? screen->getWindowStyle()->b_pic_focus :
+           screen->getWindowStyle()->b_pic_unfocus);
+  
+#ifdef    BITMAPBUTTONS
+  PixmapMask pm = screen->getWindowStyle()->stick_button;
+
+  if (pm.mask != None) {
+    XSetClipMask(blackbox->getXDisplay(), pen.gc(), pm.mask);
+    XSetClipOrigin(blackbox->getXDisplay(), pen.gc(),
+                   (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2);
+    
+    XFillRectangle(blackbox->getXDisplay(), frame.stick_button, pen.gc(),
+                   (frame.button_w - pm.w)/2, (frame.button_w - pm.h)/2,
+                   (frame.button_w + pm.w)/2, (frame.button_w + pm.h)/2);
+
+  
+    XSetClipOrigin(blackbox->getXDisplay(), pen.gc(), 0, 0 );
+    XSetClipMask( blackbox->getXDisplay(), pen.gc(), None );
+  } else {
+#endif // BITMAPBUTTONS
+    XFillRectangle(blackbox->getXDisplay(), frame.stick_button, pen.gc(),
+                   frame.button_w/2 - 1, frame.button_w/2 -1, 2, 2 );
+#ifdef    BITMAPBUTTONS
+  }
+#endif
+}
 
 void BlackboxWindow::mapRequestEvent(const XMapRequestEvent *re) {
   if (re->window != client.window)
@@ -2607,6 +2813,15 @@ void BlackboxWindow::mapRequestEvent(const XMapRequestEvent *re) {
           client.window);
 #endif // DEBUG
 
+  /*
+     Even though the window wants to be shown, if it is not on the current
+     workspace, then it isn't going to be shown right now.
+  */
+  if (! flags.stuck &&
+      blackbox_attrib.workspace != screen->getCurrentWorkspaceID() &&
+      blackbox_attrib.workspace < screen->getWorkspaceCount())
+    if (current_state == NormalState) current_state = WithdrawnState;
+
   switch (current_state) {
   case IconicState:
     iconify();
@@ -2625,8 +2840,8 @@ void BlackboxWindow::mapRequestEvent(const XMapRequestEvent *re) {
     if (isNormal()) {
       if (! blackbox->isStartup()) {
         XSync(blackbox->getXDisplay(), False); // make sure the frame is mapped
-        if (screen->doFocusNew()|| (isTransient() && getTransientFor() &&
-                                    getTransientFor()->isFocused())) {
+        if (screen->doFocusNew() || (isTransient() && getTransientFor() &&
+                                     getTransientFor()->isFocused())) {
           setInputFocus();
         }
         if (screen->getPlacementPolicy() == BScreen::ClickMousePlacement) {
@@ -2687,10 +2902,10 @@ void BlackboxWindow::reparentNotifyEvent(const XReparentEvent *re) {
 
 
 void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent *pe) {
-  if (pe->state == PropertyDelete)
+  if (pe->state == PropertyDelete || ! validateClient())
     return;
 
-#ifdef    DEBUG
+#if 0
   fprintf(stderr, "BlackboxWindow::propertyNotifyEvent(): for 0x%lx\n",
           client.window);
 #endif
@@ -2702,14 +2917,18 @@ void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent *pe) {
     break;
 
   case XA_WM_TRANSIENT_FOR: {
+    bool s = flags.stuck;
+    
     // determine if this is a transient window
     getTransientInfo();
 
+    if (flags.stuck != s) stick();
+
     // adjust the window decorations based on transience
     if (isTransient()) {
-      decorations &= ~(Decor_Maximize | Decor_Handle);
       functions &= ~Func_Maximize;
       setAllowedActions();
+      setupDecor();
     }
 
     reconfigure();
@@ -2745,17 +2964,15 @@ void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent *pe) {
       ungrabButtons();
       if (client.max_width <= client.min_width &&
           client.max_height <= client.min_height) {
-        decorations &= ~(Decor_Maximize | Decor_Handle);
         functions &= ~(Func_Resize | Func_Maximize);
       } else {
-        if (! isTransient()) {
-          decorations |= Decor_Maximize | Decor_Handle;
+        if (! isTransient())
           functions |= Func_Maximize;
-        }
         functions |= Func_Resize;
       }
       grabButtons();
       setAllowedActions();
+      setupDecor();
     }
 
     Rect old_rect = frame.rect;
@@ -2790,7 +3007,7 @@ void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent *pe) {
 
 
 void BlackboxWindow::exposeEvent(const XExposeEvent *ee) {
-#ifdef DEBUG
+#if 0
   fprintf(stderr, "BlackboxWindow::exposeEvent() for 0x%lx\n", client.window);
 #endif
 
@@ -2802,6 +3019,8 @@ void BlackboxWindow::exposeEvent(const XExposeEvent *ee) {
     redrawMaximizeButton(flags.maximized);
   else if (frame.iconify_button == ee->window)
     redrawIconifyButton(False);
+  else if (frame.stick_button == ee->window)
+    redrawStickyButton(flags.stuck);
 }
 
 
@@ -2813,7 +3032,7 @@ void BlackboxWindow::configureRequestEvent(const XConfigureRequestEvent *cr) {
     client.old_bw = cr->border_width;
 
   if (cr->value_mask & (CWX | CWY | CWWidth | CWHeight)) {
-    Rect req = frame.rect;
+    frame.changing = frame.rect;
 
     if (cr->value_mask & (CWX | CWY)) {
       if (cr->value_mask & CWX)
@@ -2821,16 +3040,45 @@ void BlackboxWindow::configureRequestEvent(const XConfigureRequestEvent *cr) {
       if (cr->value_mask & CWY)
         client.rect.setY(cr->y);
 
-      applyGravity(req);
+      applyGravity(frame.changing);
     }
 
-    if (cr->value_mask & CWWidth)
-      req.setWidth(cr->width + frame.margin.left + frame.margin.right);
+    if (cr->value_mask & (CWWidth | CWHeight)) {
+      if (cr->value_mask & CWWidth)
+        frame.changing.setWidth(cr->width +
+                                frame.margin.left + frame.margin.right);
 
-    if (cr->value_mask & CWHeight)
-      req.setHeight(cr->height + frame.margin.top + frame.margin.bottom);
+      if (cr->value_mask & CWHeight)
+        frame.changing.setHeight(cr->height +
+                                 frame.margin.top + frame.margin.bottom);
 
-    configure(req.x(), req.y(), req.width(), req.height());
+      /*
+        if a position change has been specified, then that position will be
+        used instead of determining a position based on the window's gravity.
+      */
+      if (! (cr->value_mask & (CWX | CWY))) {
+        Corner corner;
+        switch (client.win_gravity) {
+        case NorthEastGravity:
+        case EastGravity:
+          corner = TopRight;
+          break;
+        case SouthWestGravity:
+        case SouthGravity:
+          corner = BottomLeft;
+          break;
+        case SouthEastGravity:
+          corner = BottomRight;
+          break;
+        default:     // NorthWest, Static, etc
+          corner = TopLeft;
+        }
+        constrain(corner);
+      }
+    }
+
+    configure(frame.changing.x(), frame.changing.y(),
+              frame.changing.width(), frame.changing.height());
   }
 
   if (cr->value_mask & CWStackMode && !isDesktop()) {
@@ -2858,7 +3106,7 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
 
   if (frame.maximize_button == be->window && be->button <= 3) {
     redrawMaximizeButton(True);
-  } else if (be->button == 1 || (be->button == 3 && be->state == ModMask)) {
+  } else if (be->button == 1 || (be->button == 3 && be->state == mod_mask)) {
     if (! flags.focused)
       setInputFocus();
 
@@ -2866,6 +3114,8 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
       redrawIconifyButton(True);
     } else if (frame.close_button == be->window) {
       redrawCloseButton(True);
+    } else if (frame.stick_button == be->window) {
+      redrawStickyButton(True);
     } else if (frame.plate == be->window) {
       if (windowmenu && windowmenu->isVisible()) windowmenu->hide();
 
@@ -2889,7 +3139,8 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
       screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
     }
   } else if (be->button == 2 && (be->window != frame.iconify_button) &&
-             (be->window != frame.close_button)) {
+             (be->window != frame.close_button) &&
+             (be->window != frame.stick_button)) {
     screen->getWorkspace(blackbox_attrib.workspace)->lowerWindow(this);
   } else if (windowmenu && be->button == 3 &&
              (frame.title == be->window || frame.label == be->window ||
@@ -2918,12 +3169,16 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
 
       if (mx < left_edge)
         mx = left_edge;
-      if (mx > right_edge)
+      else if (mx > right_edge)
         mx = right_edge;
       if (my < top_edge)
         my = top_edge;
-      if (my > bottom_edge)
+      else if (my > bottom_edge)
         my = bottom_edge;
+      
+      if (my + windowmenu->getHeight() > screen->getHeight())
+        my = screen->getHeight() - windowmenu->getHeight() -
+          (screen->getBorderWidth() * 2);
 
       windowmenu->move(mx, my);
       windowmenu->show();
@@ -2937,7 +3192,8 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
          be->window == frame.title ||
          be->window == frame.maximize_button ||
          be->window == frame.iconify_button ||
-         be->window == frame.close_button) &&
+         be->window == frame.close_button ||
+         be->window == frame.stick_button) &&
         ! flags.shaded)
       shade();
   // mouse wheel down
@@ -2946,7 +3202,8 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
          be->window == frame.title ||
          be->window == frame.maximize_button ||
          be->window == frame.iconify_button ||
-         be->window == frame.close_button) &&
+         be->window == frame.close_button ||
+         be->window == frame.stick_button) &&
         flags.shaded)
       shade();
   }
@@ -2974,6 +3231,13 @@ void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) {
     } else {
       redrawIconifyButton(False);
     }
+  } else if (re->window == frame.stick_button && re->button == 1) {
+    if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
+        (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w))) {
+      stick();
+    } else {
+      redrawStickyButton(False);
+    }
   } else if (re->window == frame.close_button & re->button == 1) {
     if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
         (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w)))
@@ -2984,7 +3248,7 @@ void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) {
   } else if (flags.resizing) {
     endResize();
   } else if (re->window == frame.window) {
-    if (re->button == 2 && re->state == ModMask)
+    if (re->button == 2 && re->state == mod_mask)
       XUngrabPointer(blackbox->getXDisplay(), CurrentTime);
   }
 }
@@ -2992,6 +3256,8 @@ void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) {
 
 
 void BlackboxWindow::beginMove(int x_root, int y_root) {
+  if (! (functions & Func_Move)) return;
+
   assert(! (flags.resizing || flags.moving));
 
   /*
@@ -3044,13 +3310,12 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
   dx -= frame.border_w;
   dy -= frame.border_w;
 
-  if (screen->doWorkspaceWarping())
-    if (doWorkspaceWarping(x_root, y_root, dx, dy))
-      return;
-
   doWindowSnapping(dx, dy);
 
   if (screen->doOpaqueMove()) {
+    if (screen->doWorkspaceWarping())
+      doWorkspaceWarping(x_root, y_root, dx);
+
     configure(dx, dy, frame.rect.width(), frame.rect.height());
   } else {
     XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(),
@@ -3060,6 +3325,9 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
                    frame.changing.width() - 1,
                    frame.changing.height() - 1);
 
+    if (screen->doWorkspaceWarping())
+      doWorkspaceWarping(x_root, y_root, dx);
+
     frame.changing.setPos(dx, dy);
 
     XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(),
@@ -3074,8 +3342,7 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
 }
 
 
-bool BlackboxWindow::doWorkspaceWarping(int x_root, int y_root,
-                                        int dx, int dy) {
+void BlackboxWindow::doWorkspaceWarping(int x_root, int y_root, int &dx) {
   // workspace warping
   bool warp = False;
   unsigned int dest = screen->getCurrentWorkspaceID();
@@ -3092,41 +3359,41 @@ bool BlackboxWindow::doWorkspaceWarping(int x_root, int y_root,
     else dest = 0;
   }
   if (! warp)
-    return false;
+    return;
 
-  endMove();
   bool focus = flags.focused; // had focus while moving?
+
+  int dest_x = x_root;
+  if (x_root <= 0) {
+    dest_x += screen->getRect().width() - 1;
+    dx += screen->getRect().width() - 1;
+  } else {
+    dest_x -= screen->getRect().width() - 1;
+    dx -= screen->getRect().width() - 1;
+  }
+
   if (! flags.stuck)
     screen->reassociateWindow(this, dest, False);
   screen->changeWorkspaceID(dest);
-  if (focus)
-    setInputFocus();
 
-  /*
-     If the XWarpPointer is done after the configure, we can end up
-     grabbing another window, so made sure you do it first.
-     */
-  int dest_x;
-  if (x_root <= 0) {
-    dest_x = screen->getRect().right() - 1;
-    XWarpPointer(blackbox->getXDisplay(), None, 
-                 screen->getRootWindow(), 0, 0, 0, 0,
-                 dest_x, y_root);
+  if (screen->doOpaqueMove())
+    XGrabServer(blackbox->getXDisplay());
 
-    configure(dx + (screen->getRect().width() - 1), dy,
-              frame.rect.width(), frame.rect.height());
-  } else {
-    dest_x = 0;
-    XWarpPointer(blackbox->getXDisplay(), None, 
-                 screen->getRootWindow(), 0, 0, 0, 0,
-                 dest_x, y_root);
+  XUngrabPointer(blackbox->getXDisplay(), CurrentTime);
+  XWarpPointer(blackbox->getXDisplay(), None, 
+               screen->getRootWindow(), 0, 0, 0, 0,
+               dest_x, y_root);
+  XGrabPointer(blackbox->getXDisplay(), frame.window, False,
+               PointerMotionMask | ButtonReleaseMask,
+               GrabModeAsync, GrabModeAsync,
+               None, blackbox->getMoveCursor(), CurrentTime);
 
-    configure(dx - (screen->getRect().width() - 1), dy,
-              frame.rect.width(), frame.rect.height());
-  }
+  if (screen->doOpaqueMove())
+    XUngrabServer(blackbox->getXDisplay());
+
+  if (focus)
+    setInputFocus();
 
-  beginMove(dest_x, y_root);
-  return true;
 }
 
 
@@ -3452,11 +3719,14 @@ void BlackboxWindow::endMove(void) {
 
 
 void BlackboxWindow::beginResize(int x_root, int y_root, Corner dir) {
+  if (! (functions & Func_Resize)) return;
+
   assert(! (flags.resizing || flags.moving));
 
   /*
-    Only one window can be moved/resized at a time. If another window is already
-    being moved or resized, then stop it before whating to work with this one.
+    Only one window can be moved/resized at a time. If another window is
+    already being moved or resized, then stop it before whating to work with
+    this one.
   */
   BlackboxWindow *changing = blackbox->getChangingWindow();
   if (changing && changing != this) {
@@ -3531,34 +3801,42 @@ void BlackboxWindow::doResize(int x_root, int y_root) {
 
   unsigned int gw, gh;
   Corner anchor;
+  int dx, dy; // the amount of change in the size of the window
 
   switch (resize_dir) {
   case BottomLeft:
     anchor = TopRight;
-    frame.changing.setSize(frame.rect.width() - (x_root - frame.grab_x),
-                           frame.rect.height() + (y_root - frame.grab_y));
+    dx = - (x_root - frame.grab_x);
+    dy = + (y_root - frame.grab_y);
     break;
   case BottomRight:
     anchor = TopLeft;
-    frame.changing.setSize(frame.rect.width() + (x_root - frame.grab_x),
-                           frame.rect.height() + (y_root - frame.grab_y));
+    dx = + (x_root - frame.grab_x);
+    dy = + (y_root - frame.grab_y);
     break;
   case TopLeft:
     anchor = BottomRight;
-    frame.changing.setSize(frame.rect.width() - (x_root - frame.grab_x),
-                           frame.rect.height() - (y_root - frame.grab_y));
+    dx = - (x_root - frame.grab_x);
+    dy = - (y_root - frame.grab_y);
     break;
   case TopRight:
     anchor = BottomLeft;
-    frame.changing.setSize(frame.rect.width() + (x_root - frame.grab_x),
-                           frame.rect.height() - (y_root - frame.grab_y));
+    dx = + (x_root - frame.grab_x);
+    dy = - (y_root - frame.grab_y);
     break;
 
   default:
     assert(false); // unhandled Corner
     return;        // unreachable, for the compiler
   }
-  
+
+  // make sure the user cant resize the window smaller than 0, which makes it
+  // wrap around and become huge
+  if (dx < -(signed)client.rect.width()) dx = -(signed)client.rect.width();
+  if (dy < -(signed)client.rect.height()) dy = -(signed)client.rect.height();
+
+  frame.changing.setSize(frame.rect.width() + dx, frame.rect.height() + dy);
+
   constrain(anchor, &gw, &gh);
 
   XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(),
@@ -3600,7 +3878,7 @@ void BlackboxWindow::endResize(void) {
 
 
 void BlackboxWindow::motionNotifyEvent(const XMotionEvent *me) {
-#ifdef DEBUG
+#if 0
   fprintf(stderr, "BlackboxWindow::motionNotifyEvent() for 0x%lx\n",
           client.window);
 #endif
@@ -3610,15 +3888,20 @@ void BlackboxWindow::motionNotifyEvent(const XMotionEvent *me) {
   } else if (flags.resizing) {
     doResize(me->x_root, me->y_root);
   } else {
-    if (!flags.resizing && me->state & Button1Mask && (functions & Func_Move) &&
+    if ((functions & Func_Move) &&
+       (me->state & Button1Mask) &&
         (frame.title == me->window || frame.label == me->window ||
          frame.handle == me->window || frame.window == me->window)) {
       beginMove(me->x_root, me->y_root);
     } else if ((functions & Func_Resize) &&
-               (me->state & Button1Mask && (me->window == frame.right_grip ||
-                                            me->window == frame.left_grip)) ||
-               (me->state & Button3Mask && me->state & ModMask &&
-                me->window == frame.window)) {
+               ((me->state & Button1Mask) &&
+                (me->window == frame.right_grip ||
+                 me->window == frame.left_grip)) ||
+               ((me->state & Button3Mask) && (me->state & mod_mask) &&
+                (frame.title == me->window || frame.label == me->window ||
+                 frame.handle == me->window || frame.window == me->window ||
+                 frame.right_grip == me->window ||
+                 frame.left_grip == me->window))) {
       unsigned int zones = screen->getResizeZones();
       Corner corner;
       
@@ -3660,14 +3943,21 @@ void BlackboxWindow::enterNotifyEvent(const XCrossingEvent* ce) {
     }
   }
 
-  if ((! leave || inferior) && ! isFocused()) {
-    bool success = setInputFocus();
-    if (success)    // if focus succeeded install the colormap
-      installColormap(True); // XXX: shouldnt we honour no install?
-  }
+  if (! leave || inferior) {
+    if (! isFocused()) {
+      bool success = setInputFocus();
+      if (success)    // if focus succeeded install the colormap
+        installColormap(True); // XXX: shouldnt we honour no install?
 
-  if (screen->doAutoRaise())
-    timer->start();
+      /*
+        We only auto-raise when the window wasn't focused because otherwise
+        we run into problems with gtk+ drop-down lists. The window ends up
+        raising over the list.
+      */
+      if (screen->doAutoRaise())
+        timer->start();
+    }
+  }
 }
 
 
@@ -3683,9 +3973,15 @@ void BlackboxWindow::leaveNotifyEvent(const XCrossingEvent*) {
 
 
 #ifdef    SHAPE
-void BlackboxWindow::shapeEvent(XShapeEvent *) {
-  if (blackbox->hasShapeExtensions() && flags.shaped) {
-    configureShape();
+void BlackboxWindow::shapeEvent(XShapeEvent *e) {
+  if (blackbox->hasShapeExtensions()) {
+    if (! e->shaped && flags.shaped) {
+      clearShape();
+      flags.shaped = False;
+    } else if (e->shaped) {
+      configureShape();
+      flags.shaped = True;
+    }
   }
 }
 #endif // SHAPE
@@ -3717,6 +4013,12 @@ void BlackboxWindow::restore(bool remap) {
   if (flags.shaded && ! flags.iconic)
     setState(NormalState);
 
+  // erase the netwm stuff that we read when a window maps, so that it
+  // doesn't persist between mappings.
+  // (these are the ones read in getNetWMFlags().)
+  xatom->eraseValue(client.window, XAtom::net_wm_desktop);
+  xatom->eraseValue(client.window, XAtom::net_wm_state);
+
   restoreGravity(client.rect);
 
   XUnmapWindow(blackbox->getXDisplay(), frame.window);
@@ -3792,58 +4094,16 @@ void BlackboxWindow::changeBlackboxHints(const BlackboxHints *net) {
   if (net->flags & AttribDecoration) {
     switch (net->decoration) {
     case DecorNone:
-      decorations = 0;
-
+      enableDecor(False);
       break;
 
     default:
     case DecorNormal:
-      decorations |= Decor_Titlebar | Decor_Border | Decor_Iconify;
-  
-      decorations = ((functions & Func_Resize) && !isTransient() ?
-                     decorations | Decor_Handle :
-                     decorations &= ~Decor_Handle);
-      decorations = (functions & Func_Maximize ?
-                     decorations | Decor_Maximize :
-                     decorations &= ~Decor_Maximize);
-
-      break;
-
     case DecorTiny:
-      decorations |= Decor_Titlebar | Decor_Iconify;
-      decorations &= ~(Decor_Border | Decor_Handle);
-      
-      decorations = (functions & Func_Maximize ?
-                     decorations | Decor_Maximize :
-                     decorations &= ~Decor_Maximize);
-
-      break;
-
     case DecorTool:
-      decorations |= Decor_Titlebar;
-      decorations &= ~(Decor_Iconify | Decor_Border);
-
-      decorations = ((functions & Func_Resize) && !isTransient() ?
-                     decorations | Decor_Handle :
-                     decorations &= ~Decor_Handle);
-      decorations = (functions & Func_Maximize ?
-                     decorations | Decor_Maximize :
-                     decorations &= ~Decor_Maximize);
-
+      enableDecor(True);
       break;
     }
-
-    // we can not be shaded if we lack a titlebar
-    if (flags.shaded && ! (decorations & Decor_Titlebar))
-      shade();
-
-    if (flags.visible && frame.window) {
-      XMapSubwindows(blackbox->getXDisplay(), frame.window);
-      XMapWindow(blackbox->getXDisplay(), frame.window);
-    }
-
-    reconfigure();
-    setState(current_state);
   }
 }
 
@@ -3953,13 +4213,17 @@ void BlackboxWindow::constrain(Corner anchor,
     base_height = (client.base_height) ? client.base_height :
                                          client.min_height;
 
-  // constrain
-  if (dw < client.min_width) dw = client.min_width;
-  if (dh < client.min_height) dh = client.min_height;
-  if (dw > client.max_width) dw = client.max_width;
-  if (dh > client.max_height) dh = client.max_height;
-
-  assert(dw >= base_width && dh >= base_height);
+  // constrain, but only if the min/max are being used. if they aren't, then
+  // this resize is going to be from a ConfigureRequest because the window
+  // isn't allowed to be resized by the user. And in that case, we don't want
+  // to limit what the app can do
+  if (client.max_width > client.min_width ||
+      client.max_height > client.min_height) {
+    if (dw < client.min_width) dw = client.min_width;
+    if (dh < client.min_height) dh = client.min_height;
+    if (dw > client.max_width) dw = client.max_width;
+    if (dh > client.max_height) dh = client.max_height;
+  }
 
   if (client.width_inc > 1) {
     dw -= base_width;