enhance bbox naming

Author: sprocketc

src/renderer/app/db.cljs

@@ -13,7 +13,7 @@
    [renderer.theme.db :refer [Theme]]
    [renderer.timeline.db :refer [Timeline]]
    [renderer.tool.db :refer [Handle Tool State Cursor]]
-   [renderer.utils.bounds :refer [Bounds]]
+   [renderer.utils.bounds :refer [BBox]]
    [renderer.utils.i18n :as i18n]
    [renderer.utils.math :refer [Vec2]]
    [renderer.window.db :refer [Window]]))
@@ -74,7 +74,7 @@
    [:fx {:default []} vector?]
    [:pivot-point {:optional true} Vec2]
    [:clicked-element {:optional true} [:or Element Handle]]
-   [:copied-bounds {:optional true} Bounds]
+   [:copied-bbox {:optional true} BBox]
    [:copied-elements {:optional true} [:* Element]]
    [:kdtree {:optional true} [:maybe map?]]
    [:viewbox-kdtree {:optional true} [:maybe map?]]

src/renderer/document/handlers.cljs

@@ -82,7 +82,7 @@
          (-> db :dom-rect)
          (-> db :window :focused)
          (not (get-in db (path db :focused))))
-    (-> (frame.h/focus-bounds :original)
+    (-> (frame.h/focus-bbox :original)
         (assoc-in (path db :focused) true)
         (snap.h/update-viewport-tree))))
 

src/renderer/element/db.cljs

@@ -3,7 +3,7 @@
    [malli.core :as m]
    [malli.transform :as mt]
    [renderer.element.hierarchy :as hierarchy]
-   [renderer.utils.bounds :refer [Bounds]]))
+   [renderer.utils.bounds :refer [BBox]]))
 
 (defn tag?
   [k]
@@ -33,7 +33,7 @@
    [:locked {:optional true} boolean?]
    [:selected {:optional true} boolean?]
    [:children {:default [] :optional true} [:vector uuid?]]
-   [:bounds {:optional true} Bounds]
+   [:bbox {:optional true} BBox]
    [:content {:optional true} string?]
    [:attrs {:optional true} Attrs]])
 

src/renderer/element/effects.cljs

@@ -15,14 +15,14 @@
      (.close print-window))))
 
 (defn data-url->canvas-context!
-  [data-url [width height] f]
+  [data-url [w h] f]
   (let [canvas (js/document.createElement "canvas")
         context (.getContext canvas "2d")
         image (js/Image.)]
     (set! (.-onload image)
-          #(do (set! (.-width canvas) width)
-               (set! (.-height canvas) height)
-               (.drawImage context image 0 0 width height)
+          #(do (set! (.-width canvas) w)
+               (set! (.-height canvas) h)
+               (.drawImage context image 0 0 w h)
                (f context)))
     (set! (.-src image) data-url)))
 
@@ -31,19 +31,19 @@
  (fn [images]
    (doseq [image images]
      (let [data-url (-> image :attrs :href)
-           [x y] (:bounds image)
+           [x y] (:bbox image)
            ;; TODO: Handle preserveAspectRatio.
-           width (length/unit->px (-> image :attrs :width))
-           height (length/unit->px (-> image :attrs :height))]
+           w (length/unit->px (-> image :attrs :width))
+           h (length/unit->px (-> image :attrs :height))]
        (data-url->canvas-context!
         data-url
-        [width height]
+        [w h]
         (fn [context]
           (rf/dispatch
            [::worker.e/create
             {:action "trace"
              :data {:label (:label image)
-                    :image (.getImageData context 0 0 width height)
+                    :image (.getImageData context 0 0 w h)
                     :position [x y]}
              :on-success [::e/traced]}])))))))
 
