From 4eaa9394f64d61ae1420c3e9b43e3ea30353faa9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20Moya?= Date: Wed, 7 Sep 2022 15:32:47 +0200 Subject: [PATCH] :tada: Show transient changes in component copies --- common/src/app/common/geom/shapes.cljc | 19 + common/src/app/common/pages/changes.cljc | 9 +- .../src/app/common/pages/changes_builder.cljc | 3 +- common/src/app/common/pages/helpers.cljc | 65 --- common/src/app/common/types/component.cljc | 31 +- common/src/app/common/types/container.cljc | 35 ++ common/src/app/common/types/file.cljc | 14 +- common/src/app/common/types/shape_tree.cljc | 3 +- .../test/common_tests/helpers/components.cljc | 17 +- frontend/src/app/main/data/workspace.cljs | 6 +- .../app/main/data/workspace/libraries.cljs | 13 +- .../data/workspace/libraries_helpers.cljs | 32 +- .../app/main/data/workspace/transforms.cljs | 343 ++++++++++++++ .../shapes/frame/dynamic_modifiers.cljs | 420 +++++++++++++++++- .../frontend_tests/helpers/libraries.cljs | 15 +- .../frontend_tests/state_components_test.cljs | 4 +- 16 files changed, 905 insertions(+), 124 deletions(-) diff --git a/common/src/app/common/geom/shapes.cljc b/common/src/app/common/geom/shapes.cljc index 0c2e9043a..228a729c9 100644 --- a/common/src/app/common/geom/shapes.cljc +++ b/common/src/app/common/geom/shapes.cljc @@ -58,6 +58,21 @@ [shape] (or (:y shape) (:y (:selrect shape)))) ; Paths don't have :y attribute +(defn orig-pos + "Return the top left point of the shape wrapper BEFORE applying transformations." + [shape] + (gpt/point (left-bound shape) (top-bound shape))) + +(defn width + "Return the width of the shape BEFORE transformations." + [shape] + (-> shape :selrect :width)) + +(defn height + "Return the height of the shape BEFORE transformations." + [shape] + (-> shape :selrect :height)) + (defn fully-contained? "Checks if one rect is fully inside the other" [rect other] @@ -178,6 +193,10 @@ (dm/export gtr/transform-bounds) (dm/export gtr/move-position-data) (dm/export gtr/apply-objects-modifiers) +(dm/export gtr/parent-coords-rect) +(dm/export gtr/parent-coords-points) +(dm/export gtr/apply-modifiers) +(dm/export gtr/apply-transform) ;; Constratins (dm/export gct/calc-child-modifiers) diff --git a/common/src/app/common/pages/changes.cljc b/common/src/app/common/pages/changes.cljc index 9d4f37c73..e4c3d29f9 100644 --- a/common/src/app/common/pages/changes.cljc +++ b/common/src/app/common/pages/changes.cljc @@ -16,6 +16,7 @@ [app.common.pages.helpers :as cph] [app.common.spec :as us] [app.common.pages.changes-spec :as pcs] + [app.common.types.component :as ctk] [app.common.types.components-list :as ctkl] [app.common.types.container :as ctn] [app.common.types.colors-list :as ctcl] @@ -116,7 +117,7 @@ (cond-> parent (and (:shape-ref parent) (not ignore-touched)) - (-> (update :touched cph/set-touched-group :shapes-group) + (-> (update :touched ctk/set-touched-group :shapes-group) (dissoc :remote-synced?))))) (delete-from-objects [objects] @@ -221,7 +222,7 @@ (update :shapes d/vec-without-nils))] (cond-> parent (and (:shape-ref parent) (= (:type parent) :group) (not ignore-touched)) - (-> (update :touched cph/set-touched-group :shapes-group) + (-> (update :touched ctk/set-touched-group :shapes-group) (dissoc :remote-synced?))))) (remove-from-old-parent [old-objects objects shape-id] @@ -241,7 +242,7 @@ (d/update-in-when [pid :shapes] without-obj sid) (d/update-in-when [pid :shapes] d/vec-without-nils) (cond-> component? (d/update-when pid #(-> % - (update :touched cph/set-touched-group :shapes-group) + (update :touched ctk/set-touched-group :shapes-group) (dissoc :remote-synced?))))))))) (update-parent-id [objects id] @@ -416,7 +417,7 @@ (not root-name?) (not (and ignore-geometry is-geometry?))) (-> - (update :touched cph/set-touched-group group) + (update :touched ctk/set-touched-group group) (dissoc :remote-synced?)) (nil? val) diff --git a/common/src/app/common/pages/changes_builder.cljc b/common/src/app/common/pages/changes_builder.cljc index bb669eeb1..81c7168fa 100644 --- a/common/src/app/common/pages/changes_builder.cljc +++ b/common/src/app/common/pages/changes_builder.cljc @@ -15,6 +15,7 @@ [app.common.math :as mth] [app.common.pages :as cp] [app.common.pages.helpers :as cph] + [app.common.types.container :as ctn] [app.common.types.file :as ctf] [app.common.uuid :as uuid])) @@ -43,7 +44,7 @@ (defn with-container [changes container] - (if (cph/page? container) + (if (ctn/page? container) (vary-meta changes assoc ::page-id (:id container)) (vary-meta changes assoc ::component-id (:id container)))) diff --git a/common/src/app/common/pages/helpers.cljc b/common/src/app/common/pages/helpers.cljc index 8ada915fc..d567bde81 100644 --- a/common/src/app/common/pages/helpers.cljc +++ b/common/src/app/common/pages/helpers.cljc @@ -190,71 +190,6 @@ :else (recur (get-in objects [current-id :parent-id]))))) -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; COMPONENTS HELPERS -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defn set-touched-group - [touched group] - (conj (or touched #{}) group)) - -(defn touched-group? - [shape group] - ((or (:touched shape) #{}) group)) - -(defn get-component - "Retrieve a component from libraries, if no library-id is provided, we - iterate over all libraries and find the component on it." - ([libraries component-id] - (some #(-> % :data :components (get component-id)) (vals libraries))) - ([libraries library-id component-id] - (get-in libraries [library-id :data :components component-id]))) - -(defn get-component-shape - "Get the parent shape linked to a component for this shape, if any" - [objects shape] - (if-not (:shape-ref shape) - nil - (if (:component-id shape) - shape - (if-let [parent-id (:parent-id shape)] - (get-component-shape objects (get objects parent-id)) - nil)))) - -(defn get-root-shape - "Get the root shape linked to a component for this shape, if any." - [objects shape] - - (cond - (some? (:component-root? shape)) - shape - - (some? (:shape-ref shape)) - (recur objects (get objects (:parent-id shape))))) - -(defn make-container - [page-or-component type] - (assoc page-or-component :type type)) - -(defn page? - [container] - (= (:type container) :page)) - -(defn component? - [container] - (= (:type container) :component)) - -(defn get-container - [file type id] - (us/assert map? file) - (us/assert keyword? type) - (us/assert uuid? id) - - (-> (if (= type :page) - (get-in file [:pages-index id]) - (get-in file [:components id])) - (assoc :type type))) - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ALGORITHMS & TRANSFORMATIONS FOR SHAPES ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff --git a/common/src/app/common/types/component.cljc b/common/src/app/common/types/component.cljc index d84befc44..19b88fc98 100644 --- a/common/src/app/common/types/component.cljc +++ b/common/src/app/common/types/component.cljc @@ -7,10 +7,23 @@ (ns app.common.types.component) (defn instance-root? + "Check if the shape is the root of an instance or a subinstance." [shape] (some? (:component-id shape))) +(defn instance-tree-root? + "Check if the shape is the root of an instance that is no + subinstance of a higher one." + [shape] + (:component-root? shape)) + +(defn instance-shape? + "Check if the shape is part of any instance." + [shape] + (some? (:shape-ref shape))) + (defn instance-of? + "Check if the shape is the root of a near instance of the component." [shape file-id component-id] (and (some? (:component-id shape)) (some? (:component-file shape)) @@ -18,8 +31,10 @@ (= (:component-file shape) file-id))) (defn is-main-of? + "Check if the first shape is the near main of the second one." [shape-main shape-inst] - (and (:shape-ref shape-inst) + (and (not= (:id shape-main) (:id shape-inst)) + (:shape-ref shape-inst) (or (= (:shape-ref shape-inst) (:id shape-main)) (= (:shape-ref shape-inst) (:shape-ref shape-main))))) @@ -35,11 +50,13 @@ (= page-id (:main-instance-page component)))) (defn get-component-root + "Get the root shape of the component." [component] (get-in component [:objects (:id component)])) (defn uses-library-components? - "Check if the shape uses any component in the given library." + "Check if the shape is the root of an instance of any component in + the given library." [shape library-id] (and (some? (:component-id shape)) (= (:component-file shape) library-id))) @@ -49,3 +66,13 @@ [shape] (some? (:shape-ref shape))) +(defn set-touched-group + "Add a group to the touched flags." + [touched group] + (conj (or touched #{}) group)) + +(defn touched-group? + "Check if the touched flags contain the given group." + [shape group] + ((or (:touched shape) #{}) group)) + diff --git a/common/src/app/common/types/container.cljc b/common/src/app/common/types/container.cljc index 5660f1ae2..f5efbe73f 100644 --- a/common/src/app/common/types/container.cljc +++ b/common/src/app/common/types/container.cljc @@ -10,6 +10,7 @@ [app.common.geom.point :as gpt] [app.common.geom.shapes :as gsh] [app.common.spec :as us] + [app.common.types.component :as ctk] [app.common.types.shape-tree :as ctst] [clojure.spec.alpha :as s])) @@ -61,6 +62,40 @@ [container shape-id f] (update-in container [:objects shape-id] f)) +(defn get-component-shape + "Get the root shape of an instance, the one that is linked to the component. + If this is a subinstance, get the most direct root." + [objects shape] + (if-not (:shape-ref shape) + nil + (if (:component-id shape) + shape + (if-let [parent-id (:parent-id shape)] + (get-component-shape objects (get objects parent-id)) + nil)))) + +(defn get-root-shape + "Get the topmost root shape of an instance, the one that is linked to the + component and without any container instance upwards." + [objects shape] + (cond + (some? (:component-root? shape)) + shape + + (some? (:shape-ref shape)) + (recur objects (get objects (:parent-id shape))))) + +(defn get-instances + "Get all shapes in the objects list that are near instances of the given one + + --------------------------------------------------------------------------- + TODO: Warning!!! this is a slow operation, since it needs to walk the whole + objects list. Perhaps there is a way of indexing this someway. + ---------------------------------------------------------------------------" + [objects main-shape] + (filter #(ctk/is-main-of? main-shape %) + (vals objects))) + (defn make-component-shape "Clone the shape and all children. Generate new ids and detach from parent and frame. Update the original shapes to have links diff --git a/common/src/app/common/types/file.cljc b/common/src/app/common/types/file.cljc index d2143101b..298f8c0ea 100644 --- a/common/src/app/common/types/file.cljc +++ b/common/src/app/common/types/file.cljc @@ -6,6 +6,7 @@ (ns app.common.types.file (:require + [app.common.pprint :refer [pprint]] [app.common.data :as d] [app.common.data.macros :as dm] [app.common.files.features :as ffeat] @@ -99,6 +100,17 @@ (concat (map #(ctn/make-container % :page) (ctpl/pages-seq file-data)) (map #(ctn/make-container % :component) (ctkl/components-seq file-data)))) +(defn get-container + [file type id] + (us/assert map? file) + (us/assert :app.common.types.container/type type) + (us/assert uuid? id) + + (-> (if (= type :page) + (get-in file [:pages-index id]) + (get-in file [:components id])) + (assoc :type type))) + (defn update-container "Update a container inside the file, it can be a page or a component" [file-data container f] @@ -500,7 +512,7 @@ (show-component [shape objects] (if (nil? (:shape-ref shape)) "" - (let [root-shape (cph/get-component-shape objects shape) + (let [root-shape (ctn/get-component-shape objects shape) component-id (when root-shape (:component-id root-shape)) component-file-id (when root-shape (:component-file root-shape)) component-file (when component-file-id (get libraries component-file-id nil)) diff --git a/common/src/app/common/types/shape_tree.cljc b/common/src/app/common/types/shape_tree.cljc index 6304264a8..904a0faa8 100644 --- a/common/src/app/common/types/shape_tree.cljc +++ b/common/src/app/common/types/shape_tree.cljc @@ -13,6 +13,7 @@ [app.common.math :as mth] [app.common.pages.helpers :as cph] [app.common.spec :as us] + [app.common.types.component :as ctk] [app.common.types.shape :as cts] [app.common.uuid :as uuid] [clojure.spec.alpha :as s])) @@ -45,7 +46,7 @@ (cond-> (and (:shape-ref parent) (not= (:id parent) frame-id) (not ignore-touched)) - (-> (update :touched cph/set-touched-group :shapes-group) + (-> (update :touched ctk/set-touched-group :shapes-group) (dissoc :remote-synced?))))) ;; TODO: this looks wrong, why we allow nil values? diff --git a/common/test/common_tests/helpers/components.cljc b/common/test/common_tests/helpers/components.cljc index b96e0fea6..4cfbdd547 100644 --- a/common/test/common_tests/helpers/components.cljc +++ b/common/test/common_tests/helpers/components.cljc @@ -9,7 +9,8 @@ [clojure.test :as t] [app.common.pages.helpers :as cph] [app.common.types.component :as ctk] - [app.common.types.container :as ctn])) + [app.common.types.container :as ctn] + [app.common.types.file :as ctf])) ;; ---- Helpers to manage libraries and synchronization @@ -81,7 +82,7 @@ [page root-inst-id libraries] (let [root-inst (ctn/get-shape page root-inst-id) - component (cph/get-component libraries (:component-id root-inst)) + component (ctf/get-component libraries (:component-id root-inst)) shapes-inst (cph/get-children-with-self (:objects page) root-inst-id) shapes-main (cph/get-children-with-self (:objects component) (:shape-ref root-inst)) @@ -90,10 +91,10 @@ main-exists? (fn [shape] (let [component-shape - (cph/get-component-shape (:objects page) shape) + (ctn/get-component-shape (:objects page) shape) component - (cph/get-component libraries (:component-id component-shape)) + (ctf/get-component libraries (:component-id component-shape)) main-shape (ctn/get-shape component (:shape-ref shape))] @@ -117,7 +118,7 @@ [page root-inst-id libraries] (let [root-inst (ctn/get-shape page root-inst-id) - component (cph/get-component libraries (:component-id root-inst)) + component (ctf/get-component libraries (:component-id root-inst)) shapes-inst (cph/get-children-with-self (:objects page) root-inst-id) shapes-main (cph/get-children-with-self (:objects component) (:shape-ref root-inst)) @@ -126,10 +127,10 @@ main-exists? (fn [shape] (let [component-shape - (cph/get-component-shape (:objects page) shape) + (ctn/get-component-shape (:objects page) shape) component - (cph/get-component libraries (:component-id component-shape)) + (ctf/get-component libraries (:component-id component-shape)) main-shape (ctn/get-shape component (:shape-ref shape))] @@ -144,7 +145,7 @@ (defn resolve-component "Get the component with the given id and all its shapes." [page component-id libraries] - (let [component (cph/get-component libraries component-id) + (let [component (ctf/get-component libraries component-id) root-main (ctk/get-component-root component) shapes-main (cph/get-children-with-self (:objects component) (:id root-main))] diff --git a/frontend/src/app/main/data/workspace.cljs b/frontend/src/app/main/data/workspace.cljs index 74d1e1c1a..abf4c5903 100644 --- a/frontend/src/app/main/data/workspace.cljs +++ b/frontend/src/app/main/data/workspace.cljs @@ -772,8 +772,8 @@ (not (:component-root? shape))) parent (get objects parent-id) - component-shape (cph/get-component-shape objects shape) - component-shape-parent (cph/get-component-shape objects parent) + component-shape (ctn/get-component-shape objects shape) + component-shape-parent (ctn/get-component-shape objects parent) detach? (and instance-part? (not= (:id component-shape) (:id component-shape-parent))) @@ -1510,7 +1510,7 @@ ;; Check if the shape is an instance whose master is defined in a ;; library that is not linked to the current file (foreign-instance? [shape paste-objects state] - (let [root (cph/get-root-shape paste-objects shape) + (let [root (ctn/get-root-shape paste-objects shape) root-file-id (:component-file root)] (and (some? root) (not= root-file-id (:current-file-id state)) diff --git a/frontend/src/app/main/data/workspace/libraries.cljs b/frontend/src/app/main/data/workspace/libraries.cljs index d58524fb6..36083ccbd 100644 --- a/frontend/src/app/main/data/workspace/libraries.cljs +++ b/frontend/src/app/main/data/workspace/libraries.cljs @@ -372,7 +372,7 @@ ptk/WatchEvent (watch [it state _] (let [libraries (wsh/get-libraries state) - component (cph/get-component libraries id) + component (ctf/get-component libraries id) all-components (-> state :workspace-data :components vals) unames (into #{} (map :name) all-components) new-name (ctst/generate-unique-name unames (:name component)) @@ -490,7 +490,7 @@ (watch [it state _] (let [file (wsh/get-local-file state) page-id (get state :current-page-id) - container (cph/get-container file :page page-id) + container (ctf/get-container file :page page-id) changes (-> (pcb/empty-changes it) (pcb/with-container container) @@ -506,7 +506,7 @@ (let [page-id (:current-page-id state) objects (wsh/lookup-page-objects state page-id) file (wsh/get-local-file state) - container (cph/get-container file :page page-id) + container (ctf/get-container file :page page-id) selected (->> state (wsh/lookup-selected) (cph/clean-loops objects)) @@ -563,7 +563,7 @@ libraries (wsh/get-libraries state) page-id (:current-page-id state) - container (cph/get-container file :page page-id) + container (ctf/get-container file :page page-id) components-v2 (features/active-feature? state :components-v2) @@ -599,7 +599,7 @@ local-file (wsh/get-local-file state) libraries (wsh/get-libraries state) - container (cph/get-container local-file :page page-id) + container (ctf/get-container local-file :page page-id) shape (ctn/get-shape container id) changes @@ -858,7 +858,8 @@ (fn [[event data]] (let [page (wsh/lookup-page state) - [{:keys [changes save-undo?]} (deref event) + {:keys [changes save-undo?]} (deref event) + components-changed (reduce #(into %1 (ch/components-changed data %2)) #{} changes) diff --git a/frontend/src/app/main/data/workspace/libraries_helpers.cljs b/frontend/src/app/main/data/workspace/libraries_helpers.cljs index 681ec9c34..d9d3147f3 100644 --- a/frontend/src/app/main/data/workspace/libraries_helpers.cljs +++ b/frontend/src/app/main/data/workspace/libraries_helpers.cljs @@ -127,7 +127,7 @@ (defn generate-instantiate-component "Generate changes to create a new instance from a component." [it file-id component-id position page libraries] - (let [component (cph/get-component libraries file-id component-id) + (let [component (ctf/get-component libraries file-id component-id) [new-shape new-shapes] (ctn/make-component-instance page component file-id position) @@ -191,7 +191,7 @@ asset-id library-id state - (cph/make-container page :page) + (ctn/make-container page :page) components-v2))) changes)))) @@ -227,7 +227,7 @@ asset-id library-id state - (cph/make-container local-component :component) + (ctn/make-container local-component :component) components-v2))) changes)))) @@ -236,7 +236,7 @@ or a component) that use assets of the given type in the given library." [it asset-type asset-id library-id state container components-v2] - (if (cph/page? container) + (if (ctn/page? container) (log/debug :msg "Sync page in local file" :page-id (:id container)) (log/debug :msg "Sync component in local library" :component-id (:id container))) @@ -451,7 +451,7 @@ [changes libraries container shape-id reset? components-v2] (log/debug :msg "Sync shape direct" :shape (str shape-id) :reset? reset?) (let [shape-inst (ctn/get-shape container shape-id) - component (cph/get-component libraries + component (ctf/get-component libraries (:component-file shape-inst) (:component-id shape-inst)) component (or component @@ -588,7 +588,7 @@ [changes libraries container shape-id] (log/debug :msg "Sync shape inverse" :shape (str shape-id)) (let [shape-inst (ctn/get-shape container shape-id) - component (cph/get-component libraries + component (ctf/get-component libraries (:component-file shape-inst) (:component-id shape-inst)) shape-main (ctn/get-shape component (:shape-ref shape-inst)) @@ -618,7 +618,7 @@ (if (nil? shape-main) ;; This should not occur, but protect against it in any case changes - (let [component-container (cph/make-container component :component) + (let [component-container (ctn/make-container component :component) omit-touched? false set-remote-synced? (not initial-root?) @@ -825,7 +825,7 @@ :shapes all-parents})) changes' (reduce del-obj-change changes' new-shapes)] - (if (and (cph/touched-group? parent-shape :shapes-group) omit-touched?) + (if (and (ctk/touched-group? parent-shape :shapes-group) omit-touched?) changes changes'))) @@ -908,7 +908,7 @@ (defn- remove-shape [changes shape container omit-touched?] (log/info :msg (str "REMOVE-SHAPE " - (if (cph/page? container) "[P] " "[C] ") + (if (ctn/page? container) "[P] " "[C] ") (:name shape))) (let [objects (get container :objects) parents (cph/get-parent-ids objects (:id shape)) @@ -946,14 +946,14 @@ changes' (map :id children))] - (if (and (cph/touched-group? parent :shapes-group) omit-touched?) + (if (and (ctk/touched-group? parent :shapes-group) omit-touched?) changes changes'))) (defn- move-shape [changes shape index-before index-after container omit-touched?] (log/info :msg (str "MOVE " - (if (cph/page? container) "[P] " "[C] ") + (if (ctn/page? container) "[P] " "[C] ") (:name shape) " " index-before @@ -977,7 +977,7 @@ :index index-before :ignore-touched true})))] - (if (and (cph/touched-group? parent :shapes-group) omit-touched?) + (if (and (ctk/touched-group? parent :shapes-group) omit-touched?) changes changes'))) @@ -989,7 +989,7 @@ changes (do (log/info :msg (str "CHANGE-TOUCHED " - (if (cph/page? container) "[P] " "[C] ") + (if (ctn/page? container) "[P] " "[C] ") (:name dest-shape)) :options options) (let [new-touched (cond @@ -1024,7 +1024,7 @@ changes (do (log/info :msg (str "CHANGE-REMOTE-SYNCED? " - (if (cph/page? container) "[P] " "[C] ") + (if (ctn/page? container) "[P] " "[C] ") (:name shape)) :remote-synced? remote-synced?) (-> changes @@ -1054,7 +1054,7 @@ (log/info :msg (str "SYNC " (:name origin-shape) " -> " - (if (cph/page? container) "[P] " "[C] ") + (if (ctn/page? container) "[P] " "[C] ") (:name dest-shape))) (let [; To synchronize geometry attributes we need to make a prior @@ -1133,7 +1133,7 @@ (defn- make-change [container change] - (if (cph/page? container) + (if (ctn/page? container) (assoc change :page-id (:id container)) (assoc change :component-id (:id container)))) diff --git a/frontend/src/app/main/data/workspace/transforms.cljs b/frontend/src/app/main/data/workspace/transforms.cljs index 65b964082..902a5d080 100644 --- a/frontend/src/app/main/data/workspace/transforms.cljs +++ b/frontend/src/app/main/data/workspace/transforms.cljs @@ -16,12 +16,16 @@ [app.common.pages.changes-builder :as pcb] [app.common.pages.helpers :as cph] [app.common.spec :as us] + [app.common.types.component :as ctk] + [app.common.types.container :as ctn] [app.common.types.modifiers :as ctm] [app.common.types.shape-tree :as ctst] [app.common.types.shape.layout :as ctl] [app.common.uuid :as uuid] [app.main.data.workspace.changes :as dch] [app.main.data.workspace.collapse :as dwc] + [app.main.data.workspace.comments :as dwcm] + [app.main.data.workspace.guides :as dwg] [app.main.data.workspace.modifiers :as dwm] [app.main.data.workspace.selection :as dws] [app.main.data.workspace.state-helpers :as wsh] @@ -33,6 +37,110 @@ [cljs.spec.alpha :as s] [potok.core :as ptk])) +;; --- copies --------------------------- + +(defn- get-copies + "If one or more of the shapes belongs to a component's main instance, find all copies of + the component in the same page. + + Return a map { [ [ ...]] ...}" + [shapes objects modifiers] + (letfn [(get-copies-one [shape] + (let [root-shape (ctn/get-root-shape objects shape)] + (when (:main-instance? root-shape) + (let [children (->> root-shape + :shapes + (map #(get objects %)) + (map #(gsh/apply-modifiers % (get-in modifiers [(:id %) :modifiers])))) + root-shape (gsh/update-group-selrect root-shape children)] + [(:id root-shape) [root-shape (ctn/get-instances objects root-shape)]]))))] + + (into {} (map get-copies-one shapes)))) + +(defn- reposition-shape + [shape origin-root dest-root] + (let [shape-pos (fn [shape] + (gpt/point (get-in shape [:selrect :x]) + (get-in shape [:selrect :y]))) + + origin-root-pos (shape-pos origin-root) + dest-root-pos (shape-pos dest-root) + delta (gpt/subtract dest-root-pos origin-root-pos)] + (gsh/move shape delta))) + +(defn- sync-shape + [main-shape copy-shape copy-root main-root] + ;; (js/console.log "+++") + ;; (js/console.log "main-shape" (clj->js main-shape)) + ;; (js/console.log "copy-shape" (clj->js copy-shape)) + (if (ctk/touched-group? copy-shape :geometry-group) + {} + (let [main-shape (reposition-shape main-shape main-root copy-root) + + translation (gpt/subtract (gsh/orig-pos main-shape) + (gsh/orig-pos copy-shape)) + + center (gsh/orig-pos copy-shape) + mult-w (/ (gsh/width main-shape) (gsh/width copy-shape)) + mult-h (/ (gsh/height main-shape) (gsh/height copy-shape)) + resize (gpt/point mult-w mult-h)] + + (cond-> {} + (not (gpt/almost-zero? translation)) + (assoc :displacement (gmt/translate-matrix translation)) + + (not (gpt/close? resize (gpt/point 1 1))) + (assoc :resize-vector resize + :resize-origin center))))) + +(defn- process-text-modifiers + "For texts we only use the displacement because resize + needs to recalculate the text layout" + [shape modifiers] + modifiers) + ;; (cond-> modifiers + ;; (= :text (:type shape)) + ;; (select-keys [:displacement :rotation]))) + +(defn- add-copies-modifiers + "Add modifiers to all necessary shapes inside the copies" + [copies objects modifiers] + (letfn [(add-copy-modifiers-one [modifiers copy-shape copy-root main-root main-shapes main-shapes-modif] + (let [main-shape-modif (d/seek #(ctk/is-main-of? % copy-shape) main-shapes-modif) + modifier (cond-> (sync-shape main-shape-modif copy-shape copy-root main-root) + (some? (:rotation (get-in modifiers [(:id main-shape-modif) :modifiers]))) + (assoc :rotation (:rotation (get-in modifiers [(:id main-shape-modif) :modifiers]))) + )] + (if (seq modifier) + (assoc-in modifiers [(:id copy-shape) :modifiers] modifier) + modifiers))) + + (add-copy-modifiers [modifiers copy-root main-root main-shapes main-shapes-modif] + (let [copy-shapes (into [copy-root] (cph/get-children objects (:id copy-root)))] + (reduce #(add-copy-modifiers-one %1 %2 copy-root main-root main-shapes main-shapes-modif) + modifiers + copy-shapes))) + + (add-copies-modifiers-one [modifiers [main-root copy-roots]] + (let [main-shapes (into [main-root] (cph/get-children objects (:id main-root))) + main-shapes-modif (map (fn [shape] + (let [; shape (cond-> shape + ; (some? (:transform-inverse shape)) + ; (gsh/apply-transform (:transform-inverse shape))) + ] + (->> (get-in modifiers [(:id shape) :modifiers]) + (process-text-modifiers shape) + (gsh/apply-modifiers shape)))) + main-shapes)] + (reduce #(add-copy-modifiers %1 %2 main-root main-shapes main-shapes-modif) + modifiers + copy-roots)))] + + (reduce add-copies-modifiers-one + modifiers + (vals copies)))) + + ;; -- Helpers -------------------------------------------------------- ;; For each of the 8 handlers gives the multiplier for resize @@ -98,6 +206,241 @@ (update state :workspace-local dissoc :transform)))) +; === OJO: bloque posiblemente borrado +;; -- Temporary modifiers ------------------------------------------- + +;; During an interactive transformation of shapes (e.g. when resizing or rotating +;; a group with the mouse), there are a lot of objects that need to be modified +;; (in this case, the group and all its children). +;; +;; To avoid updating the shapes theirselves, and forcing redraw of all components +;; that depend on the "objects" global state, we set a "modifiers" structure, with +;; the changes that need to be applied, and store it in :workspace-modifiers global +;; variable. The viewport reads this and merges it into the objects list it uses to +;; paint the viewport content, redrawing only the objects that have new modifiers. +;; +;; When the interaction is finished (e.g. user releases mouse button), the +;; apply-modifiers event is done, that consolidates all modifiers into the base +;; geometric attributes of the shapes. + +(declare clear-local-transform) + +(declare get-ignore-tree) + +(defn set-modifiers + ([ids] + (set-modifiers ids nil false)) + + ([ids modifiers] + (set-modifiers ids modifiers false)) + + ([ids modifiers ignore-constraints] + (set-modifiers ids modifiers ignore-constraints false)) + + ([ids modifiers ignore-constraints ignore-snap-pixel] + (us/verify (s/coll-of uuid?) ids) + (ptk/reify ::set-modifiers + ptk/UpdateEvent + (update [_ state] + (let [objects (wsh/lookup-page-objects state) + ids (into #{} (remove #(get-in objects [% :blocked] false)) ids) + + snap-pixel? (and (not ignore-snap-pixel) + (contains? (:workspace-layout state) :snap-pixel-grid)) + + modif-tree + (gsh/set-objects-modifiers ids objects (constantly modifiers) ignore-constraints snap-pixel?) + + copies (get-copies (mapv (d/getf objects) ids) objects modif-tree) + + ;; TODO: mark new modifiers to be ignored in apply-modifiers + modif-tree (add-copies-modifiers copies objects modif-tree)] + + (update state :workspace-modifiers merge modif-tree)))))) + +;; (defn set-modifiers-raw +;; [modifiers] +;; (ptk/reify ::set-modifiers-raw +;; ptk/UpdateEvent +;; (update [_ state] +;; (update state :workspace-modifiers merge modifiers)))) + +;; Rotation use different algorithm to calculate children modifiers (and do not use child constraints). +(defn- set-rotation-modifiers + ([angle shapes] + (set-rotation-modifiers angle shapes (-> shapes gsh/selection-rect gsh/center-selrect))) + + ([angle shapes center] + (ptk/reify ::set-rotation-modifiers + ptk/UpdateEvent + (update [_ state] + (let [objects (wsh/lookup-page-objects state) + ids + (->> shapes + (remove #(get % :blocked false)) + (mapcat #(cph/get-children objects (:id %))) + (concat shapes) + (filter #((cpc/editable-attrs (:type %)) :rotation)) + (map :id)) + + get-modifier + (fn [shape] + (gsh/rotation-modifiers shape center angle)) + + modif-tree + (gsh/set-objects-modifiers ids objects get-modifier false false)] + + (update state :workspace-modifiers merge modif-tree)))))) + +(defn- update-grow-type + [shape old-shape] + (let [auto-width? (= :auto-width (:grow-type shape)) + auto-height? (= :auto-height (:grow-type shape)) + + changed-width? (not (mth/close? (:width shape) (:width old-shape))) + changed-height? (not (mth/close? (:height shape) (:height old-shape))) + + change-to-fixed? (or (and auto-width? (or changed-height? changed-width?)) + (and auto-height? changed-height?))] + (cond-> shape + change-to-fixed? + (assoc :grow-type :fixed)))) + +(defn apply-modifiers + ([] + (apply-modifiers nil)) + + ([{:keys [undo-transation?] :or {undo-transation? true}}] + (ptk/reify ::apply-modifiers + ptk/WatchEvent + (watch [_ state _] + (let [objects (wsh/lookup-page-objects state) + object-modifiers (get state :workspace-modifiers) + + ids (keys object-modifiers) + ids-with-children (into (vec ids) (mapcat #(cph/get-children-ids objects %)) ids) + + shapes (map (d/getf objects) ids) + ignore-tree (->> (map #(get-ignore-tree object-modifiers objects %) shapes) + (reduce merge {}))] + + (rx/concat + (if undo-transation? + (rx/of (dwu/start-undo-transaction)) + (rx/empty)) + (rx/of (ptk/event ::dwg/move-frame-guides ids-with-children) + (ptk/event ::dwcm/move-frame-comment-threads ids-with-children) + (dch/update-shapes + ids + (fn [shape] + (let [modif (get object-modifiers (:id shape)) + text-shape? (cph/text-shape? shape)] + (-> shape + (merge modif) + (gsh/transform-shape) + (cond-> text-shape? + (update-grow-type shape))))) + {:reg-objects? true + :ignore-tree ignore-tree + ;; Attributes that can change in the transform. This way we don't have to check + ;; all the attributes + :attrs [:selrect + :points + :x + :y + :width + :height + :content + :transform + :transform-inverse + :rotation + :position-data + :flip-x + :flip-y + :grow-type]}) + (clear-local-transform)) + (if undo-transation? + (rx/of (dwu/commit-undo-transaction)) + (rx/empty)))))))) + +(defn- check-delta + "If the shape is a component instance, check its relative position respect the + root of the component, and see if it changes after applying a transformation." + [shape root transformed-shape transformed-root objects modif-tree] + (let [root + (cond + (:component-root? shape) + shape + + (nil? root) + (ctn/get-root-shape objects shape) + + :else root) + + transformed-root + (cond + (:component-root? transformed-shape) + transformed-shape + + (nil? transformed-root) + (as-> (ctn/get-root-shape objects transformed-shape) $ + (gsh/transform-shape (merge $ (get modif-tree (:id $))))) + + :else transformed-root) + + shape-delta + (when root + (gpt/point (- (gsh/left-bound shape) (gsh/left-bound root)) + (- (gsh/top-bound shape) (gsh/top-bound root)))) + + transformed-shape-delta + (when transformed-root + (gpt/point (- (gsh/left-bound transformed-shape) (gsh/left-bound transformed-root)) + (- (gsh/top-bound transformed-shape) (gsh/top-bound transformed-root)))) + + ;; There are cases in that the coordinates change slightly (e.g. when + ;; rounding to pixel, or when recalculating text positions in different + ;; zoom levels). To take this into account, we ignore movements smaller + ;; than 1 pixel. + distance (if (and shape-delta transformed-shape-delta) + (gpt/distance-vector shape-delta transformed-shape-delta) + (gpt/point 0 0)) + + ignore-geometry? (and (< (:x distance) 1) (< (:y distance) 1))] + + [root transformed-root ignore-geometry?])) + +(defn- get-ignore-tree + "Retrieves a map with the flag `ignore-geometry?` given a tree of modifiers" + ([modif-tree objects shape] + (get-ignore-tree modif-tree objects shape nil nil {})) + + ([modif-tree objects shape root transformed-root ignore-tree] + (let [children (map (d/getf objects) (:shapes shape)) + + shape-id (:id shape) + transformed-shape (gsh/transform-shape (merge shape (get modif-tree shape-id))) + + [root transformed-root ignore-geometry?] + (check-delta shape root transformed-shape transformed-root objects modif-tree) + + ignore-tree (assoc ignore-tree shape-id ignore-geometry?) + + set-child + (fn [ignore-tree child] + (get-ignore-tree modif-tree objects child root transformed-root ignore-tree))] + + (reduce set-child ignore-tree children)))) + +(defn- clear-local-transform [] + (ptk/reify ::clear-local-transform + ptk/UpdateEvent + (update [_ state] + (-> state + (dissoc :workspace-modifiers) + (dissoc ::current-move-selected))))) + +; === OJO: fin bloque ;; -- Resize -------------------------------------------------------- (defn start-resize diff --git a/frontend/src/app/main/ui/workspace/shapes/frame/dynamic_modifiers.cljs b/frontend/src/app/main/ui/workspace/shapes/frame/dynamic_modifiers.cljs index 21bef0046..be29339fa 100644 --- a/frontend/src/app/main/ui/workspace/shapes/frame/dynamic_modifiers.cljs +++ b/frontend/src/app/main/ui/workspace/shapes/frame/dynamic_modifiers.cljs @@ -11,12 +11,18 @@ [app.common.geom.matrix :as gmt] [app.common.geom.point :as gpt] [app.common.geom.shapes :as gsh] + [app.common.math :as mth] + [app.common.pages.helpers :as cph] ; TODO: move this to ctst + [app.common.types.component :as ctk] + [app.common.types.container :as ctn] [app.common.types.modifiers :as ctm] + [app.main.data.workspace.transforms :as dwt] [app.main.store :as st] [app.main.ui.hooks :as hooks] [app.main.ui.workspace.viewport.utils :as vwu] [app.util.dom :as dom] [app.util.globals :as globals] + [app.util.timers :as tm] [rumext.v2 :as mf])) (defn get-shape-node @@ -190,14 +196,228 @@ (-> modifiers (ctm/resize scalev (-> shape' :points first) (:transform shape') (:transform-inverse shape'))))) +(defn- get-copies + "If one or more of the shapes belongs to a component's main instance, find all copies of + the component in the same page. + + Return a map { [ [ ...]] ...}" + [shapes objects modifiers] + (letfn [(get-copies-one [shape] + (let [root-shape (ctn/get-root-shape objects shape)] + (when (:main-instance? root-shape) + (let [children (->> root-shape + :shapes + (map #(get objects %)) + (map #(gsh/apply-modifiers % (get-in modifiers [(:id %) :modifiers])))) + root-shape (gsh/update-group-selrect root-shape children)] + [(:id root-shape) [root-shape (ctn/get-instances objects root-shape)]]))))] + + (into {} (map get-copies-one shapes)))) + +(defn- reposition-shape + [shape origin-root dest-root] + (let [shape-pos (fn [shape] + (gpt/point (get-in shape [:selrect :x]) + (get-in shape [:selrect :y]))) + + origin-root-pos (shape-pos origin-root) + dest-root-pos (shape-pos dest-root) + delta (gpt/subtract dest-root-pos origin-root-pos)] + (gsh/move shape delta))) + +(defn- sync-shape + [main-shape copy-shape copy-root main-root] + ;; (js/console.log "+++") + ;; (js/console.log "main-shape" (clj->js main-shape)) + ;; (js/console.log "copy-shape" (clj->js copy-shape)) + (if (ctk/touched-group? copy-shape :geometry-group) + {} + (let [main-shape (reposition-shape main-shape main-root copy-root) + + translation (gpt/subtract (gsh/orig-pos main-shape) + (gsh/orig-pos copy-shape)) + + center (gsh/orig-pos copy-shape) + mult-w (/ (gsh/width main-shape) (gsh/width copy-shape)) + mult-h (/ (gsh/height main-shape) (gsh/height copy-shape)) + resize (gpt/point mult-w mult-h)] + + (cond-> {} + (not (gpt/almost-zero? translation)) + (assoc :displacement (gmt/translate-matrix translation)) + + (not (gpt/close? resize (gpt/point 1 1))) + (assoc :resize-vector resize + :resize-origin center))))) + +;; (defn- sync-shape +;; [main-shape copy-shape copy-root main-root] +;; ;; (js/console.log "+++") +;; ;; (js/console.log "main-shape" (clj->js main-shape)) +;; ;; (js/console.log "copy-shape" (clj->js copy-shape)) +;; (if (ctk/touched-group? copy-shape :geometry-group) +;; (gmt/matrix) +;; (let [main-shape (reposition-shape main-shape main-root copy-root) +;; +;; translation (gpt/subtract (gsh/orig-pos main-shape) +;; (gsh/orig-pos copy-shape)) +;; +;; center (gsh/orig-pos copy-shape) +;; mult-w (/ (gsh/width main-shape) (gsh/width copy-shape)) +;; mult-h (/ (gsh/height main-shape) (gsh/height copy-shape)) +;; resize (gpt/point mult-w mult-h)] +;; +;; (cond-> (gmt/matrix) +;; (not (gpt/almost-zero? translation)) +;; (gmt/multiply (gmt/translate-matrix translation)) +;; +;; (not (gpt/almost-zero? resize)) +;; (gmt/multiply (gmt/scale-matrix resize center)))))) + +(defn- process-text-modifiers + "For texts we only use the displacement because resize + needs to recalculate the text layout" + [shape modifiers] + (cond-> modifiers + (= :text (:type shape)) + (select-keys [:displacement :rotation]))) + +(defn- add-copies-modifiers + "Add modifiers to all necessary shapes inside the copies" + [copies objects modifiers] + ;; (js/console.log "copies" (clj->js copies)) + (letfn [(add-copy-modifiers-one [modifiers copy-shape copy-root main-root main-shapes main-shapes-modif] + ;; (assert (not (contains? modifiers (:id copy-shape))) "Si peta esto, we have a problem") + (let [main-shape-modif (d/seek #(ctk/is-main-of? % copy-shape) main-shapes-modif) + ;; copy-shape (cond-> copy-shape + ;; (some? (:transform-inverse copy-shape)) + ;; (gsh/apply-transform (:transform-inverse copy-shape))) + modifier (cond-> (sync-shape main-shape-modif copy-shape copy-root main-root) + (some? (:rotation (get-in modifiers [(:id main-shape-modif) :modifiers]))) + (assoc :rotation (:rotation (get-in modifiers [(:id main-shape-modif) :modifiers]))) + )] + (if (seq modifier) + (assoc-in modifiers [(:id copy-shape) :modifiers] modifier) + modifiers))) + + ;; $$$ + ;; (add-copy-modifiers-one [modifiers copy-shape copy-root main-root main-shapes main-shapes-modif] + ;; (update modifiers (:id copy-shape) + ;; (fn [modifier] + ;; (let [modifier (or modifier (gmt/matrix)) + ;; main-shape-modif (d/seek #(ctk/is-main-of? % copy-shape) main-shapes-modif)] + ;; (gmt/multiply modifier (sync-shape main-shape-modif copy-shape copy-root main-root)))))) + + (add-copy-modifiers [modifiers copy-root main-root main-shapes main-shapes-modif] + (let [copy-shapes (into [copy-root] (cph/get-children objects (:id copy-root)))] + (reduce #(add-copy-modifiers-one %1 %2 copy-root main-root main-shapes main-shapes-modif) + modifiers + copy-shapes))) + + (add-copies-modifiers-one [modifiers [main-root copy-roots]] + (let [main-shapes (into [main-root] (cph/get-children objects (:id main-root))) + main-shapes-modif (map (fn [shape] + (let [; shape (cond-> shape + ; (some? (:transform-inverse shape)) + ; (gsh/apply-transform (:transform-inverse shape))) + ] + (->> (get-in modifiers [(:id shape) :modifiers]) + (process-text-modifiers shape) + (gsh/apply-modifiers shape)))) + main-shapes)] + (reduce #(add-copy-modifiers %1 %2 main-root main-shapes main-shapes-modif) + modifiers + copy-roots)))] + + (reduce add-copies-modifiers-one + modifiers + (vals copies)))) + +;; $$$ +;; (defn- add-copies-transforms +;; "Add transform to all necessary shapes inside the copies" +;; [copies objects modifiers transforms] +;; ;; (js/console.log "copies" (clj->js copies)) +;; (letfn [(add-copy-transforms-one [transforms copy-shape copy-root main-root main-shapes main-shapes-modif] +;; (update transforms (:id copy-shape) +;; (fn [transform] +;; (let [transform (or transform (gmt/matrix)) +;; main-shape-modif (d/seek #(ctk/is-main-of? % copy-shape) main-shapes-modif)] +;; (gmt/multiply transform (sync-shape main-shape-modif copy-shape copy-root main-root)))))) +;; +;; (add-copy-transforms [transforms copy-root main-root main-shapes main-shapes-modif] +;; (let [copy-shapes (into [copy-root] (cph/get-children objects (:id copy-root)))] +;; (reduce #(add-copy-transforms-one %1 %2 copy-root main-root main-shapes main-shapes-modif) +;; transforms +;; copy-shapes))) +;; +;; (add-copies-transforms-one [transforms [main-root copy-roots]] +;; (let [main-shapes (into [main-root] (cph/get-children objects (:id main-root))) +;; main-shapes-modif (map (fn [shape] +;; (->> (get-in modifiers [(:id shape) :modifiers]) +;; (process-text-modifiers shape) +;; (gsh/apply-modifiers shape))) +;; main-shapes)] +;; (reduce #(add-copy-transforms %1 %2 main-root main-shapes main-shapes-modif) +;; transforms +;; copy-roots)))] +;; +;; (reduce add-copies-transforms-one +;; transforms +;; (vals copies)))) + +;; (defn get-copy-shapes +;; "If one or more of the shapes belongs to a component's main instance, find all copies of +;; the component in the same page. Ignore copies with the geometry values touched." +;; [shapes objects] +;; (letfn [(get-copy-shapes-one [shape] +;; (let [root-shape (ctn/get-root-shape objects shape)] +;; (when (:main-instance? root-shape) +;; (->> (ctn/get-instances objects shape) +;; (filter #(not (ctk/touched-group? % :geometry-group))))))) +;; +;; (pack-main-copies [shape] +;; (map #(vector shape %) (get-copy-shapes-one shape)))] +;; +;; (mapcat pack-main-copies shapes))) + (defn use-dynamic-modifiers [objects node modifiers] - (let [transforms + (let [prev-shapes (mf/use-var nil) + prev-modifiers (mf/use-var nil) + prev-transforms (mf/use-var nil) + ;; prev-copies (mf/use-var nil) + + ;; copies + ;; (mf/use-memo ; TODO: ojo estas deps hay que revisarlas + ;; (mf/deps modifiers (and (d/not-empty? @prev-modifiers) (d/not-empty? modifiers))) + ;; (fn [] + ;; (let [shapes (->> (keys modifiers) + ;; (mapv (d/getf objects)))] + ;; (get-copies shapes objects modifiers)))) + + ;; modifiers + ;; (mf/use-memo + ;; (mf/deps objects modifiers copies @prev-copies) + ;; (fn [] + ;; (if (= (count copies) (count @prev-copies)) + ;; modifiers + ;; (let [new-modifiers (add-copies-modifiers copies objects modifiers)] + ;; (js/console.log "==================") + ;; (js/console.log "modifiers (antes)" (clj->js modifiers)) + ;; (js/console.log "copies" (clj->js copies)) + ;; (js/console.log "modifiers (después)" (clj->js new-modifiers)) + ;; (when (seq new-modifiers) + ;; (tm/schedule #(st/emit! (dwt/set-modifiers-raw new-modifiers)))) + ;; new-modifiers)))) + + transforms (mf/use-memo (mf/deps modifiers) (fn [] - (when (some? modifiers) + ;; (js/console.log "****modifiers" (clj->js modifiers)) + (when (seq modifiers) (d/mapm (fn [id {modifiers :modifiers}] (let [shape (get objects id) adapt-text? (and (= :text (:type shape)) (not (ctm/only-move? modifiers))) @@ -213,13 +433,195 @@ (mf/use-memo (mf/deps transforms) (fn [] + ;; (js/console.log "transforms" (clj->js transforms)) (->> (keys transforms) (filter #(some? (get transforms %))) (mapv (d/getf objects))))) - prev-shapes (mf/use-var nil) - prev-modifiers (mf/use-var nil) - prev-transforms (mf/use-var nil)] + ;; $$$ + ;; transforms + ;; (mf/use-memo + ;; (mf/deps objects modifiers transforms copies) + ;; (fn [] + ;; ;; (js/console.log "modifiers" (clj->js modifiers)) + ;; (add-copies-transforms copies objects modifiers transforms))) + + ;; copy-shapes + ;; (mf/use-memo + ;; (mf/deps (and (d/not-empty? @prev-modifiers) (d/not-empty? modifiers))) + ;; (fn [] + ;; (get-copy-shapes shapes objects))) + + ;; transforms + ;; (mf/use-memo + ;; (mf/deps objects modifiers transforms copy-shapes) + ;; (fn [] + ;; (let [add-copy-transforms + ;; (fn [transforms main-shape copy-shape] + ;; (let [main-bounds (gsh/bounding-box main-shape) + ;; copy-bounds (gsh/bounding-box copy-shape) + ;; delta (gpt/subtract (gpt/point (:x copy-bounds) (:y copy-bounds)) + ;; (gpt/point (:x main-bounds) (:y main-bounds))) + ;; + ;; ;; Move the modifier origin points to the position of the copy. + ;; main-modifiers (get-in modifiers [(:id main-shape) :modifiers]) + ;; copy-modifiers (let [origin (:resize-origin main-modifiers) + ;; origin-2 (:resize-origin-2 main-modifiers)] + ;; (cond-> main-modifiers + ;; (some? origin) + ;; (assoc :resize-origin (gpt/add origin delta)) + ;; + ;; (some? origin-2) + ;; (assoc :resize-origin-2 (gpt/add origin-2 delta)))) + ;; + ;; center (gsh/center-shape copy-shape)] + ;; + ;; (update transforms (:id copy-shape) + ;; #(let [transform (or % (gmt/matrix))] + ;; (gmt/multiply transform + ;; (gsh/modifiers->transform center copy-modifiers)))))) + ;; + ;; apply-delta + ;; (fn [transforms shape-id delta] + ;; (let [shape-ids (-> (cph/get-children-ids objects shape-id) + ;; (conj shape-id)) + ;; + ;; add-delta (fn [transform] + ;; (let [transform (or transform (gmt/matrix))] + ;; (gmt/multiply transform (gmt/translate-matrix delta))))] + ;; + ;; (reduce #(update %1 %2 add-delta) + ;; transforms + ;; shape-ids))) + ;; + ;; manage-root + ;; (fn [transforms main-shape copy-shape] + ;; (let [main-modifiers (get-in modifiers [(:id main-shape) :modifiers]) + ;; modified-main (gsh/apply-modifiers main-shape main-modifiers) + ;; + ;; delta (gpt/subtract (gsh/orig-pos main-shape) + ;; (gsh/orig-pos modified-main))] + ;; + ;; (cond-> transforms + ;; (not (gpt/almost-zero? delta)) + ;; (apply-delta (:id copy-shape) delta)))) + ;; + ;; manage-nonroot + ;; (fn [transforms main-shape copy-shape] + ;; ; TODO: comparar el orig-pos de la main-shape modificada con el del su propio + ;; ; root también modificado (antes de rotación). Si es menor que cero en alguno + ;; ; de los dos ejes, añadir un desplazamiento al root y todos sus hijos + ;; (let [main-root (ctn/get-root-shape objects main-shape) + ;; main-root-modifiers (get-in modifiers [(:id main-root) :modifiers]) + ;; modified-main-root (gsh/apply-modifiers main-root main-root-modifiers) + ;; + ;; main-shape-modifiers (get-in modifiers [(:id main-shape) :modifiers]) + ;; modified-main-shape (gsh/apply-modifiers main-shape main-shape-modifiers) + ;; + ;; delta (gpt/subtract (gsh/orig-pos modified-main-shape) + ;; (gsh/orig-pos modified-main-root)) + ;; + ;; delta-x (- (min 0 (:x delta))) + ;; delta-y (- (min 0 (:y delta)))] + ;; + ;; (if (or (pos? delta-x) (pos? delta-y)) + ;; (let [copy-root (ctn/get-root-shape objects copy-shape)] + ;; (apply-delta transforms (:id copy-root) (gpt/point delta-x delta-y))) + ;; transforms))) + ;; + ;; add-all-transforms + ;; (fn [transforms [main-shape copy-shape]] + ;; ;; (js/console.log "----------------------") + ;; ;; (js/console.log "main-shape" (clj->js main-shape)) + ;; ;; (js/console.log "copy-shape" (clj->js copy-shape)) + ;; (as-> transforms $ + ;; (add-copy-transforms $ main-shape copy-shape) + ;; (if (ctk/instance-root? main-shape) + ;; (manage-root $ main-shape copy-shape) + ;; (manage-nonroot $ main-shape copy-shape))))] + ;; + ;; ;; (js/console.log "==================") + ;; (reduce add-all-transforms + ;; transforms + ;; copy-shapes)))) + + ;; ---- old + + ;; (let [translate1 + ;; (fn [shape modifiers] + ;; (let [root-shape (ctn/get-root-shape objects shape) + ;; root-pos (gsh/orig-pos root-shape) + ;; + ;; modified-shape (gsh/apply-modifiers shape modifiers) + ;; modified-pos (gsh/orig-pos modified-shape)] + ;; ;; (js/console.log "root-pos" (clj->js root-pos)) + ;; ;; (js/console.log "modified-pos" (clj->js modified-pos)) + ;; (if (or (< (:x modified-pos) (:x root-pos)) + ;; (< (:y modified-pos) (:y root-pos))) + ;; (let [displacement (get modifiers :displacement (gmt/matrix)) + ;; delta (gpt/point (max 0 (- (:x root-pos) (:x modified-pos))) + ;; (max 0 (- (:y root-pos) (:y modified-pos))))] + ;; [(assoc modifiers :displacement + ;; (gmt/add-translate displacement + ;; (gmt/translate-matrix delta))) + ;; delta]) + ;; [modifiers (gpt/point 0 0)]))) + ;; + ;; get-copy-transform + ;; (fn [[main-shape copy-shape]] + ;; (js/console.log "----------------------") + ;; (js/console.log "main-shape" (clj->js main-shape)) + ;; (js/console.log "copy-shape" (clj->js copy-shape)) + ;; (let [[main-modifiers deltaa] (->> (get-in modifiers [(:id main-shape) :modifiers]) + ;; (translate1 main-shape)) + ;; + ;; main-bounds (gsh/bounding-box main-shape) + ;; copy-bounds (gpt/add (gpt/point + ;; (:x (gsh/bounding-box copy-shape)) + ;; (:y (gsh/bounding-box copy-shape))) + ;; deltaa) + ;; delta (gpt/subtract (gpt/point (:x copy-bounds) (:y copy-bounds)) + ;; (gpt/point (:x main-bounds) (:y main-bounds))) + ;; + ;; root-shape (ctn/get-root-shape objects main-shape) + ;; root-modifiers (get-in modifiers [(:id root-shape) :modifiers]) + ;; _ (js/console.log "main-modifiers" (clj->js main-modifiers)) + ;; _ (js/console.log "root-modifiers" (clj->js root-modifiers)) + ;; + ;; ;; root-shape (ctn/get-root-shape objects copy-shape) + ;; ;; root-pos (gsh/orig-pos root-shape) + ;; ;; copy-pos (gsh/orig-pos copy-shape) + ;; + ;; ;; Move the modifier origin points to the position of the copy. + ;; copy-modifiers (let [origin (:resize-origin main-modifiers) + ;; origin-2 (:resize-origin-2 main-modifiers)] + ;; (cond-> main-modifiers + ;; (some? origin) + ;; (assoc :resize-origin (gpt/add origin delta)) + ;; + ;; (some? origin-2) + ;; (assoc :resize-origin-2 (gpt/add origin-2 delta)) + ;; + ;; ;; (gpt/close? root-pos copy-pos) + ;; ;; (dissoc :displacement) + ;; )) + ;; + ;; center (gsh/center-shape copy-shape)] + ;; + ;; ;; (js/console.log "delta" (clj->js delta)) + ;; ;; (js/console.log "main-modifiers" (clj->js main-modifiers)) + ;; ;; (js/console.log "main-transform" (str (gsh/modifiers->transform + ;; ;; (gsh/center-shape main-shape) + ;; ;; main-modifiers))) + ;; ;; (js/console.log "copy-modifiers" (clj->js copy-modifiers)) + ;; ;; (js/console.log "copy-transform" (str (gsh/modifiers->transform + ;; ;; center copy-modifiers))) + ;; (gsh/modifiers->transform center copy-modifiers)))] + ;; + ;; (reduce #(assoc %1 (:id (second %2)) (get-copy-transform %2)) + ;; transforms + ;; copy-shapes)))) + ] (mf/use-effect (mf/deps add-children) @@ -265,6 +667,8 @@ (when (d/not-empty? removed-shapes) (remove-transform! node @prev-shapes))) - (reset! prev-modifiers modifiers) - (reset! prev-transforms transforms) - (reset! prev-shapes shapes))))) + (reset! prev-modifiers modifiers) + (reset! prev-transforms transforms) + (reset! prev-shapes shapes) + ;; (reset! prev-copies copies) + )))) diff --git a/frontend/test/frontend_tests/helpers/libraries.cljs b/frontend/test/frontend_tests/helpers/libraries.cljs index c00776136..001441096 100644 --- a/frontend/test/frontend_tests/helpers/libraries.cljs +++ b/frontend/test/frontend_tests/helpers/libraries.cljs @@ -9,6 +9,7 @@ [app.common.pages.helpers :as cph] [app.common.types.component :as ctk] [app.common.types.container :as ctn] + [app.common.types.file :as ctf] [app.main.data.workspace.state-helpers :as wsh] [cljs.pprint :refer [pprint]] [cljs.test :as t :include-macros true] @@ -91,7 +92,7 @@ root-inst (ctn/get-shape page root-inst-id) libs (wsh/get-libraries state) - component (cph/get-component libs (:component-id root-inst)) + component (ctf/get-component libs (:component-id root-inst)) shapes-inst (cph/get-children-with-self (:objects page) root-inst-id) shapes-main (cph/get-children-with-self (:objects component) (:shape-ref root-inst)) @@ -100,10 +101,10 @@ main-exists? (fn [shape] (let [component-shape - (cph/get-component-shape (:objects page) shape) + (ctn/get-component-shape (:objects page) shape) component - (cph/get-component libs (:component-id component-shape)) + (ctf/get-component libs (:component-id component-shape)) main-shape (ctn/get-shape component (:shape-ref shape))] @@ -131,7 +132,7 @@ root-inst (ctn/get-shape page root-inst-id) libs (wsh/get-libraries state) - component (cph/get-component libs (:component-id root-inst)) + component (ctf/get-component libs (:component-id root-inst)) shapes-inst (cph/get-children-with-self (:objects page) root-inst-id) shapes-main (cph/get-children-with-self (:objects component) (:shape-ref root-inst)) @@ -140,10 +141,10 @@ main-exists? (fn [shape] (let [component-shape - (cph/get-component-shape (:objects page) shape) + (ctn/get-component-shape (:objects page) shape) component - (cph/get-component libs (:component-id component-shape)) + (ctf/get-component libs (:component-id component-shape)) main-shape (ctn/get-shape component (:shape-ref shape))] @@ -160,7 +161,7 @@ [state component-id] (let [page (thp/current-page state) libs (wsh/get-libraries state) - component (cph/get-component libs component-id) + component (ctf/get-component libs component-id) root-main (ctk/get-component-root component) shapes-main (cph/get-children-with-self (:objects component) (:id root-main))] diff --git a/frontend/test/frontend_tests/state_components_test.cljs b/frontend/test/frontend_tests/state_components_test.cljs index 86a4a56d6..b11acc919 100644 --- a/frontend/test/frontend_tests/state_components_test.cljs +++ b/frontend/test/frontend_tests/state_components_test.cljs @@ -302,7 +302,7 @@ ; Renamed component ; Rect-1 (let [libs (wsh/get-libraries new-state) - component (cph/get-component libs + component (ctf/get-component libs (:component-file instance1) (:component-id instance1))] (t/is (= (:name component) @@ -400,7 +400,7 @@ (:id instance1)) libs (wsh/get-libraries new-state) - component (cph/get-component libs + component (ctf/get-component libs (:component-file instance1) (:component-id instance1))]