X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2FWindow.cc;h=e3ecd944cc40e36ddbd5b090a2e88bfcf59ea3fa;hb=22869af55c6eba6df528e21b9edc5f905aad2690;hp=427cc955d8500695bfcf2c1e652e911869472f7d;hpb=6954842d84539c1b345d575a39c5dbd5ab0a1227;p=chaz%2Fopenbox

diff --git a/src/Window.cc b/src/Window.cc
index 427cc955..e3ecd944 100644
--- a/src/Window.cc
+++ b/src/Window.cc
@@ -38,12 +38,15 @@ extern "C" {
 #    include <stdio.h>
 #  endif // HAVE_STDIO_H
 #endif // DEBUG
-}
 
-#include <cstdlib>
+#ifdef HAVE_STDLIB_H
+   #include <stdlib.h>
+#endif // HAVE_STDLIB_H
+}
 
 #include "i18n.hh"
 #include "blackbox.hh"
+#include "Clientmenu.hh"
 #include "Font.hh"
 #include "GCCache.hh"
 #include "Iconmenu.hh"
@@ -57,6 +60,12 @@ extern "C" {
 #include "Slit.hh"
 
 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.
@@ -85,21 +94,11 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
     return;
   }
 
-  // set the eventmask early in the game so that we make sure we get
-  // all the events we are interested in
-  XSetWindowAttributes attrib_set;
-  attrib_set.event_mask = PropertyChangeMask | FocusChangeMask |
-                          StructureNotifyMask;
-  attrib_set.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask |
-                                     ButtonMotionMask;
-  XChangeWindowAttributes(blackbox->getXDisplay(), client.window,
-                          CWEventMask|CWDontPropagate, &attrib_set);
-
   // fetch client size and placement
   XWindowAttributes wattrib;
-  if ((! XGetWindowAttributes(blackbox->getXDisplay(),
-                              client.window, &wattrib)) ||
-      (! wattrib.screen) || wattrib.override_redirect) {
+  if (! XGetWindowAttributes(blackbox->getXDisplay(),
+                             client.window, &wattrib) ||
+      ! wattrib.screen || wattrib.override_redirect) {
 #ifdef    DEBUG
     fprintf(stderr,
             "BlackboxWindow::BlackboxWindow(): XGetWindowAttributes failed\n");
@@ -109,6 +108,16 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
     return;
   }
 
+  // set the eventmask early in the game so that we make sure we get
+  // all the events we are interested in
+  XSetWindowAttributes attrib_set;
+  attrib_set.event_mask = PropertyChangeMask | FocusChangeMask |
+                          StructureNotifyMask;
+  attrib_set.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask |
+                                     ButtonMotionMask;
+  XChangeWindowAttributes(blackbox->getXDisplay(), client.window,
+                          CWEventMask|CWDontPropagate, &attrib_set);
+
   flags.moving = flags.resizing = flags.shaded = flags.visible =
     flags.iconic = flags.focused = flags.stuck = flags.modal =
     flags.send_focus_message = flags.shaped = flags.skip_taskbar =
@@ -140,10 +149,12 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
                 Decor_Iconify | Decor_Maximize;
   functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
 
-  client.wm_hint_flags = client.normal_hint_flags = 0;
+  client.normal_hint_flags = 0;
   client.window_group = None;
   client.transient_for = 0;
 
+  current_state = NormalState;
+
   /*
     get the initial size and location of client window (relative to the
     _root window_). This position is the reference point used with the
@@ -152,42 +163,31 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
   client.rect.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
   client.old_bw = wattrib.border_width;
 
-  windowmenu = 0;
   lastButtonPressTime = 0;
 
   timer = new BTimer(blackbox, this);
   timer->setTimeout(blackbox->getAutoRaiseDelay());
 
+  windowmenu = new Windowmenu(this);
+
+  // get size, aspect, minimum/maximum size and other hints set by the
+  // client
+
   if (! getBlackboxHints()) {
     getMWMHints();
     getNetWMHints();
   }
 
-  // get size, aspect, minimum/maximum size and other hints set by the
-  // client
   getWMProtocols();
   getWMHints();
   getWMNormalHints();
 
-  if (client.initial_state == WithdrawnState) {
-    screen->getSlit()->addClient(client.window);
-    delete this;
-    return;
-  }
-
-  if (isKDESystrayWindow()) {
-    screen->addSystrayWindow(client.window);
-    delete this;
-    return;
-  }
-
   frame.window = createToplevelWindow();
-  frame.plate = createChildWindow(frame.window);
-  associateClientWindow();
 
   blackbox->saveWindowSearch(frame.window, this);
+  
+  frame.plate = createChildWindow(frame.window);
   blackbox->saveWindowSearch(frame.plate, this);
-  blackbox->saveWindowSearch(client.window, this);
 
   // determine if this is a transient window
   getTransientInfo();
@@ -197,31 +197,19 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
   getWindowType();
 
   // adjust the window decorations/behavior based on the window type
+
   switch (window_type) {
   case Type_Desktop:
-    // desktop windows are not managed by us, we just make sure they stay on the
-    // bottom.
-    return;
-
   case Type_Dock:
-    // docks (such as kicker) cannot be moved, and appear on all workspaces
-    functions &= ~(Func_Move);
-    flags.stuck = True;
-  case Type_Toolbar:
   case Type_Menu:
+  case Type_Toolbar:
   case Type_Utility:
-    // these windows have minimal decorations, only a titlebar, and cannot
-    // be resized or iconified
-    decorations &= ~(Decor_Maximize | Decor_Handle | Decor_Border |
-                     Decor_Iconify);
-    functions &= ~(Func_Resize | Func_Maximize | Func_Iconify);
-    break;
-
   case Type_Splash:
-    // splash screens have no functionality or decorations, they are left up
-    // to the application which created them
+    // none of these windows are decorated or manipulated by the window manager
     decorations = 0;
     functions = 0;
+    blackbox_attrib.workspace = 0;  // we do need to belong to a workspace
+    flags.stuck = True;             // we show up on all workspaces
     break;
 
   case Type_Dialog:
@@ -234,6 +222,8 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
     // normal windows retain all of the possible decorations and functionality
     break;
   }
+  
+  setAllowedActions();
 
   // further adjeust the window's decorations/behavior based on window sizes
   if ((client.normal_hint_flags & PMinSize) &&
@@ -243,17 +233,23 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
     decorations &= ~(Decor_Maximize | Decor_Handle);
     functions &= ~(Func_Resize | Func_Maximize);
   }
-  upsize();
+  
+  if (decorations & Decor_Titlebar)
+    createTitlebar();
 
-  setAllowedActions();
+  if (decorations & Decor_Handle)
+    createHandle();
+
+  // apply the size and gravity hint to the frame
+
+  upsize();
 
   bool place_window = True;
   if (blackbox->isStartup() || isTransient() ||
       client.normal_hint_flags & (PPosition|USPosition)) {
     applyGravity(frame.rect);
 
-    if (blackbox->isStartup() ||
-        client.rect.intersects(screen->availableArea()))
+    if (blackbox->isStartup() || client.rect.intersects(screen->getRect()))
       place_window = False;
   }
 
@@ -261,21 +257,14 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
   screen->addStrut(&client.strut);
   updateStrut();
   
-  if (decorations & Decor_Titlebar)
-    createTitlebar();
-
-  if (decorations & Decor_Handle)
-    createHandle();
-
 #ifdef    SHAPE
-  if (blackbox->hasShapeExtensions() && flags.shaped) {
+  if (blackbox->hasShapeExtensions() && flags.shaped)
     configureShape();
-  }
 #endif // SHAPE
-
-  grabButtons();
-
-  windowmenu = new Windowmenu(this);
+  
+  // get the window's title before adding it to the workspace
+  getWMName();
+  getWMIconName();
 
   if (blackbox_attrib.workspace >= screen->getWorkspaceCount())
     screen->getCurrentWorkspace()->addWindow(this, place_window);
@@ -283,37 +272,62 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
     screen->getWorkspace(blackbox_attrib.workspace)->
       addWindow(this, place_window);
 
+  /*
+    the server needs to be grabbed here to prevent client's from sending
+    events while we are in the process of configuring their window.
+    We hold the grab until after we are done moving the window around.
+  */
+
+  XGrabServer(blackbox->getXDisplay());
+
+  associateClientWindow();
+
+  blackbox->saveWindowSearch(client.window, this);
+
   if (! place_window) {
     // don't need to call configure if we are letting the workspace
     // place the window
     configure(frame.rect.x(), frame.rect.y(),
               frame.rect.width(), frame.rect.height());
+
   }
 
+  positionWindows();
+
+  XUngrabServer(blackbox->getXDisplay());
+
+  // now that we know where to put the window and what it should look like
+  // we apply the decorations
+  decorate();
+
+  grabButtons();
+
+  XMapSubwindows(blackbox->getXDisplay(), frame.window);
+
+  // this ensures the title, buttons, and other decor are properly displayed
+  redrawWindowFrame();
+
   // preserve the window's initial state on first map, and its current state
   // across a restart
-  if (! getState()) {
-    if (client.wm_hint_flags & StateHint)
-      current_state = client.initial_state;
-    else
-      current_state = NormalState;
-  }
+  unsigned long initial_state = current_state;
+  if (! getState())
+    current_state = initial_state;
 
   // get sticky state from our parent window if we've got one
   if (isTransient() && client.transient_for != (BlackboxWindow *) ~0ul &&
       client.transient_for->isStuck() != flags.stuck)
-    stick();
+    flags.stuck = True;
 
   if (flags.shaded) {
     flags.shaded = False;
-    unsigned long orig_state = current_state;
+    initial_state = current_state;
     shade();
 
     /*
       At this point in the life of a window, current_state should only be set
       to IconicState if the window was an *icon*, not if it was shaded.
     */
-    if (orig_state != IconicState)
+    if (initial_state != IconicState)
       current_state = NormalState;
   }
 
@@ -322,26 +336,8 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
     stick();
   }
 
