snap widgets after mouse button release

- a more concise widget snapping algorithm
- also fixes some issues when the widgets were
  perfectly aligned

src/Widgets/DisplaysOverlay.vala

@@ -384,116 +384,62 @@ public class Display.DisplaysOverlay : Gtk.Overlay {
     }
 
    /******************************************************************************************
-    *   Widget snaping is done by trying to snap a child to other widgets called Anchors.    *
-    *   It first calculates the distance between each anchor and the child, and afterwards   *
-    *   snaps the child to the closest edge                                                  *
+    *   Widget snaping is done by trying to snap a widget to other widgets called Anchors.   *
+    *   It first calculates the distance between each anchor and the widget, and afterwards  *
+    *   snaps the widget to the closest edge/corner                                          *
     *                                                                                        *
-    *   Cases:          C = child, A = current anchor                                        *
+    *   Cases:          W = widget, A = current anchor                                       *
     *                                                                                        *
-    *   1.        2.        3.        4.                                                     *
-    *     A C       C A        A         C                                                   *
-    *                          C         A                                                   *
+    *   1.        2.        3.        4.        5.        6.        7.         8.            *
+    *     A W       W A        A         W         W          W         A         A          *
+    *                          W         A          A        A           W       W           *
     *                                                                                        *
     ******************************************************************************************/
