snapping/resistance is optional for window and edge snapping

src/Screen.hh

@@ -188,6 +188,7 @@ private:
 
   void updateWorkArea(void);
 public:
+  enum { WindowNoSnap = 0, WindowSnap, WindowResistance };
   enum { RowSmartPlacement = 1, ColSmartPlacement, CascadePlacement,
          UnderMousePlacement, ClickMousePlacement, LeftRight, RightLeft,
          TopBottom, BottomTop, IgnoreShaded, IgnoreMaximized };
@@ -196,7 +197,7 @@ public:
          WindowShade, WindowIconify, WindowMaximize, WindowClose, WindowRaise,
          WindowLower, WindowStick, WindowKill, SetStyle };
   enum FocusModel { SloppyFocus, ClickToFocus };
-  enum RootScrollDirection { NoScroll, NormalScroll, ReverseScroll };
+  enum RootScrollDirection { NoScroll = 0, NormalScroll, ReverseScroll };
 
   BScreen(Blackbox *bb, unsigned int scrn);
   ~BScreen(void);

src/Window.cc

@@ -3027,7 +3027,38 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
   dx -= frame.border_w;
   dy -= frame.border_w;
 
-  if (screen->doWorkspaceWarping()) {
+  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();
@@ -3043,7 +3074,9 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
     if (dest < screen->getNumberOfWorkspaces() - 1) dest++;
     else dest = 0;
   }
-    if (warp) {
+  if (! warp)
+    return false;
+
   endMove();
   bool focus = flags.focused; // had focus while moving?
   if (! flags.stuck)
@@ -3076,18 +3109,22 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
   }
 
   beginMove(dest_x, y_root);
-      return;
+  return true;
-    }
+}
-  }
 
+
+void BlackboxWindow::doWindowSnapping(int &dx, int &dy) {
   // how much resistance to edges to provide
   const int resistance_size = screen->getEdgeSnapThreshold();
 
-  if (resistance_size > 0) {
+  // how far away to snap
-    RectList rectlist;
+  const int snap_distance = screen->getEdgeSnapThreshold();
 
-    // the amount of space away from the edge to provide resistance
+  // how to snap windows
-    const int resistance_offset = screen->getEdgeSnapThreshold();
+  const int snap_to_windows = BScreen::WindowResistance;
+  const int snap_to_edges = BScreen::WindowResistance;
+  // the amount of space away from the edge to provide resistance/snap
+  const int snap_offset = screen->getEdgeSnapThreshold();
 
   // find the geomeetery where the moving window currently is
   const Rect &moving = screen->doOpaqueMove() ? frame.rect : frame.changing;
@@ -3098,7 +3135,9 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
              wtop = dy,
           wbottom = dy + frame.rect.height() - 1;
 
-    if (screen->getWindowToWindowSnap()) {
+  if (snap_to_windows) {
+    RectList rectlist;
+
     Workspace *w = screen->getWorkspace(getWorkspaceNumber());
     assert(w);
 
@@ -3130,23 +3169,24 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
     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 = wright - winrect.left(),
+      int dleft, dright, dtop, dbottom;
-           dright = winrect.right() - wleft,
-             dtop = wbottom - winrect.top(),
-          dbottom = winrect.bottom() - wtop;
 
       // 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();
@@ -3157,10 +3197,26 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
             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) {
+            dx = winrect.left() - frame.rect.width();
+            snapped = True;
+          }
+          // snap right of other window?
+          else if (dright < snap_distance) {
+            dx = winrect.right() + 1;
+            snapped = True;
+          }            
+        }
 
         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) {
@@ -3174,6 +3230,14 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
                 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;
@@ -3184,6 +3248,10 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
       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();
@@ -3194,10 +3262,27 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
             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) {
+            dy = winrect.top() - frame.rect.height();
+            snapped = True;
+          }
+          // snap bottom of other window?
+          else if (dbottom < snap_distance) {
+            dy = winrect.bottom() + 1;
+            snapped = True;
+          }
+
+        }
 
         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) {
@@ -3211,6 +3296,14 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
                 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;
@@ -3219,9 +3312,10 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
     }
   }
 
-    // snap to the screen edges (and screen boundaries for xinerama)
+  if (snap_to_edges) {
-    rectlist.clear();
+    RectList rectlist;
 
+    // snap to the screen edges (and screen boundaries for xinerama)
 #ifdef    XINERAMA
     if (screen->isXineramaActive() && blackbox->doXineramaSnapping()) {
       rectlist.insert(rectlist.begin(),
@@ -3235,10 +3329,18 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
     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;
+      }
 
+      if (snap_to_edges == BScreen::WindowResistance) {
       int dleft = srect.left() - wleft,
          dright = wright - srect.right(),
            dtop = srect.top() - wtop,
@@ -3257,30 +3359,28 @@ void BlackboxWindow::doMove(int x_root, int y_root) {
         // 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;
       }
     }
-
-  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);
 }
 
 

src/Window.hh

@@ -295,6 +295,8 @@ private:
   void setState(unsigned long new_state);
   void upsize(void);
   void doMove(int x_root, int y_root);
+  bool doWorkspaceWarping(int x_root, int y_root, int dx, int dy);
+  void doWindowSnapping(int &dx, int &dy);
   void endMove(void);
   void doResize(int x_root, int y_root);
   void endResize(void);