@@ -58,16 +58,16 @@
              img (js/document.createElement "img")]
          (set! (.-onload img)
                (fn []
-                 (let [width (.-width img)
-                       height (.-height img)]
+                 (let [w (.-width img)
+                       h (.-height img)]
                    (.remove img)
                    (rf/dispatch [::e/add {:type :element
                                           :tag :image
                                           :label (.-name file)
-                                          :attrs {:x (- x (/ width 2))
-                                                  :y (- y (/ height 2))
-                                                  :width width
-                                                  :height height
+                                          :attrs {:x (- x (/ w 2))
+                                                  :y (- y (/ h 2))
+                                                  :width w
+                                                  :height h
                                                   :href data-url}}]))))
          (set! (.-src img) data-url)))
      (.readAsDataURL reader file))))

src/renderer/element/events.cljs

@@ -203,7 +203,7 @@
 (rf/reg-event-db
  ::scale
  (fn [db [_ ratio]]
-   (let [pivot-point (-> db h/bounds bounds/center)]
+   (let [pivot-point (-> db h/bbox bounds/center)]
      (-> (h/scale db ratio pivot-point false)
          (history.h/finalize "Scale selection")))))
 

src/renderer/element/handlers.cljs

@@ -14,7 +14,7 @@
    [renderer.notification.handlers :as notification.h]
    [renderer.notification.views :as notification.v]
    [renderer.utils.attribute :as attr]
-   [renderer.utils.bounds :as bounds :refer [Bounds]]
+   [renderer.utils.bounds :as bounds :refer [BBox]]
    [renderer.utils.element :as element]
    [renderer.utils.extra :refer [partial-right]]
    [renderer.utils.hiccup :as hiccup]
@@ -102,39 +102,42 @@
         parent-el
         (recur (parent db (:id parent-el)))))))
 
-(m/=> adjusted-bounds [:-> App uuid? [:maybe Bounds]])
-(defn adjusted-bounds
+(m/=> adjusted-bbox [:-> App uuid? [:maybe BBox]])
+(defn adjusted-bbox
   [db id]
   (loop [container (parent-container db id)
-         bounds (hierarchy/bounds (entity db id))]
-    (if-not (and container bounds)
-      bounds
-      (let [[offset-x offset-y _ _] (hierarchy/bounds container)
-            [x1 y1 x2 y2] bounds]
+         bbox (hierarchy/bbox (entity db id))]
+    (if-not (and container bbox)
+      bbox
+      (let [[offset-x offset-y _ _] (hierarchy/bbox container)
+            [min-x min-y max-x max-y] bbox]
         (recur
          (parent-container db (:id container))
-         [(+ x1 offset-x) (+ y1 offset-y) (+ x2 offset-x) (+ y2 offset-y)])))))
+         [(+ min-x offset-x)
+          (+ min-y offset-y)
+          (+ max-x offset-x)
+          (+ max-y offset-y)])))))
 