-    private void snap_widget (Display.DisplayWidget child, List<Display.DisplayWidget> anchors) {
-        if (anchors.length () == 0) return;
-        int child_x, child_y, child_width, child_height;
-        child.get_geometry (out child_x, out child_y, out child_width, out child_height);
-        debug ("Child: %d %d %d %d\n", child_x, child_y, child_width, child_height);
 
-        bool snap_y = false, snap_x = false, move = false, diagonally = false;
-        int case_1 = int.MAX, case_2 = int.MAX, case_3 = int.MAX, case_4 = int.MAX;
+    private void snap_widget (Display.DisplayWidget widget, List<Display.DisplayWidget> anchors) {
+        if (anchors.length () == 0) {
+            return;
+        }
 
-        foreach (var anchor in anchors) {
-            if (child.equals (anchor)) continue;
+        int widget_x, widget_y, widget_width, widget_height;
+        widget.get_geometry (out widget_x, out widget_y, out widget_width, out widget_height);
+        widget_x += widget.delta_x;
+        widget_y += widget.delta_y;
 
+        int distance = int.MAX, distance_x = 0, distance_y = 0;
+        foreach (var anchor in anchors) {
             int anchor_x, anchor_y, anchor_width, anchor_height;
             anchor.get_geometry (out anchor_x, out anchor_y, out anchor_width, out anchor_height);
-            debug ("Anchor: %d %d %d %d\n", anchor_x, anchor_y, anchor_width, anchor_height);
-
-            int case_1_t = child_x - anchor_x - anchor_width;
-            int case_2_t = child_x - anchor_x + child_width;
-            int case_3_t = child_y - anchor_y - anchor_height;
-            int case_4_t = child_height + child_y - anchor_y;
-
-            // Check projections
-            if (is_projected (child_y, child_height, anchor_y, anchor_height)) {
-                debug ("Child is on the X axis of Anchor %s\n", anchor.virtual_monitor.get_display_name ());
-                case_1 = is_x_smaller_absolute (case_1, case_1_t) && !diagonally ? case_1 : case_1_t;
-                case_2 = is_x_smaller_absolute (case_2, case_2_t) && !diagonally ? case_2 : case_2_t;
-                snap_x = true;
-                move = true;
-            } else if (is_projected (child_x, child_width, anchor_x, anchor_width)) {
-                debug ("Child is on the Y axis of Anchor %s\n", anchor.virtual_monitor.get_display_name ());
-                case_3 = is_x_smaller_absolute (case_3, case_3_t) && !diagonally ? case_3 : case_3_t;
-                case_4 = is_x_smaller_absolute (case_4, case_4_t) && !diagonally ? case_4 : case_4_t;
-                snap_y = true;
-                move = true;
-            } else {
-                debug ("Child is diagonally of Anchor %s\n", anchor.virtual_monitor.get_display_name ());
-                if (!move) {
-                    diagonally = true;
-                    case_1 = is_x_smaller_absolute (case_1, case_1_t) ? case_1 : case_1_t;
-                    case_2 = is_x_smaller_absolute (case_2, case_2_t) ? case_2 : case_2_t;
-                    case_3 = is_x_smaller_absolute (case_3, case_3_t) ? case_3 : case_3_t;
-                    case_4 = is_x_smaller_absolute (case_4, case_4_t) ? case_4 : case_4_t;
-                }
-            }
-        }
-
-        int shortest_x = is_x_smaller_absolute (case_1, case_2) ? case_1 : case_2;
-        int shortest_y = is_x_smaller_absolute (case_3, case_4) ? case_3 : case_4;
-
-        // X Snapping
-        if (!snap_y || is_x_smaller_absolute (shortest_x, shortest_y)) {
-            if (snap_x & move) {
-                debug ("moving child %d on X\n", shortest_x);
-                if (shortest_x < SNAP_LIMIT) ((DisplayWidget) child).set_geometry (child_x - shortest_x, child_y , child_width, child_height);
-            }
-        }
 
-        // Y Snapping
-        if (!snap_x || is_x_smaller_absolute (shortest_y, shortest_x)) {
-            if (snap_y & move) {
-                debug ("moving child %d on Y\n", shortest_y);
-                if (shortest_y < SNAP_LIMIT) ((DisplayWidget) child).set_geometry (child_x , child_y - shortest_y, child_width, child_height);
+            var diff_x = anchor_x - widget_x;
+            var diff_y = anchor_y - widget_y;
+            var distance_left   = diff_x + anchor_width;
+            var distance_right  = diff_x - widget_width;
+            var distance_top    = diff_y + anchor_height;
+            var distance_bottom = diff_y - widget_height;
+            var test_distance_x = distance_right > -distance_left ? distance_right : distance_left;
+            var test_distance_y = distance_bottom > -distance_top ? distance_bottom : distance_top;
+
+            if (distance_left > 0 && distance_right < 0) {
+                test_distance_x = 0;
+            } else if (distance_top > 0 && distance_bottom < 0) {
+                test_distance_y = 0;
+            } else { // As diagonal monitors are not allowed, offset by 50px
+                if (test_distance_x.abs () >= test_distance_y.abs ()) {
+                    test_distance_x += diff_x > 0 ? 50 : -50;
+                } else {
+                    test_distance_y += diff_y > 0 ? 50 : -50;
+                }
             }
-        }
 
-        // X & Y Snapping
-        if (!snap_x && !snap_y) {
-            if (shortest_x < SNAP_LIMIT && shortest_y < SNAP_LIMIT) {
-                ((DisplayWidget) child).set_geometry (child_x - shortest_x, child_y - shortest_y , child_width, child_height);
-                debug ("moving child %d on X & %d on Y\n", shortest_x, shortest_y);
-            } else {
-                debug ("too large");
+            var test_distance = test_distance_x * test_distance_x + test_distance_y * test_distance_y;
+            if (test_distance < distance) {
+                distance_x = test_distance_x;
+                distance_y = test_distance_y;
+                distance = test_distance;
             }
         }
-    }
-
-    static bool equals = false;
-    private bool is_projected (int child_x, int child_length, int anchor_x, int anchor_length) {
-        var numberline = new List<int> ();
-
-        equals = false;
-        CompareFunc<int> intcmp = (a, b) => {
-            if (a == b) equals = true;
-            return (int) (a > b) - (int) (a < b);
-        };
-
-        var child_x2 = child_x + child_length;
-        var anchor_x2 = anchor_x + anchor_length;
-
-        numberline.insert_sorted (child_x, intcmp);
-        numberline.insert_sorted (child_x2, intcmp);
-        numberline.insert_sorted (anchor_x, intcmp);
-        numberline.insert_sorted (anchor_x2, intcmp);
-
-        if (equals) return false;
-        return !((numberline.index (child_x) - numberline.index (child_x2)).abs () == 1 && (numberline.index (anchor_x) - numberline.index (anchor_x2)).abs () == 1);
-    }
 
-    private bool is_x_smaller_absolute (int x, int y) {
-        return x.abs () < y.abs ();
+        widget.set_geometry (widget_x + distance_x, widget_y + distance_y, widget_width, widget_height);
     }
 }