-  if (flags.maximized && (functions & Func_Maximize)) {
+  if (flags.maximized && (functions & Func_Maximize))
     remaximize();
-  }
-
-  /*
-    When the window is mapped (and also when its attributes are restored), the
-    current_state that was set here will be used.
-    It is set to Normal if the window is to be mapped or it is set to Iconic
-    if the window is to be iconified.
-    *Note* that for sticky windows, the same rules apply here, they are in
-    fact never set to Iconic since there is no way for us to tell if a sticky
-    window was iconified previously.
-  */
- 
-  positionWindows();
-  decorate();
-
-  XMapSubwindows(blackbox->getXDisplay(), frame.window);
-
-  redrawWindowFrame();
 }
 
 
@@ -424,7 +420,7 @@ Window BlackboxWindow::createToplevelWindow(void) {
                              ButtonMotionMask | EnterWindowMask;
 
   return XCreateWindow(blackbox->getXDisplay(), screen->getRootWindow(),
-                       -1, -1, 1, 1, frame.border_w, screen->getDepth(),
+                       0, 0, 1, 1, frame.border_w, screen->getDepth(),
                        InputOutput, screen->getVisual(), create_mask,
                        &attrib_create);
 }
@@ -456,24 +452,25 @@ Window BlackboxWindow::createChildWindow(Window parent, Cursor cursor) {
 
 void BlackboxWindow::associateClientWindow(void) {
   XSetWindowBorderWidth(blackbox->getXDisplay(), client.window, 0);
-  getWMName();
-  getWMIconName();
 
   XChangeSaveSet(blackbox->getXDisplay(), client.window, SetModeInsert);
 
   XSelectInput(blackbox->getXDisplay(), frame.plate, SubstructureRedirectMask);
 
-  XGrabServer(blackbox->getXDisplay());
-  XSelectInput(blackbox->getXDisplay(), client.window, NoEventMask);
-  XReparentWindow(blackbox->getXDisplay(), client.window, frame.plate, 0, 0);
+  /*
+    note we used to grab around this call to XReparentWindow however the
+    server is now grabbed before this method is called
+  */
+  unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
+                             StructureNotifyMask;
   XSelectInput(blackbox->getXDisplay(), client.window,
-               PropertyChangeMask | FocusChangeMask | StructureNotifyMask);
-  XUngrabServer(blackbox->getXDisplay());
+               event_mask & ~StructureNotifyMask);
+  XReparentWindow(blackbox->getXDisplay(), client.window, frame.plate, 0, 0);
+  XSelectInput(blackbox->getXDisplay(), client.window, event_mask);
 
   XRaiseWindow(blackbox->getXDisplay(), frame.plate);
   XMapSubwindows(blackbox->getXDisplay(), frame.plate);
 
-
 #ifdef    SHAPE
   if (blackbox->hasShapeExtensions()) {
     XShapeSelectInput(blackbox->getXDisplay(), client.window,
@@ -817,13 +814,16 @@ void BlackboxWindow::positionButtons(bool redecorate_label) {
 
 
 void BlackboxWindow::reconfigure(void) {
+  restoreGravity(client.rect);
   upsize();
-
+  applyGravity(frame.rect);
   positionWindows();
   decorate();
-
   redrawWindowFrame();
 
+  ungrabButtons();
+  grabButtons();
+
   if (windowmenu) {
     windowmenu->move(windowmenu->getX(), frame.rect.y() + frame.title_h);
     windowmenu->reconfigure();
@@ -832,30 +832,35 @@ void BlackboxWindow::reconfigure(void) {
 
 
 void BlackboxWindow::grabButtons(void) {
-  if ((! screen->isSloppyFocus()) || screen->doClickRaise())
+  if (! screen->isSloppyFocus() || screen->doClickRaise())
     // grab button 1 for changing focus/raising
     blackbox->grabButton(Button1, 0, frame.plate, True, ButtonPressMask,
-                         GrabModeSync, GrabModeSync, frame.plate, None);
-
+                         GrabModeSync, GrabModeSync, frame.plate, None,
+                         screen->allowScrollLock());
+  
   if (functions & Func_Move)
-    blackbox->grabButton(Button1, Mod1Mask, frame.window, True,
+    blackbox->grabButton(Button1, ModMask, frame.window, True,
                          ButtonReleaseMask | ButtonMotionMask, GrabModeAsync,
-                         GrabModeAsync, frame.window,
-                         blackbox->getMoveCursor());
+                         GrabModeAsync, frame.window, None,
+                         screen->allowScrollLock());
   if (functions & Func_Resize)
-    blackbox->grabButton(Button3, Mod1Mask, frame.window, True,
+    blackbox->grabButton(Button3, ModMask, frame.window, True,
                          ButtonReleaseMask | ButtonMotionMask, GrabModeAsync,
-                         GrabModeAsync, frame.window,
-                         blackbox->getLowerRightAngleCursor());
+                         GrabModeAsync, frame.window, None,
+                         screen->allowScrollLock());
+  // alt+middle lowers the window
+  blackbox->grabButton(Button2, ModMask, frame.window, True,
+                       ButtonReleaseMask, GrabModeAsync, GrabModeAsync,
+                       frame.window, None,
+                       screen->allowScrollLock());
 }
 
 
 void BlackboxWindow::ungrabButtons(void) {
-  if ((! screen->isSloppyFocus()) || screen->doClickRaise())
-    blackbox->ungrabButton(Button1, 0, frame.plate);
-
-  blackbox->ungrabButton(Button1, Mod1Mask, frame.window);
-  blackbox->ungrabButton(Button3, Mod1Mask, frame.window);
+  blackbox->ungrabButton(Button1, 0, frame.plate);
+  blackbox->ungrabButton(Button1, ModMask, frame.window);
+  blackbox->ungrabButton(Button2, ModMask, frame.window);
+  blackbox->ungrabButton(Button3, ModMask, frame.window);
 }
 
 
@@ -874,10 +879,8 @@ void BlackboxWindow::positionWindows(void) {
   XMoveResizeWindow(blackbox->getXDisplay(), client.window,
                     0, 0, client.rect.width(), client.rect.height());
   // ensure client.rect contains the real location
-  client.rect.setCoords(frame.rect.left() + frame.margin.left,
-                        frame.rect.top() + frame.margin.top,
-                        frame.rect.right() - frame.margin.right,
-                        frame.rect.bottom() - frame.margin.bottom);
+  client.rect.setPos(frame.rect.left() + frame.margin.left,
+                     frame.rect.top() + frame.margin.top);
 
   if (decorations & Decor_Titlebar) {
     if (frame.title == None) createTitlebar();
@@ -920,6 +923,7 @@ void BlackboxWindow::positionWindows(void) {
   } else if (frame.handle) {
     destroyHandle();
   }
+  XSync(blackbox->getXDisplay(), False);
 }
 
 
@@ -1052,7 +1056,6 @@ void BlackboxWindow::getWMProtocols(void) {
  */
 void BlackboxWindow::getWMHints(void) {
   focus_mode = F_Passive;
-  client.initial_state = NormalState;
 
   // remove from current window group
   if (client.window_group) {
@@ -1079,19 +1082,21 @@ void BlackboxWindow::getWMHints(void) {
   }
 
   if (wmhint->flags & StateHint)
-    client.initial_state = wmhint->initial_state;
+    current_state = wmhint->initial_state;
 
   if (wmhint->flags & WindowGroupHint) {
     client.window_group = wmhint->window_group;
 
     // add window to the appropriate group
     BWindowGroup *group = blackbox->searchGroup(client.window_group);
-    if (! group) // no group found, create it!
-      group = new BWindowGroup(blackbox, client.window_group);
-    group->addWindow(this);
+    if (! group) { // no group found, create it!
+      new BWindowGroup(blackbox, client.window_group);
+      group = blackbox->searchGroup(client.window_group);
+    }
+    if (group)
+      group->addWindow(this);
   }
 
-  client.wm_hint_flags = wmhint->flags;
   XFree(wmhint);
 }
 
@@ -1107,6 +1112,11 @@ void BlackboxWindow::getWMNormalHints(void) {
   client.min_width = client.min_height =
     client.width_inc = client.height_inc = 1;
   client.base_width = client.base_height = 0;
+  client.win_gravity = NorthWestGravity;
+#if 0
+  client.min_aspect_x = client.min_aspect_y =
+    client.max_aspect_x = client.max_aspect_y = 1;
+#endif
 
   /*
     use the full screen, not the strut modified size. otherwise when the
@@ -1115,11 +1125,7 @@ void BlackboxWindow::getWMNormalHints(void) {
   */
   const Rect& screen_area = screen->getRect();
   client.max_width = screen_area.width();
-
   client.max_height = screen_area.height();
-  client.min_aspect_x = client.min_aspect_y =
-    client.max_aspect_x = client.max_aspect_y = 1;
-  client.win_gravity = NorthWestGravity;
 
   if (! XGetWMNormalHints(blackbox->getXDisplay(), client.window,
                           &sizehint, &icccm_mask))
@@ -1128,13 +1134,22 @@ void BlackboxWindow::getWMNormalHints(void) {
   client.normal_hint_flags = sizehint.flags;
 
   if (sizehint.flags & PMinSize) {
-    client.min_width = sizehint.min_width;
-    client.min_height = sizehint.min_height;
+    if (sizehint.min_width >= 0)
+      client.min_width = sizehint.min_width;
+    if (sizehint.min_height >= 0)
+      client.min_height = sizehint.min_height;
   }
 
   if (sizehint.flags & PMaxSize) {
-    client.max_width = sizehint.max_width;
-    client.max_height = sizehint.max_height;
+    if (sizehint.max_width > static_cast<signed>(client.min_width))
+      client.max_width = sizehint.max_width;
+    else
+      client.max_width = client.min_width;
+
+    if (sizehint.max_height > static_cast<signed>(client.min_height))
+      client.max_height = sizehint.max_height;
+    else
+      client.max_height = client.min_height;
   }
 
   if (sizehint.flags & PResizeInc) {
@@ -1142,12 +1157,14 @@ void BlackboxWindow::getWMNormalHints(void) {
     client.height_inc = sizehint.height_inc;
   }
 
+#if 0 // we do not support this at the moment
   if (sizehint.flags & PAspect) {
     client.min_aspect_x = sizehint.min_aspect.x;
     client.min_aspect_y = sizehint.min_aspect.y;
     client.max_aspect_x = sizehint.max_aspect.x;
     client.max_aspect_y = sizehint.max_aspect.y;
   }
+#endif
 
   if (sizehint.flags & PBaseSize) {
     client.base_width = sizehint.base_width;
@@ -1319,17 +1336,12 @@ bool BlackboxWindow::getBlackboxHints(void) {
   if (blackbox_hint->flags & AttribDecoration) {
     switch (blackbox_hint->decoration) {
     case DecorNone:
-      // clear all decorations except close
-      decorations &= Decor_Close;
-      // clear all functions except close
-      functions &= Func_Close;
-
+      decorations = 0;
       break;
 
     case DecorTiny:
       decorations |= Decor_Titlebar | Decor_Iconify;
       decorations &= ~(Decor_Border | Decor_Handle | Decor_Maximize);
-      functions |= Func_Move | Func_Iconify;
       functions &= ~(Func_Resize | Func_Maximize);
 
       break;
@@ -1337,7 +1349,6 @@ bool BlackboxWindow::getBlackboxHints(void) {
     case DecorTool:
       decorations |= Decor_Titlebar;
       decorations &= ~(Decor_Iconify | Decor_Border | Decor_Handle);
-      functions |= Func_Move;
       functions &= ~(Func_Resize | Func_Maximize | Func_Iconify);
 
       break;
@@ -1346,8 +1357,6 @@ bool BlackboxWindow::getBlackboxHints(void) {
     default:
       decorations |= Decor_Titlebar | Decor_Border | Decor_Handle |
                      Decor_Iconify | Decor_Maximize;
-      functions |= Func_Resize | Func_Move | Func_Iconify | Func_Maximize;
-
       break;
     }
 
@@ -1363,8 +1372,7 @@ bool BlackboxWindow::getBlackboxHints(void) {
 void BlackboxWindow::getTransientInfo(void) {
   if (client.transient_for &&
       client.transient_for != (BlackboxWindow *) ~0ul) {
-    // the transient for hint was removed, so we need to tell our
-    // previous transient_for that we are going away
+    // reset transient_for in preparation of looking for a new owner
     client.transient_for->client.transientList.remove(this);
   }
 
@@ -1415,15 +1423,6 @@ void BlackboxWindow::getTransientInfo(void) {
 }
 
 
-bool BlackboxWindow::isKDESystrayWindow(void) {
-  Window systray;
-  if (xatom->getValue(client.window, XAtom::kde_net_wm_system_tray_window_for,
-                      XAtom::window, systray) && systray)
-    return True;
-  return False;
-}
-
-
 BlackboxWindow *BlackboxWindow::getTransientFor(void) const {
   if (client.transient_for &&
       client.transient_for != (BlackboxWindow*) ~0ul)
@@ -1440,7 +1439,8 @@ BlackboxWindow *BlackboxWindow::getTransientFor(void) const {
  */
 void BlackboxWindow::configure(int dx, int dy,
                                unsigned int dw, unsigned int dh) {
-  bool send_event = (frame.rect.x() != dx || frame.rect.y() != dy);
+  bool send_event = ((frame.rect.x() != dx || frame.rect.y() != dy) &&
+                     ! flags.moving);
 
   if (dw != frame.rect.width() || dh != frame.rect.height()) {
     frame.rect.setRect(dx, dy, dw, dh);
@@ -1469,9 +1469,15 @@ void BlackboxWindow::configure(int dx, int dy,
 
     XMoveWindow(blackbox->getXDisplay(), frame.window,
                 frame.rect.x(), frame.rect.y());
+    /*
+      we may have been called just after an opaque window move, so even though
+      the old coords match the new ones no ConfigureNotify has been sent yet.
+      There are likely other times when this will be relevant as well.
+    */
+    if (! flags.moving) send_event = True;
   }
 
-  if (send_event && ! flags.moving) {
+  if (send_event) {
     // if moving, the update and event will occur when the move finishes
     client.rect.setPos(frame.rect.left() + frame.margin.left,
                        frame.rect.top() + frame.margin.top);
@@ -1493,6 +1499,7 @@ void BlackboxWindow::configure(int dx, int dy,
     XSendEvent(blackbox->getXDisplay(), client.window, False,
                StructureNotifyMask, &event);
     screen->updateNetizenConfigNotify(&event);
+    XFlush(blackbox->getXDisplay());
   }
 }
 
@@ -1533,24 +1540,21 @@ void BlackboxWindow::configureShape(void) {
 bool BlackboxWindow::setInputFocus(void) {
   if (flags.focused) return True;
 
-  assert(! flags.iconic &&
-         (flags.stuck ||  // window must be on the current workspace or sticky
-          blackbox_attrib.workspace == screen->getCurrentWorkspaceID()));
-#if 0
-  // if the window is not visible, mark the window as wanting focus rather
-  // than give it focus.
-  if (! flags.visible) {
-    Workspace *wkspc = screen->getWorkspace(blackbox_attrib.workspace);
-    wkspc->setLastFocusedWindow(this);
-    return True;
-  }
-#endif
-  if (! frame.rect.intersects(screen->getRect())) {
-    // client is outside the screen, move it to the center
-    configure((screen->getWidth() - frame.rect.width()) / 2,
-              (screen->getHeight() - frame.rect.height()) / 2,
-              frame.rect.width(), frame.rect.height());
-  }
+  assert(flags.stuck ||  // window must be on the current workspace or sticky
+         blackbox_attrib.workspace == screen->getCurrentWorkspaceID());
+
+  /*
+     We only do this check for normal windows and dialogs because other windows
+     do this on purpose, such as kde's kicker, and we don't want to go moving
+     it.
+  */
+  if (window_type == Type_Normal || window_type == Type_Dialog)
+    if (! frame.rect.intersects(screen->getRect())) {
+      // client is outside the screen, move it to the center
+      configure((screen->getWidth() - frame.rect.width()) / 2,
+                (screen->getHeight() - frame.rect.height()) / 2,
+                frame.rect.width(), frame.rect.height());
+    }
 
   if (client.transientList.size() > 0) {
     // transfer focus to any modal transients
@@ -1564,8 +1568,6 @@ bool BlackboxWindow::setInputFocus(void) {
   if (focus_mode == F_LocallyActive || focus_mode == F_Passive) {
     XSetInputFocus(blackbox->getXDisplay(), client.window,
                    RevertToPointerRoot, CurrentTime);
-
-    blackbox->setFocusedWindow(this);
   } else {
     /* we could set the focus to none, since the window doesn't accept focus,
      * but we shouldn't set focus to nothing since this would surely make
@@ -1588,6 +1590,7 @@ bool BlackboxWindow::setInputFocus(void) {
     ce.xclient.data.l[4] = 0l;
     XSendEvent(blackbox->getXDisplay(), client.window, False,
                NoEventMask, &ce);
+    XFlush(blackbox->getXDisplay());
   }
 
   return ret;
@@ -1611,11 +1614,13 @@ void BlackboxWindow::iconify(void) {
    * split second, leaving us with a ghost window... so, we need to do this
    * while the X server is grabbed
    */
+  unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
+                             StructureNotifyMask;
   XGrabServer(blackbox->getXDisplay());
-  XSelectInput(blackbox->getXDisplay(), client.window, NoEventMask);
-  XUnmapWindow(blackbox->getXDisplay(), client.window);
   XSelectInput(blackbox->getXDisplay(), client.window,
-               PropertyChangeMask | FocusChangeMask | StructureNotifyMask);
+               event_mask & ~StructureNotifyMask);
+  XUnmapWindow(blackbox->getXDisplay(), client.window);
+  XSelectInput(blackbox->getXDisplay(), client.window, event_mask);
   XUngrabServer(blackbox->getXDisplay());
 
   XUnmapWindow(blackbox->getXDisplay(), frame.window);
@@ -1625,6 +1630,11 @@ void BlackboxWindow::iconify(void) {
   setState(IconicState);
 
   screen->getWorkspace(blackbox_attrib.workspace)->removeWindow(this);
+  if (flags.stuck) {
+    for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
+      if (i != blackbox_attrib.workspace)
+        screen->getWorkspace(i)->removeWindow(this, True);
+  }
 
   if (isTransient()) {
     if (client.transient_for != (BlackboxWindow *) ~0ul &&
@@ -1643,6 +1653,7 @@ void BlackboxWindow::iconify(void) {
       if (! (*it)->flags.iconic) (*it)->iconify();
     }
   }
+  screen->updateStackingList();
 }
 
 
@@ -1657,7 +1668,7 @@ void BlackboxWindow::show(void) {
   XMapSubwindows(blackbox->getXDisplay(), frame.window);
   XMapWindow(blackbox->getXDisplay(), frame.window);
 
-#ifdef DEBUG
+#if 0
   int real_x, real_y;
   Window child;
   XTranslateCoordinates(blackbox->getXDisplay(), client.window,
@@ -1704,6 +1715,7 @@ void BlackboxWindow::close(void) {
   ce.xclient.data.l[3] = 0l;
   ce.xclient.data.l[4] = 0l;
   XSendEvent(blackbox->getXDisplay(), client.window, False, NoEventMask, &ce);
+  XFlush(blackbox->getXDisplay());
 }
 
 
@@ -1722,10 +1734,12 @@ void BlackboxWindow::withdraw(void) {
 
   XGrabServer(blackbox->getXDisplay());
 
-  XSelectInput(blackbox->getXDisplay(), client.window, NoEventMask);
-  XUnmapWindow(blackbox->getXDisplay(), client.window);
+  unsigned long event_mask = PropertyChangeMask | FocusChangeMask |
+                             StructureNotifyMask;
   XSelectInput(blackbox->getXDisplay(), client.window,
-               PropertyChangeMask | FocusChangeMask | StructureNotifyMask);
+               event_mask & ~StructureNotifyMask);
+  XUnmapWindow(blackbox->getXDisplay(), client.window);
+  XSelectInput(blackbox->getXDisplay(), client.window, event_mask);
 
   XUngrabServer(blackbox->getXDisplay());
 
@@ -1772,8 +1786,21 @@ void BlackboxWindow::maximize(unsigned int button) {
   blackbox_attrib.premax_h =
     client.rect.height() + frame.margin.top + frame.margin.bottom;
 
-  const Rect &screen_area = screen->availableArea();
-  frame.changing = screen_area;
+#ifdef    XINERAMA
+  if (screen->isXineramaActive() && blackbox->doXineramaMaximizing()) {
+    // find the area to use
+    RectList availableAreas = screen->allAvailableAreas();
+    RectList::iterator it, end = availableAreas.end();
+
+    for (it = availableAreas.begin(); it != end; ++it)
+      if (it->intersects(frame.rect)) break;
+    if (it == end) // the window isn't inside an area
+      it = availableAreas.begin(); // so just default to the first one
+
+    frame.changing = *it;
+  } else
+#endif // XINERAMA
+  frame.changing = screen->availableArea();
 
   switch(button) {
   case 1:
@@ -1819,6 +1846,27 @@ void BlackboxWindow::maximize(unsigned int button) {
 
 // re-maximizes the window to take into account availableArea changes
 void BlackboxWindow::remaximize(void) {
+  if (flags.shaded) {
+    // we only update the window's attributes otherwise we lose the shade bit
+    switch(flags.maximized) {
+    case 1:
+      blackbox_attrib.flags |= AttribMaxHoriz | AttribMaxVert;
+      blackbox_attrib.attrib |= AttribMaxHoriz | AttribMaxVert;
+      break;
+
+    case 2:
+      blackbox_attrib.flags |= AttribMaxVert;
+      blackbox_attrib.attrib |= AttribMaxVert;
+      break;
+
+    case 3:
+      blackbox_attrib.flags |= AttribMaxHoriz;
+      blackbox_attrib.attrib |= AttribMaxHoriz;
+      break;
+    }
+    return;
+  }
+
   // save the original dimensions because maximize will wipe them out
   int premax_x = blackbox_attrib.premax_x,
     premax_y = blackbox_attrib.premax_y,
@@ -1840,6 +1888,14 @@ void BlackboxWindow::remaximize(void) {
 void BlackboxWindow::setWorkspace(unsigned int n) {
   blackbox_attrib.flags |= AttribWorkspace;
   blackbox_attrib.workspace = n;
+  if (n == BSENTINEL) { // iconified window
+    /*
+       we set the workspace to 'all workspaces' so that taskbars will show the
+       window. otherwise, it made uniconifying a window imposible without the
+       blackbox workspace menu
+    */
+    n = 0xffffffff;
+  }
   xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal, n);
 }
 
@@ -1884,14 +1940,17 @@ void BlackboxWindow::stick(void) {
     blackbox_attrib.attrib ^= AttribOmnipresent;
 
     flags.stuck = False;
+    
+    for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
+      if (i != blackbox_attrib.workspace)
+        screen->getWorkspace(i)->removeWindow(this, True);
 
     if (! flags.iconic)
       screen->reassociateWindow(this, BSENTINEL, True);
-    else
-      // temporary fix since sticky windows suck. set the hint to what we
-      // actually hold in our data.
-      xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
-                      blackbox_attrib.workspace);
+    // temporary fix since sticky windows suck. set the hint to what we
+    // actually hold in our data.
+    xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
+                    blackbox_attrib.workspace);
 
     setState(current_state);
   } else {
@@ -1904,6 +1963,10 @@ void BlackboxWindow::stick(void) {
     // value than that contained in the class' data.
     xatom->setValue(client.window, XAtom::net_wm_desktop, XAtom::cardinal,
                     0xffffffff);
+    
+    for (unsigned int i = 0; i < screen->getNumberOfWorkspaces(); ++i)
+      if (i != blackbox_attrib.workspace)
+        screen->getWorkspace(i)->addWindow(this, False, True);
 
     setState(current_state);
   }
@@ -2013,8 +2076,17 @@ void BlackboxWindow::setFocusFlag(bool focus) {
     else timer->stop();
   }
 
-  if (isFocused())
+  if (flags.focused)
     blackbox->setFocusedWindow(this);
+ 
+  if (! flags.iconic) {
+    // iconic windows arent in a workspace menu!
+    if (flags.stuck)
+      screen->getCurrentWorkspace()->setFocused(this, isFocused());
+    else
+      screen->getWorkspace(blackbox_attrib.workspace)->
+        setFocused(this, flags.focused);
+  }
 }
 
 
@@ -2155,8 +2227,8 @@ void BlackboxWindow::restoreAttributes(void) {
     current_state = NormalState;
   }
 
-  if (net->flags & AttribOmnipresent && net->attrib & AttribOmnipresent) {
-    flags.stuck = False;
+  if (net->flags & AttribOmnipresent && net->attrib & AttribOmnipresent &&
+      ! flags.stuck) {
     stick();
 
     // if the window was on another workspace, it was going to be hidden. this
@@ -2186,6 +2258,56 @@ void BlackboxWindow::restoreAttributes(void) {
     blackbox_attrib.premax_h = h;
   }
 
+  if (net->flags & AttribDecoration) {
+    switch (net->decoration) {
+    case DecorNone:
+      decorations = 0;
+
+      break;
+
+    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);
+
+      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
   // window's state and behave accordingly
 
@@ -2216,7 +2338,7 @@ void BlackboxWindow::applyGravity(Rect &r) {
   case NorthEastGravity:
   case SouthEastGravity:
   case EastGravity:
-    r.setX(client.rect.x() - frame.margin.left - frame.margin.right);
+    r.setX(client.rect.x() - frame.margin.left - frame.margin.right + 2);
     break;
 
   case ForgetGravity:
@@ -2243,7 +2365,7 @@ void BlackboxWindow::applyGravity(Rect &r) {
   case SouthWestGravity:
   case SouthEastGravity:
   case SouthGravity:
-    r.setY(client.rect.y() - frame.margin.top - frame.margin.bottom);
+    r.setY(client.rect.y() - frame.margin.top - frame.margin.bottom + 2);
     break;
 
   case ForgetGravity:
@@ -2279,7 +2401,7 @@ void BlackboxWindow::restoreGravity(Rect &r) {
   case NorthEastGravity:
   case SouthEastGravity:
   case EastGravity:
-    r.setX(frame.rect.x() + frame.margin.left + frame.margin.right);
+    r.setX(frame.rect.x() + frame.margin.left + frame.margin.right - 2);
     break;
 
   case ForgetGravity:
@@ -2306,7 +2428,7 @@ void BlackboxWindow::restoreGravity(Rect &r) {
   case SouthWestGravity:
   case SouthEastGravity:
   case SouthGravity:
-    r.setY(frame.rect.y() + frame.margin.top + frame.margin.bottom);
+    r.setY(frame.rect.y() + frame.margin.top + frame.margin.bottom - 2);
     break;
 
   case ForgetGravity:
@@ -2483,9 +2605,22 @@ void BlackboxWindow::mapRequestEvent(const XMapRequestEvent *re) {
   default:
     show();
     screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
-    if (! blackbox->isStartup() && (isTransient() || screen->doFocusNew())) {
-      XSync(blackbox->getXDisplay(), False); // make sure the frame is mapped..
-      setInputFocus();
+    if (isNormal()) {
+      if (! blackbox->isStartup()) {
+        XSync(blackbox->getXDisplay(), False); // make sure the frame is mapped
+        if (screen->doFocusNew()|| (isTransient() && getTransientFor() &&
+                                    getTransientFor()->isFocused())) {
+          setInputFocus();
+        }
+        if (screen->getPlacementPolicy() == BScreen::ClickMousePlacement) {
+          int x, y, rx, ry;
+          Window c, r;
+          unsigned int m;
+          XQueryPointer(blackbox->getXDisplay(), screen->getRootWindow(),
+                        &r, &c, &rx, &ry, &x, &y, &m);
+          beginMove(rx, ry);
+        }
+      }
     }
     break;
   }
@@ -2596,8 +2731,11 @@ void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent *pe) {
         decorations &= ~(Decor_Maximize | Decor_Handle);
         functions &= ~(Func_Resize | Func_Maximize);
       } else {
-        decorations |= Decor_Maximize | Decor_Handle;
-        functions |= Func_Resize | Func_Maximize;
+        if (! isTransient()) {
+          decorations |= Decor_Maximize | Decor_Handle;
+          functions |= Func_Maximize;
+        }
+        functions |= Func_Resize;
       }
       grabButtons();
       setAllowedActions();
@@ -2678,7 +2816,7 @@ void BlackboxWindow::configureRequestEvent(const XConfigureRequestEvent *cr) {
     configure(req.x(), req.y(), req.width(), req.height());
   }
 
-  if (cr->value_mask & CWStackMode) {
+  if (cr->value_mask & CWStackMode && !isDesktop()) {
     switch (cr->detail) {
     case Below:
     case BottomIf:
@@ -2701,9 +2839,9 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
           client.window);
 #endif
 
-  if (frame.maximize_button == be->window) {
+  if (frame.maximize_button == be->window && be->button <= 3) {
     redrawMaximizeButton(True);
-  } else if (be->button == 1 || (be->button == 3 && be->state == Mod1Mask)) {
+  } else if (be->button == 1 || (be->button == 3 && be->state == ModMask)) {
     if (! flags.focused)
       setInputFocus();
 
@@ -2721,7 +2859,7 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
       if (frame.title == be->window || frame.label == be->window) {
         if (((be->time - lastButtonPressTime) <=
              blackbox->getDoubleClickInterval()) ||
-            (be->state & ControlMask)) {
+            (be->state == ControlMask)) {
           lastButtonPressTime = 0;
           shade();
         } else {
@@ -2779,13 +2917,19 @@ void BlackboxWindow::buttonPressEvent(const XButtonEvent *be) {
   // mouse wheel up
   } else if (be->button == 4) {
     if ((be->window == frame.label ||
-         be->window == frame.title) &&
+         be->window == frame.title ||
+         be->window == frame.maximize_button ||
+         be->window == frame.iconify_button ||
+         be->window == frame.close_button) &&
         ! flags.shaded)
       shade();
   // mouse wheel down
   } else if (be->button == 5) {
     if ((be->window == frame.label ||
-         be->window == frame.title) &&
+         be->window == frame.title ||
+         be->window == frame.maximize_button ||
+         be->window == frame.iconify_button ||
+         be->window == frame.close_button) &&
         flags.shaded)
       shade();
   }
@@ -2798,21 +2942,22 @@ void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) {
           client.window);
 #endif
 
-  if (re->window == frame.maximize_button) {
+  if (re->window == frame.maximize_button &&
+      re->button >= 1 && re->button <= 3) {
     if ((re->x >= 0 && re->x <= static_cast<signed>(frame.button_w)) &&
         (re->y >= 0 && re->y <= static_cast<signed>(frame.button_w))) {
       maximize(re->button);
     } else {
       redrawMaximizeButton(flags.maximized);
     }
-  } else if (re->window == frame.iconify_button) {
+  } else if (re->window == frame.iconify_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))) {
       iconify();
     } else {
       redrawIconifyButton(False);
     }
-  } else if (re->window == frame.close_button) {
+  } 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)))
       close();
@@ -2821,6 +2966,9 @@ void BlackboxWindow::buttonReleaseEvent(const XButtonEvent *re) {
     endMove();
   } else if (flags.resizing) {
     endResize();
+  } else if (re->window == frame.window) {
+    if (re->button == 2 && re->state == ModMask)
+      XUngrabPointer(blackbox->getXDisplay(), CurrentTime);
   }
 }
 
@@ -2879,35 +3027,179 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
   dx -= frame.border_w;
   dy -= frame.border_w;
 
-  const int snap_distance = screen->getEdgeSnapThreshold();
+  if (screen->doWorkspaceWarping())
+    if (doWorkspaceWarping(x_root, y_root, dx, dy))
+      return;
+
+  doWindowSnapping(dx, dy);
+
+  if (screen->doOpaqueMove()) {
+    configure(dx, dy, frame.rect.width(), frame.rect.height());
+  } else {
+    XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(),
+                   screen->getOpGC(),
+                   frame.changing.x(),
+                   frame.changing.y(),
+                   frame.changing.width() - 1,
+                   frame.changing.height() - 1);
+
+    frame.changing.setPos(dx, dy);
+
+    XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(),
+                   screen->getOpGC(),
+                   frame.changing.x(),
+                   frame.changing.y(),
+                   frame.changing.width() - 1,
+                   frame.changing.height() - 1);
+  }
+
+  screen->showPosition(dx, dy);
+}
+
+
+bool BlackboxWindow::doWorkspaceWarping(int x_root, int y_root,
+                                        int dx, int dy) {
+  // workspace warping
+  bool warp = False;
+  unsigned int dest = screen->getCurrentWorkspaceID();
+  if (x_root <= 0) {
+    warp = True;
+
+    if (dest > 0) dest--;
+    else dest = screen->getNumberOfWorkspaces() - 1;
 
-  if (snap_distance) {
-    // window corners
-    const int wleft = dx,
-              wright = dx + frame.rect.width() - 1,
-              wtop = dy,
-              wbottom = dy + frame.rect.height() - 1;
+  } else if (x_root >= screen->getRect().right()) {
+    warp = True;
 
-    if (screen->getWindowToWindowSnap()) {
-      Workspace *w = screen->getWorkspace(getWorkspaceNumber());
-      assert(w);
+    if (dest < screen->getNumberOfWorkspaces() - 1) dest++;
+    else dest = 0;
+  }
+  if (! warp)
+    return false;
+
+  endMove();
+  bool focus = flags.focused; // had focus while moving?
+  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);
+
+    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);
+
+    configure(dx - (screen->getRect().width() - 1), dy,
+              frame.rect.width(), frame.rect.height());
+  }
+
+  beginMove(dest_x, y_root);
+  return true;
+}
 
-      // try snap to another window
-      for (unsigned int i = 0, c = w->getCount(); i < c; ++i) {
-        BlackboxWindow *snapwin = w->getWindow(i);
-        if (snapwin == this)
-          continue;   // don't snap to self
 
-        bool snapped = False;
-        
-        const Rect &winrect = snapwin->frameRect();
-        int dleft = std::abs(wright - winrect.left()),
-           dright = std::abs(wleft - winrect.right()),
-             dtop = std::abs(wbottom - winrect.top()),
-          dbottom = std::abs(wtop - winrect.bottom());
+void BlackboxWindow::doWindowSnapping(int &dx, int &dy) {
+  // how much resistance to edges to provide
+  const int resistance_size = screen->getResistanceSize();
 
-        if (wtop >= (signed)(winrect.y() - frame.rect.height() + 1) &&
-            wtop < (signed)(winrect.y() + winrect.height() - 1)) {
+  // how far away to snap
+  const int snap_distance = screen->getSnapThreshold();
+
+  // how to snap windows
+  const int snap_to_windows = screen->getWindowToWindowSnap();
+  const int snap_to_edges = screen->getWindowToEdgeSnap();
+  // the amount of space away from the edge to provide resistance/snap
+  const int snap_offset = 0;
+
+  // find the geomeetery where the moving window currently is
+  const Rect &moving = screen->doOpaqueMove() ? frame.rect : frame.changing;
+
+  // window corners
+  const int wleft = dx - snap_offset,
+           wright = dx + frame.rect.width() - 1 + snap_offset,
+             wtop = dy - snap_offset,
+          wbottom = dy + frame.rect.height() - 1 + snap_offset;
+
+  if (snap_to_windows) {
+    RectList rectlist;
+
+    Workspace *w = screen->getWorkspace(getWorkspaceNumber());
+    assert(w);
+
+    // add windows on the workspace to the rect list
+    const BlackboxWindowList& stack_list = w->getStackingList();
+    BlackboxWindowList::const_iterator st_it, st_end = stack_list.end();
+    for (st_it = stack_list.begin(); st_it != st_end; ++st_it)
+      rectlist.push_back( (*st_it)->frameRect() );
+
+    // add the toolbar and the slit to the rect list.
+    // (only if they are not hidden)
+    Toolbar *tbar = screen->getToolbar();
+    Slit *slit = screen->getSlit();
+    Rect tbar_rect, slit_rect;
+    unsigned int bwidth = screen->getBorderWidth() * 2;
+
+    if (! (screen->doHideToolbar() || tbar->isHidden())) {
+      tbar_rect.setRect(tbar->getX(), tbar->getY(), tbar->getWidth() + bwidth,
+                        tbar->getHeight() + bwidth);
+      rectlist.push_back(tbar_rect);
+    }
+
+    if (! slit->isHidden()) {
+      slit_rect.setRect(slit->getX(), slit->getY(), slit->getWidth() + bwidth,
+                        slit->getHeight() + bwidth);
+      rectlist.push_back(slit_rect);
+    }
+
+    RectList::const_iterator it, end = rectlist.end();
+    for (it = rectlist.begin(); it != end; ++it) {
+      bool snapped = False;
+      const Rect &winrect = *it;
+
+      if (snap_to_windows == BScreen::WindowResistance)
+        // if the window is already over top of this snap target, then
+        // resistance is futile, so just ignore it
+        if (winrect.intersects(moving))
+          continue;
+
+      int dleft, dright, dtop, dbottom;
+
+      // if the windows are in the same plane vertically
+      if (wtop >= (signed)(winrect.y() - frame.rect.height() + 1) &&
+          wtop < (signed)(winrect.y() + winrect.height() - 1)) {
+
+        if (snap_to_windows == BScreen::WindowResistance) {
+          dleft = wright - winrect.left();
+          dright = winrect.right() - wleft;
+
+          // snap left of other window?
+          if (dleft >= 0 && dleft < resistance_size) {
+            dx = winrect.left() - frame.rect.width();
+            snapped = True;
+          }
+          // snap right of other window?
+          else if (dright >= 0 && dright < resistance_size) {
+            dx = winrect.right() + 1;
+            snapped = True;
+          }
+        } else { // BScreen::WindowSnap
+          dleft = abs(wright - winrect.left());
+          dright = abs(wleft - winrect.right());
 
           // snap left of other window?
           if (dleft < snap_distance && dleft <= dright) {
@@ -2918,25 +3210,61 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
           else if (dright < snap_distance) {
             dx = winrect.right() + 1;
             snapped = True;
-          }
+          }            
+        }
 
-          if (snapped) {
-            if (screen->getWindowCornerSnap()) {
-              // try corner-snap to its other sides
-              dtop = std::abs(wtop - winrect.top());
-              dbottom = std::abs(wbottom - winrect.bottom());
+        if (snapped) {
+          if (screen->getWindowCornerSnap()) {
+            // try corner-snap to its other sides
+            if (snap_to_windows == BScreen::WindowResistance) {
+              dtop = winrect.top() - wtop;
+              dbottom = wbottom - winrect.bottom();
+              if (dtop > 0 && dtop < resistance_size) {
+                // if we're already past the top edge, then don't provide
+                // resistance
+                if (moving.top() >= winrect.top())
+                  dy = winrect.top();
+              } else if (dbottom > 0 && dbottom < resistance_size) {
+                // if we're already past the bottom edge, then don't provide
+                // resistance
+                if (moving.bottom() <= winrect.bottom())
+                  dy = winrect.bottom() - frame.rect.height() + 1;
+              }
+            } else { // BScreen::WindowSnap
+              dtop = abs(wtop - winrect.top());
+              dbottom = abs(wbottom - winrect.bottom());
               if (dtop < snap_distance && dtop <= dbottom)
                 dy = winrect.top();
               else if (dbottom < snap_distance)
                 dy = winrect.bottom() - frame.rect.height() + 1;
             }
-
-            continue;
           }
+
+          continue;
         }
+      }
 
-        if (wleft >= (signed)(winrect.x() - frame.rect.width() + 1) &&
-            wleft < (signed)(winrect.x() + winrect.width() - 1)) {
+      // if the windows are on the same plane horizontally
+      if (wleft >= (signed)(winrect.x() - frame.rect.width() + 1) &&
+          wleft < (signed)(winrect.x() + winrect.width() - 1)) {
+
+        if (snap_to_windows == BScreen::WindowResistance) {
+          dtop = wbottom - winrect.top();
+          dbottom = winrect.bottom() - wtop;
+
+          // snap top of other window?
+          if (dtop >= 0 && dtop < resistance_size) {
+            dy = winrect.top() - frame.rect.height();
+            snapped = True;
+          }
+          // snap bottom of other window?
+          else if (dbottom >= 0 && dbottom < resistance_size) {
+            dy = winrect.bottom() + 1;
+            snapped = True;
+          }
+        } else { // BScreen::WindowSnap
+          dtop = abs(wbottom - winrect.top());
+          dbottom = abs(wtop - winrect.bottom());
 
           // snap top of other window?
           if (dtop < snap_distance && dtop <= dbottom) {
@@ -2949,88 +3277,110 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
             snapped = True;
           }
 
-          if (snapped) {
-            if (screen->getWindowCornerSnap()) {
-              // try corner-snap to its other sides
-              dleft = std::abs(wleft - winrect.left());
-              dright = std::abs(wright - winrect.right());
+        }
+
+        if (snapped) {
+          if (screen->getWindowCornerSnap()) {
+            // try corner-snap to its other sides
+            if (snap_to_windows == BScreen::WindowResistance) {
+              dleft = winrect.left() - wleft;
+              dright = wright - winrect.right();
+              if (dleft > 0 && dleft < resistance_size) {
+                // if we're already past the left edge, then don't provide
+                // resistance
+                if (moving.left() >= winrect.left())
+                  dx = winrect.left();
+              } else if (dright > 0 && dright < resistance_size) {
+                // if we're already past the right edge, then don't provide
+                // resistance
+                if (moving.right() <= winrect.right())
+                  dx = winrect.right() - frame.rect.width() + 1;
+              }
+            } else { // BScreen::WindowSnap
+              dleft = abs(wleft - winrect.left());
+              dright = abs(wright - winrect.right());
               if (dleft < snap_distance && dleft <= dright)
                 dx = winrect.left();
               else if (dright < snap_distance)
                 dx = winrect.right() - frame.rect.width() + 1;
             }
-
-            continue;
           }
+
+          continue;
         }
       }
     }
-
-    // try snap to the screen's available area
-    Rect srect = screen->availableArea();
-
-    int dleft = std::abs(wleft - srect.left()),
-       dright = std::abs(wright - srect.right()),
-         dtop = std::abs(wtop - srect.top()),
-      dbottom = std::abs(wbottom - srect.bottom());
-
-    // snap left?
-    if (dleft < snap_distance && dleft <= dright)
-      dx = srect.left();
-    // snap right?
-    else if (dright < snap_distance)
-      dx = srect.right() - frame.rect.width() + 1;
-
-    // snap top?
-    if (dtop < snap_distance && dtop <= dbottom)
-      dy = srect.top();
-    // snap bottom?
-    else if (dbottom < snap_distance)
-      dy = srect.bottom() - frame.rect.height() + 1;
-
-    srect = screen->getRect(); // now get the full screen
-
-    dleft = std::abs(wleft - srect.left()),
-      dright = std::abs(wright - srect.right()),
-      dtop = std::abs(wtop - srect.top()),
-      dbottom = std::abs(wbottom - srect.bottom());
-
-    // snap left?
-    if (dleft < snap_distance && dleft <= dright)
-      dx = srect.left();
-    // snap right?
-    else if (dright < snap_distance)
-      dx = srect.right() - frame.rect.width() + 1;
-
-    // snap top?
-    if (dtop < snap_distance && dtop <= dbottom)
-      dy = srect.top();
-    // snap bottom?
-    else if (dbottom < snap_distance)
-      dy = srect.bottom() - frame.rect.height() + 1;
   }
 
-  if (screen->doOpaqueMove()) {
-    configure(dx, dy, frame.rect.width(), frame.rect.height());
-  } else {
-    XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(),
-                   screen->getOpGC(),
-                   frame.changing.x(),
-                   frame.changing.y(),
-                   frame.changing.width() - 1,
-                   frame.changing.height() - 1);
-
-    frame.changing.setPos(dx, dy);
+  if (snap_to_edges) {
+    RectList rectlist;
+
+    // snap to the screen edges (and screen boundaries for xinerama)
+#ifdef    XINERAMA
+    if (screen->isXineramaActive() && blackbox->doXineramaSnapping()) {
+      rectlist.insert(rectlist.begin(),
+                      screen->getXineramaAreas().begin(),
+                      screen->getXineramaAreas().end());
+    } else
+#endif // XINERAMA
+      rectlist.push_back(screen->getRect());
+
+    RectList::const_iterator it, end = rectlist.end();
+    for (it = rectlist.begin(); it != end; ++it) {
+      const Rect &srect = *it;
+
+      if (snap_to_edges == BScreen::WindowResistance) {
+        // if we're not in the rectangle then don't snap to it.
+        if (! srect.contains(moving))
+          continue;
+      } else { // BScreen::WindowSnap
+        // if we're not in the rectangle then don't snap to it.
+        if (! srect.intersects(Rect(wleft, wtop, frame.rect.width(),
+                                    frame.rect.height())))
+          continue;
+      }
 
-    XDrawRectangle(blackbox->getXDisplay(), screen->getRootWindow(),
-                   screen->getOpGC(),
-                   frame.changing.x(),
-                   frame.changing.y(),
-                   frame.changing.width() - 1,
-                   frame.changing.height() - 1);
+      if (snap_to_edges == BScreen::WindowResistance) {
+      int dleft = srect.left() - wleft,
+         dright = wright - srect.right(),
+           dtop = srect.top() - wtop,
+        dbottom = wbottom - srect.bottom();
+
+        // snap left?
+        if (dleft > 0 && dleft < resistance_size)
+          dx = srect.left();
+        // snap right?
+        else if (dright > 0 && dright < resistance_size)
+          dx = srect.right() - frame.rect.width() + 1;
+
+        // snap top?
+        if (dtop > 0 && dtop < resistance_size)
+          dy = srect.top();
+        // snap bottom?
+        else if (dbottom > 0 && dbottom < resistance_size)
+          dy = srect.bottom() - frame.rect.height() + 1;
+      } else { // BScreen::WindowSnap
+        int dleft = abs(wleft - srect.left()),
+           dright = abs(wright - srect.right()),
+             dtop = abs(wtop - srect.top()),
+          dbottom = abs(wbottom - srect.bottom());
+
+        // snap left?
+        if (dleft < snap_distance && dleft <= dright)
+          dx = srect.left();
+        // snap right?
+        else if (dright < snap_distance)
+          dx = srect.right() - frame.rect.width() + 1;
+
+        // snap top?
+        if (dtop < snap_distance && dtop <= dbottom)
+          dy = srect.top();
+        // snap bottom?
+        else if (dbottom < snap_distance)
+          dy = srect.bottom() - frame.rect.height() + 1;
+      }
+    }
   }
-
-  screen->showPosition(dx, dy);
 }
 
 
@@ -3113,6 +3463,7 @@ void BlackboxWindow::beginResize(int x_root, int y_root, Corner dir) {
 
   default:
     assert(false); // unhandled Corner
+    return;        // unreachable, for the compiler
   }
   
   XGrabServer(blackbox->getXDisplay());
@@ -3151,29 +3502,30 @@ void BlackboxWindow::doResize(int x_root, int y_root) {
   Corner anchor;
 
   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));
-      break;
-    case BottomRight:
-      anchor = TopLeft;
-      frame.changing.setSize(frame.rect.width() + (x_root - frame.grab_x),
-                             frame.rect.height() + (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));
-      break;
-    case TopRight:
-      anchor = BottomLeft;
-      frame.changing.setSize(frame.rect.width() + (x_root - frame.grab_x),
-                             frame.rect.height() - (y_root - frame.grab_y));
-      break;
+  case BottomLeft:
+    anchor = TopRight;
+    frame.changing.setSize(frame.rect.width() - (x_root - frame.grab_x),
+                           frame.rect.height() + (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));
+    break;
+  case TopLeft:
+    anchor = BottomRight;
+    frame.changing.setSize(frame.rect.width() - (x_root - frame.grab_x),
+                           frame.rect.height() - (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));
+    break;
 
-    default:
-      assert(false); // unhandled Corner
+  default:
+    assert(false); // unhandled Corner
+    return;        // unreachable, for the compiler
   }
   
   constrain(anchor, &gw, &gh);
@@ -3227,19 +3579,36 @@ 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 (!flags.resizing && me->state & Button1Mask && (functions & Func_Move) &&
         (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 & (Mod1Mask | Button3Mask) &&
-                 me->window == frame.window))) {
-      beginResize(me->x_root, me->y_root,
-                  (me->window == frame.left_grip) ? BottomLeft : BottomRight);
+               (me->state & Button1Mask && (me->window == frame.right_grip ||
+                                            me->window == frame.left_grip)) ||
+               (me->state & Button3Mask && me->state & ModMask &&
+                me->window == frame.window)) {
+      unsigned int zones = screen->getResizeZones();
+      Corner corner;
+      
+      if (me->window == frame.left_grip) {
+        corner = BottomLeft;
+      } else if (me->window == frame.right_grip || zones == 1) {
+        corner = BottomRight;
+      } else {
+        bool top;
+        bool left = (me->x_root - frame.rect.x() <=
+                     static_cast<signed>(frame.rect.width() / 2));
+        if (zones == 2)
+          top = False;
+        else // (zones == 4)
+          top = (me->y_root - frame.rect.y() <=
+                 static_cast<signed>(frame.rect.height() / 2));
+        corner = (top ? (left ? TopLeft : TopRight) :
+                        (left ? BottomLeft : BottomRight));
+      }
+
+      beginResize(me->x_root, me->y_root, corner);
     }
   }
 }
@@ -3277,7 +3646,8 @@ void BlackboxWindow::restore(bool remap) {
   XSelectInput(blackbox->getXDisplay(), frame.plate, NoEventMask);
 
   // do not leave a shaded window as an icon unless it was an icon
-  if (flags.shaded && ! flags.iconic) setState(NormalState);
+  if (flags.shaded && ! flags.iconic)
+    setState(NormalState);
 
   restoreGravity(client.rect);
 
@@ -3308,7 +3678,7 @@ void BlackboxWindow::timeout(void) {
 }
 
 
-void BlackboxWindow::changeBlackboxHints(BlackboxHints *net) {
+void BlackboxWindow::changeBlackboxHints(const BlackboxHints *net) {
   if ((net->flags & AttribShaded) &&
       ((blackbox_attrib.attrib & AttribShaded) !=
        (net->attrib & AttribShaded)))
@@ -3354,8 +3724,7 @@ void BlackboxWindow::changeBlackboxHints(BlackboxHints *net) {
   if (net->flags & AttribDecoration) {
     switch (net->decoration) {
     case DecorNone:
-      // clear all decorations except close
-      decorations &= Decor_Close;
+      decorations = 0;
 
       break;
 
@@ -3612,16 +3981,8 @@ BWindowGroup::BWindowGroup(Blackbox *b, Window _group)
     return;
   }
 
-  /*
-    watch for destroy notify on the group window (in addition to
-    any other events we are looking for)
-
-    since some managed windows can also be window group controllers,
-    we need to make sure that we don't clobber the event mask for the
-    managed window
-  */
   XSelectInput(blackbox->getXDisplay(), group,
-               wattrib.your_event_mask | StructureNotifyMask);
+               PropertyChangeMask | FocusChangeMask | StructureNotifyMask);
 
   blackbox->saveGroupSearch(group, this);
 }