-(m/=> refresh-bounds [:-> App uuid? App])
-(defn refresh-bounds
+(m/=> refresh-bbox [:-> App uuid? App])
+(defn refresh-bbox
   [db id]
   (let [el (entity db id)
-        bounds (if (= (:tag el) :g)
-                 (let [b (map #(adjusted-bounds db %) (children-ids db id))]
-                   (when (seq b) (apply bounds/union b)))
-                 (adjusted-bounds db id))]
-    (if (or (not bounds) (element/root? el))
+        bbox (if (= (:tag el) :g)
+               (let [b (map #(adjusted-bbox db %) (children-ids db id))]
+                 (when (seq b) (apply bounds/union b)))
+               (adjusted-bbox db id))]
+    (if (or (not bbox) (element/root? el))
       db
-      (-> (reduce refresh-bounds db (children-ids db id))
-          (update-in (path db id) assoc :bounds bounds)))))
+      (-> (reduce refresh-bbox db (children-ids db id))
+          (update-in (path db id) assoc :bbox bbox)))))
 
 (m/=> update-el [:-> App uuid? ifn? [:* any?] App])
 (defn update-el
   [db id f & more]
   (if (locked? db id)
     db
     (-> (apply update-in db (path db id) f more)
-        (refresh-bounds id))))
+        (refresh-bbox id))))
 
 (m/=> siblings-selected? [:-> App [:maybe boolean?]])
 (defn siblings-selected?
@@ -241,7 +244,7 @@
 (defn update-prop
   [db id k & more]
   (-> (apply update-in db (path db id k) more)
-      (refresh-bounds id)))
+      (refresh-bbox id)))
 
 (m/=> assoc-prop [:function
                   [:-> App keyword? any? App]
@@ -253,7 +256,7 @@
    (-> (if (str/blank? v)
          (update-in db (path db id) dissoc k)
          (assoc-in db (path db id k) v))
-       (refresh-bounds id))))
+       (refresh-bbox id))))
 
 (m/=> dissoc-attr [:function
                    [:-> App keyword? App]
@@ -276,7 +279,7 @@
    (cond-> db
      (not (locked? db id))
      (-> (assoc-in (path db id :attrs k) v)
-         (refresh-bounds id)))))
+         (refresh-bbox id)))))
 
 (m/=> set-attr [:function
                 [:-> App keyword? any? App]
@@ -437,10 +440,10 @@
     (:active-document db)
     (assoc-in [:documents (:active-document db) :ignored-ids] #{})))
 
-(m/=> bounds [:-> App [:maybe Bounds]])
-(defn bounds
+(m/=> bbox [:-> App [:maybe BBox]])
+(defn bbox
   [db]
-  (element/united-bounds (selected db)))
+  (element/united-bbox (selected db)))
 
 (m/=> copy [:-> App App])
 (defn copy
@@ -449,7 +452,7 @@
     (cond-> db
       (seq els)
       (assoc :copied-elements els
-             :copied-bounds (bounds db)))))
+             :copied-bbox (bbox db)))))
 
 (m/=> delete [:function
               [:-> App App]
@@ -509,7 +512,7 @@
   (let [svgs (reverse (root-svgs db))
         pointer-pos (:adjusted-pointer-pos db)]
     (or
-     (some #(when (bounds/contained-point? (:bounds %) pointer-pos) %) svgs)
+     (some #(when (bounds/contained-point? (:bbox %) pointer-pos) %) svgs)
      (root db))))
 
 (m/=> translate [:function
@@ -531,7 +534,7 @@
    (reduce (partial-right place position) db (top-ancestor-ids db)))
   ([db id position]
    (let [el (entity db id)
-         center (bounds/center (hierarchy/bounds el))
+         center (bounds/center (hierarchy/bbox el))
          offset (mat/sub position center)]
      (update-el db id hierarchy/translate offset))))
 
@@ -544,7 +547,7 @@
     (reduce
      (fn [db id]
        (let [adjusted-pivot-point (->> (entity db id)
-                                       :bounds
+                                       :bbox
                                        (take 2)
                                        (mat/sub pivot-point))]
          (update-el db id hierarchy/scale ratio adjusted-pivot-point)))
@@ -558,19 +561,20 @@
   ([db direction]
    (reduce (partial-right align direction) db (selected-ids db)))
   ([db id direction]
-   (let [el-bounds (:bounds (entity db id))
-         center (bounds/center el-bounds)
-         parent-bounds (:bounds (parent db id))
-         parent-center (bounds/center parent-bounds)
+   (let [el-bbox (:bbox (entity db id))
+         center (bounds/center el-bbox)
+         parent-bbox (:bbox (parent db id))
+         parent-center (bounds/center parent-bbox)
          [cx cy] (mat/sub parent-center center)
-         [x1 y1 x2 y2] (mat/sub parent-bounds el-bounds)]
+         delta-bbox (mat/sub parent-bbox el-bbox)
+         [min-x-delta min-y-delta max-x-delta max-y-delta] delta-bbox]
      (translate db id (case direction
-                        :top [0 y1]
+                        :top [0 min-y-delta]
                         :center-vertical [0 cy]
-                        :bottom [0 y2]
-                        :left [x1 0]
+                        :bottom [0 max-y-delta]
+                        :left [min-x-delta 0]
                         :center-horizontal [cx 0]
-                        :right [x2 0])))))
+                        :right [max-x-delta 0])))))
 
 (m/=> ->path [:function
               [:-> App App]
@@ -592,13 +596,13 @@
   ([db id]
    (update-el db id element/stroke->path)))
 
-(m/=> overlapping-svg [:-> App Bounds Element])
+(m/=> overlapping-svg [:-> App BBox Element])
 (defn overlapping-svg
-  [db el-bounds]
+  [db el-bbox]
   (let [svgs (reverse (root-svgs db))] ; Reverse to select top svgs first.
     (or
-     (some #(when (bounds/contained? el-bounds (:bounds %)) %) svgs)
-     (some #(when (bounds/intersect? el-bounds (:bounds %)) %) svgs)
+     (some #(when (bounds/contained? el-bbox (:bbox %)) %) svgs)
+     (some #(when (bounds/intersect? el-bbox (:bbox %)) %) svgs)
      (root db))))
 
 (m/=> assoc-parent-id [:-> App Element Element])
@@ -608,7 +612,7 @@
     (not (or (element/root? el) (:parent el)))
     (assoc :parent (:id (if (element/svg? el)
                           (root db)
-                          (overlapping-svg db (hierarchy/bounds el)))))))
+                          (overlapping-svg db (hierarchy/bbox el)))))))
 
 (m/=> create [:-> App map? App])
 (defn create
@@ -624,7 +628,7 @@
         child-els (-> (entities db (set (:children el)))
                       (vals)
                       (concat (:content el)))
-        [x1 y1] (hierarchy/bounds (entity db (:parent new-el)))
+        [min-x min-y] (hierarchy/bbox (entity db (:parent new-el)))
         add-children (fn [db child-els]
                        (reduce #(cond-> %1
                                   (db/tag? (:tag %2))
@@ -641,10 +645,10 @@
         (update-prop (:parent new-el) :children #(vec (conj % id)))
 
         (not (or (element/svg? new-el) (element/root? new-el) (:parent el)))
-        (translate [(- x1) (- y1)])
+        (translate [(- min-x) (- min-y)])
 
         :always
-        (refresh-bounds id)
+        (refresh-bbox id)
 
         child-els
         (add-children child-els)))))
