refactor rulers and start working on grid snapping

Author: sprocketc

.clj-kondo/metosin/malli-types-cljs/config.edn

@@ -19073,6 +19073,11 @@
                                                                                               :ret :boolean}}},
                                                                ->snapping-points {:arities {2 {:args [:seqable :set],
                                                                                                :ret :seqable}}}},
+                                        renderer.ruler.handlers {step {:arities {1 {:args [:any], :ret :number}}},
+                                                                 steps-coll {:arities {3 {:args [:number
+                                                                                                 :seqable
+                                                                                                 :keyword],
+                                                                                          :ret :sequential}}}},
                                         renderer.history.handlers {state-count {:arities {1 {:args [{:op :keys,
                                                                                                      :opt {:system-fonts :vector,
                                                                                                            :copied-bounds :seqable,

deps.edn

@@ -13,6 +13,7 @@
         metosin/malli {:mvn/version "0.16.4"}
         net.mikera/core.matrix {:mvn/version "0.63.0"}
         org.clj-commons/hickory {:mvn/version "0.7.5"}
+        org.clojure/math.combinatorics {:mvn/version "0.3.0"}
         org.slf4j/slf4j-nop {:mvn/version "2.0.16"}
         re-frame/re-frame {:mvn/version "1.4.3"}
         re-pressed/re-pressed {:mvn/version "0.3.2"}

src/renderer/ruler/handlers.cljs

@@ -0,0 +1,54 @@
+(ns renderer.ruler.handlers
+  (:require
+   [clojure.math.combinatorics :as combo]
+   [malli.core :as m]
+   [renderer.document.db :refer [ZoomFactor]]
+   [renderer.frame.db :refer [Viewbox]]
+   [renderer.frame.handlers :as frame.h]
+   [renderer.ruler.db :refer [Orientation]]))
+
+(m/=> step [:-> ZoomFactor number?])
+(defn step
+  "Returns the grid step given a zoom level.
+
+   Any attemt to ingeniously produce this mapping was proven inferior.
+   Simply returning a fixed step depending on the zoom range works fine.
+   Zoom levels outside of this range are considered invalid for now.
+   Maybe we need to revisit this at some point."
+  [zoom]
+  (condp > zoom
+    0.001 2000
+    0.025 1000
+    0.05 500
+    0.1 200
+    0.25 100
+    0.5 50
+    1 15
+    2 10
+    5 5
+    10 2
+    25 1
+    50 0.5
+    0.1))
+
+(m/=> steps-coll [:-> number? Viewbox Orientation [:sequential number?]])
+(defn steps-coll
+  "Returns a collection of steps per orientaion, contained on the given viewbox."
+  [ruler-step viewbox orientation]
+  (let [[x y width height] viewbox
+        sections 10]
+    (range (- (+ (* sections ruler-step)
+                 (rem (if (= orientation :vertical) y x)
+                      (* sections ruler-step))))
+           (if (= orientation :vertical) height width)
+           ruler-step)))
+
+(defn steps-intersections
+  "Returns the intersection points of the rulers."
+  [db]
+  (let [zoom (get-in db [:documents (:active-document db) :zoom])
+        pan (get-in db [:documents (:active-document db) :pan])
+        viewbox (frame.h/viewbox zoom pan (:dom-rect db))
+        ruler-step (step zoom)]
+    (combo/cartesian-product (steps-coll ruler-step viewbox :vertical)
+                             (steps-coll ruler-step viewbox :horizontal))))

src/renderer/ruler/subs.cljs

@@ -4,7 +4,8 @@
    [renderer.app.subs :as-alias app.s]
    [renderer.document.subs :as-alias document.s]
    [renderer.element.subs :as-alias element.s]
-   [renderer.frame.subs :as-alias frame.s]))
+   [renderer.frame.subs :as-alias frame.s]
+   [renderer.ruler.handlers :as h]))
 
 (rf/reg-sub
  ::ruler
@@ -28,37 +29,14 @@
 (rf/reg-sub
  ::step
  :<- [::document.s/zoom]
- (fn [zoom _]
-   ;; Any attemt to ingeniously produce this mapping was proven inferior.
-   ;; Simply returning a fixed step depending on the zoom range works fine.
-   ;; Zoom levels outside of this range are considered invalid for now.
-   ;; Maybe we need to revisit this at some point.
-   (condp > zoom
-     0.001 2000
-     0.025 1000
-     0.05 500
-     0.1 200
-     0.25 100
-     0.5 50
-     1 15
-     2 10
-     5 5
-     10 2
-     25 1
-     50 0.5
-     0.1)))
+ h/step)
 
 (rf/reg-sub
  ::steps-coll
  :<- [::step]
  :<- [::frame.s/viewbox]
- (fn [[ruler-step [x y width height]] [_ orientation]]
-   (let [sections 10]
-     (range (- (+ (* sections ruler-step)
-                  (rem (if (= orientation :vertical) y x)
-                       (* sections ruler-step))))
-            (if (= orientation :vertical) height width)
-            ruler-step))))
+ (fn [[step viewbox] [_ orientation]]
+   (h/steps-coll step viewbox orientation)))
 
 (rf/reg-sub
  ::bounds-rect-attrs

src/renderer/snap/db.cljs

@@ -2,7 +2,7 @@
   (:require [renderer.utils.math :refer [Vec2D]]))
 
 (def snap-options
-  [:centers :midpoints :corners :nodes])
+  [:centers :midpoints :corners :nodes #_:grid])
 
 (def SnapOption
   (into [:enum] snap-options))

src/renderer/snap/handlers.cljs

@@ -7,6 +7,7 @@
    [renderer.element.handlers :as element.h]
    [renderer.frame.db :refer [Viewbox]]
    [renderer.frame.handlers :as frame.h]
+   [renderer.ruler.handlers :as ruler.h]
    [renderer.snap.db :refer [SnapOption NearestNeighbor]]
    [renderer.snap.subs :as-alias snap.s]
    [renderer.tool.hierarchy :as tool.hierarchy]
@@ -53,7 +54,10 @@
 (defn update-tree
   [db]
   (if (-> db :snap :active)
-    (let [points (element.h/snapping-points db (tool.hierarchy/snapping-elements db))]
+    (let [points (element.h/snapping-points db (tool.hierarchy/snapping-elements db))
+          points (cond-> points
+                   (contains? (-> db :snap :options) :grid)
+                   (into (ruler.h/steps-intersections db)))]
       (-> (assoc db
                  :snapping-points points
                  :kdtree (kdtree/build-tree points))