fix nested in-place scale and refactor

Author: sprocketc

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

@@ -306,7 +306,8 @@
                                                                                                        :key-code :number,
                                                                                                        :key :string,
                                                                                                        :modifiers :set}}],
-                                                                                         :ret :any}}}},
+                                                                                         :ret :any}}},
+                                                               pointer-delta {:arities {1 {:args [:any], :ret :any}}}},
                                         renderer.utils.math {clamp {:arities {3 {:args [:number :number :number],
                                                                                  :ret :number}}},
                                                              angle-dx {:arities {2 {:args [:number :number],
@@ -330,7 +331,9 @@
                                                                                                     :ret :any}}},
                                                                  focus-bounds {:arities {2 {:args [:any :keyword],
                                                                                             :ret :any},
-                                                                                         3 {:args [:any :any :any],
+                                                                                         3 {:args [:any
+                                                                                                   :keyword
+                                                                                                   :seqable],
                                                                                             :ret :any}}},
                                                                  zoom-in-place {:arities {3 {:args [:any
                                                                                                     :number

src/renderer/app/handlers.cljs

@@ -1,5 +1,6 @@
 (ns renderer.app.handlers
   (:require
+   [clojure.core.matrix :as mat]
    [malli.experimental :as mx]
    [renderer.app.db :refer [State]]
    [renderer.app.effects :as-alias fx]
@@ -34,6 +35,10 @@
       (assoc :tool tool)
       (tool.hierarchy/activate)))
 
+(mx/defn pointer-delta
+  [db]
+  (mat/sub (:adjusted-pointer-pos db) (:adjusted-pointer-offset db)))
+
 (mx/defn pointer-handler
   [db, e :- PointerEvent, now :- number?]
   (let [{:keys [pointer-offset tool dom-rect drag primary-tool drag-threshold]} db

src/renderer/element/events.cljs

@@ -212,7 +212,7 @@
  [(finalize "Scale selection")]
  (fn [db [_ ratio]]
    (let [pivot-point (-> db h/bounds bounds/center)]
-     (h/scale db ratio pivot-point true))))
+     (h/scale db ratio pivot-point true true))))
 
 (rf/reg-event-db
  ::move-up

src/renderer/element/handlers.cljs

@@ -445,14 +445,20 @@
    (update-el db id hierarchy/place pos)))
 
 (defn scale
-  [db ratio pivot-point recur?]
-  (reduce
-   (fn [db el]
-     (let [pivot-point (->> (element db el) :bounds (take 2) (mat/sub pivot-point))]
-       (update-el db el hierarchy/scale ratio pivot-point)))
-   db
-   (cond-> (selected-ids db)
-     recur? (concat (descendant-ids db)))))
+  [db ratio pivot-point in-place recursive]
+  (let [ids-to-scale (cond-> (selected-ids db) recursive (set/union (descendant-ids db)))]
+    (reduce
+     (fn [db id]
+       (let [pivot-point (->> (element db id) :bounds (take 2) (mat/sub pivot-point))
+             db (update-el db id hierarchy/scale ratio pivot-point)]
+         (if in-place
+           (let [pointer-delta (mat/sub (:adjusted-pointer-pos db) (:adjusted-pointer-offset db))
+                 child-ids (set (children-ids db id))
+                 child-ids (set/intersection child-ids ids-to-scale)]
+             (reduce (partial-right translate pointer-delta) db child-ids))
+           db)))
+     db
+     ids-to-scale)))
 
 (defn align
   ([db direction]

src/renderer/frame/handlers.cljs

@@ -73,19 +73,21 @@
                 (mat/add [x1 y1]))]
     (assoc-in db [:documents (:active-document db) :pan] pan)))
 
+(def FocusType [:enum :original :fit :fill])
+
 (mx/defn focus-bounds
-  ([db, focus-type :- [:enum :original :fit :fill]]
+  ([db, focus-type :- FocusType]
    (cond-> db
      (:active-document db)
      (focus-bounds focus-type (or (element.h/bounds db)
                                   (element/united-bounds (element.h/root-children db))))))
-  ([{:keys [active-document dom-rect] :as db} focus-type bounds]
+  ([db, focus-type :- FocusType, bounds :- Bounds]
    (let [[width height] (utils.bounds/->dimensions bounds)
-         width-ratio (/ (:width dom-rect) width)
-         height-ratio (/ (:height dom-rect) height)
+         width-ratio (/ (-> db :dom-rect :width) width)
+         height-ratio (/ (-> db :dom-rect :height) height)
          min-zoom (min width-ratio height-ratio)]
      (-> db
-         (assoc-in [:documents active-document :zoom]
+         (assoc-in [:documents (:active-document db) :zoom]
                    (case focus-type
                      :original (min (* min-zoom 0.9) 1)
                      :fit min-zoom

src/renderer/snap/handlers.cljs

@@ -4,6 +4,7 @@
    [kdtree :as kdtree]
    [malli.experimental :as mx]
    [re-frame.core :as rf]
+   [renderer.app.handlers :as app.h]
    [renderer.element.handlers :as element.h]
    [renderer.snap.db :refer [SnapOption]]
    [renderer.snap.subs :as-alias snap.s]
@@ -28,8 +29,7 @@
 
         (contains? #{:edit :scale} (:state db))
         [(mat/add [(-> db :clicked-element :x) (-> db :clicked-element :y)]
-                  (mat/sub (:adjusted-pointer-pos db)
-                           (:adjusted-pointer-offset db)))]
+                  (app.h/pointer-delta db))]
 
         :else
         [(:adjusted-pointer-pos db)]))))

src/renderer/tool/impl/transform/edit.cljs

@@ -64,10 +64,9 @@
 (defmethod hierarchy/drag :edit
   [db e]
   (let [clicked-element (:clicked-element db)
-        pointer-delta (mat/sub (:adjusted-pointer-pos db) (:adjusted-pointer-offset db))
         db (history.h/swap db)
         el-id (:element clicked-element)
-        delta (cond-> pointer-delta (pointer/ctrl? e) pointer/lock-direction)]
+        delta (cond-> (app.h/pointer-delta db) (pointer/ctrl? e) pointer/lock-direction)]
     (cond-> db
       el-id
       (-> (element.h/update-el el-id element.hierarchy/edit delta (:id clicked-element))

src/renderer/tool/impl/transform/select.cljs

@@ -210,7 +210,7 @@
         ratio (mapv #(max % 0.01) ratio)]
     (-> db
         (assoc :pivot-point pivot-point)
-        (element.h/scale ratio pivot-point recursive))))
+        (element.h/scale ratio pivot-point in-place recursive))))
 
 (mx/defn select-element
   [db, multiple :- boolean?]
@@ -222,13 +222,14 @@
 
 (defmethod hierarchy/drag :select
   [db e]
-  (let [delta (mat/sub (:adjusted-pointer-pos db) (:adjusted-pointer-offset db))
-        state (:state db)
+  (let [state (:state db)
         ctrl? (pointer/ctrl? e)
-        delta (cond-> delta (and ctrl? (not= state :scale)) pointer/lock-direction)
         alt-key? (pointer/alt? e)
         ratio-locked? (or (pointer/ctrl? e) (element.h/ratio-locked? db))
-        db (element.h/clear-ignored db)]
+        db (element.h/clear-ignored db)
+        delta (cond-> (app.h/pointer-delta db)
+                (and ctrl? (not= state :scale))
+                pointer/lock-direction)]
     (case state
       :select
       (-> db