@@ -703,11 +707,11 @@
    (let [parent-el (hovered-svg db)]
      (reduce (partial-right paste parent-el) (deselect-all db) (:copied-elements db))))
   ([db el parent-el]
-   (let [center (bounds/center (:copied-bounds db))
-         el-center (bounds/center (:bounds el))
+   (let [center (bounds/center (:copied-bbox db))
+         el-center (bounds/center (:bbox el))
          offset (mat/sub el-center center)
-         el (dissoc el :bounds)
-         [s-x1 s-y1] (:bounds parent-el)
+         el (dissoc el :bbox)
+         [s-x1 s-y1] (:bbox parent-el)
          pointer-pos (:adjusted-pointer-pos db)]
      (reduce
       select

src/renderer/element/hierarchy.cljs

@@ -20,7 +20,7 @@
 (defmulti area :tag)
 (defmulti centroid :tag)
 (defmulti snapping-points :tag)
-(defmulti bounds :tag)
+(defmulti bbox :tag)
 (defmulti translate (fn [el _offset] (:tag el)))
 (defmulti scale (fn [el _ratio _pivot-point] (:tag el)))
 (defmulti edit (fn [el _offset _handle] (:tag el)))
@@ -29,7 +29,7 @@
 (defmethod render :default [])
 (defmethod render-to-string :default [element] [render element])
 (defmethod render-edit :default [])
-(defmethod bounds :default [])
+(defmethod bbox :default [])
 (defmethod area :default [])
 (defmethod centroid :default [])
 (defmethod snapping-points :default [])