revert child positioning on recurring scale

Author: sprocketc

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

@@ -6549,7 +6549,7 @@
                                                                                                     :pen-mode :boolean}}
                                                                                              :any],
                                                                                       :ret :vector}}},
-                                                                   duplicate {:arities {2 {:args [{:op :keys,
+                                                                   duplicate {:arities {1 {:args [{:op :keys,
                                                                                                    :opt {:explanation :string,
                                                                                                          :system-fonts :vector,
                                                                                                          :copied-bounds :seqable,
@@ -6622,8 +6622,7 @@
                                                                                                          :panels :map,
                                                                                                          :worker {:op :keys,
                                                                                                                   :req {:tasks :map}},
-                                                                                                         :pen-mode :boolean}}
-                                                                                                  :seqable],
+                                                                                                         :pen-mode :boolean}}],
                                                                                            :ret {:op :keys,
                                                                                                  :opt {:explanation :string,
                                                                                                        :system-fonts :vector,

src/renderer/element/events.cljs

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

src/renderer/element/handlers.cljs

@@ -19,7 +19,6 @@
    [renderer.utils.extra :refer [partial-right]]
    [renderer.utils.hiccup :as hiccup]
    [renderer.utils.map :as map]
-   [renderer.utils.math :refer [Vec2D]]
    [renderer.utils.path :as path]
    [renderer.utils.vec :as vec]))
 
@@ -534,19 +533,12 @@
    (update-el db id hierarchy/place pos)))
 
 (defn scale
-  [db ratio pivot-point {:keys [in-place recursive]}]
+  [db ratio pivot-point recursive]
   (let [ids-to-scale (cond-> (selected-ids db) recursive (set/union (descendant-ids db)))]
     (reduce
      (fn [db id]
-       (let [pivot-point (->> (entity db id) :bounds (take 2) (mat/sub pivot-point))
-             db (update-el db id hierarchy/scale ratio pivot-point)]
-         (if in-place
-           ;; FIXME: Handle locked ratio.
-           (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)))
+       (let [pivot-point (->> (entity db id) :bounds (take 2) (mat/sub pivot-point))]
+         (update-el db id hierarchy/scale ratio pivot-point)))
      db
      ids-to-scale)))
 

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

@@ -202,7 +202,7 @@
 
 (m/=> scale [:-> App Vec2D map? App])
 (defn scale
-  [db offset {:keys [ratio-locked in-place] :as options}]
+  [db offset {:keys [ratio-locked in-place recursive]}]
   (let [handle (-> db :clicked-element :id)
         bounds (element.h/bounds db)
         [offset pivot-point] (delta->scale-with-pivot-point handle offset bounds)
@@ -211,11 +211,11 @@
         dimensions (bounds/->dimensions bounds)
         ratio (mat/div (mat/add dimensions offset) dimensions)
         ratio (cond-> ratio ratio-locked (lock-ratio handle))
-        ;; TODO: Handle negative ratio.
+        ;; TODO: Handle negative ratio, and position on recursive scale.
         ratio (mapv #(max % 0.01) ratio)]
     (-> db
         (assoc :pivot-point pivot-point)
-        (element.h/scale ratio pivot-point options))))
+        (element.h/scale ratio pivot-point recursive))))
 
 (m/=> select-element [:-> App boolean? App])
 (defn select-element