Merge remote-tracking branch 'origin/staging' into develop

common/src/app/common/types/container.cljc

@@ -509,6 +509,7 @@
                                           (every? nil?)))]
     (or
       ;;We don't want to change the structure of component copies
+     (ctk/in-component-copy? parent)
      (has-any-copy-parent? objects parent)
       ;; If we are moving something containing a main instance the container can't be part of a component (neither main nor copy)
      (and selected-main-instance? parent-in-component?)

frontend/src/app/main/data/workspace.cljs

@@ -682,12 +682,12 @@
 
 (defn end-rename-shape
   "End the ongoing shape rename process"
-  ([] (end-rename-shape nil))
+  ([] (end-rename-shape nil nil))
-  ([name]
+  ([shape-id name]
    (ptk/reify ::end-rename-shape
      ptk/WatchEvent
      (watch [_ state _]
-       (when-let [shape-id (dm/get-in state [:workspace-local :shape-for-rename])]
+       (when-let [shape-id (d/nilv shape-id (dm/get-in state [:workspace-local :shape-for-rename]))]
          (let [shape (wsh/lookup-shape state shape-id)
                name        (str/trim name)
                clean-name  (cfh/clean-path name)

frontend/src/app/main/data/workspace/colors.cljs

@@ -602,9 +602,11 @@
                     (update-in state [:stops stop] (fn [data] (->> changes
                                                                    (merge data)
                                                                    (materialize-color-components))))
+
                     (-> state
                         (dissoc :gradient :stops :editing-stop)
-                        (assoc :type :color)))))))
+                        (cond-> (not= :image (:type state))
+                          (assoc :type :color))))))))
     ptk/WatchEvent
     (watch [_ state _]
       (when add-recent?

frontend/src/app/main/data/workspace/shapes.cljs

@@ -387,7 +387,7 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defn update-shape-flags
-  [ids {:keys [blocked hidden transforming undo-group] :as flags}]
+  [ids {:keys [blocked hidden undo-group] :as flags}]
   (dm/assert!
    "expected valid coll of uuids"
    (every? uuid? ids))
@@ -403,15 +403,14 @@
             (fn [obj]
               (cond-> obj
                 (boolean? blocked) (assoc :blocked blocked)
-                (boolean? hidden) (assoc :hidden hidden)
+                (boolean? hidden) (assoc :hidden hidden)))
-                (boolean? transforming) (assoc :transforming transforming)))
             objects (wsh/lookup-page-objects state)
             ;; We have change only the hidden behaviour, to hide only the
             ;; selected shape, block behaviour remains the same.
             ids     (if (boolean? blocked)
                       (into ids (->> ids (mapcat #(cfh/get-children-ids objects %))))
                       ids)]
-        (rx/of (dch/update-shapes ids update-fn {:attrs #{:blocked :hidden :transforming} :undo-group undo-group}))))))
+        (rx/of (dch/update-shapes ids update-fn {:attrs #{:blocked :hidden} :undo-group undo-group}))))))
 
 (defn toggle-visibility-selected
   []

frontend/src/app/main/data/workspace/transforms.cljs

@@ -28,7 +28,6 @@
    [app.main.data.workspace.collapse :as dwc]
    [app.main.data.workspace.modifiers :as dwm]
    [app.main.data.workspace.selection :as dws]
-   [app.main.data.workspace.shapes :as dwsh]
    [app.main.data.workspace.state-helpers :as wsh]
    [app.main.data.workspace.undo :as dwu]
    [app.main.snap :as snap]
@@ -291,10 +290,10 @@
     ptk/WatchEvent
     (watch [_ _ stream]
       (rx/concat
-       (rx/of (dwsh/update-shape-flags ids {:transforming true}))
+       (rx/of #(assoc-in % [:workspace-local :transform] :move))
        (->> (rx/timer 1000)
             (rx/map (fn []
-                      (dwsh/update-shape-flags ids {:transforming false})))
+                      #(assoc-in % [:workspace-local :transform] nil)))
             (rx/take-until
              (rx/filter (ptk/type? ::trigger-bounding-box-cloaking) stream)))))))
 

frontend/src/app/main/ui/components/editable_label.scss

@@ -20,12 +20,8 @@
   color: var(--input-foreground-color-active);
 }
 
-.editable-label {
+.editable-label.is-hidden {
-  display: flex;
+  display: none;
-
-  &.is-hidden {
-    display: none;
-  }
 }
 
 .editable-label-close {

frontend/src/app/main/ui/dashboard/projects.scss

@@ -85,6 +85,9 @@
   line-height: 0.8;
   color: var(--title-foreground-color-hover);
   cursor: pointer;
+  height: $s-16;
+  display: inline-flex;
+  align-items: center;
 }
 
 .info-wrapper {

frontend/src/app/main/ui/workspace/sidebar/layer_name.cljs

@@ -51,21 +51,21 @@
 
         accept-edit
         (mf/use-fn
-         (mf/deps on-stop-edit)
+         (mf/deps shape-id on-stop-edit)
          (fn []
            (let [name-input     (mf/ref-val ref)
                  name           (str/trim (dom/get-value name-input))]
              (on-stop-edit)
              (reset! edition* false)
-             (st/emit! (dw/end-rename-shape name)))))
+             (st/emit! (dw/end-rename-shape shape-id name)))))
 
         cancel-edit
         (mf/use-fn
-         (mf/deps on-stop-edit)
+         (mf/deps shape-id on-stop-edit)
          (fn []
            (on-stop-edit)
            (reset! edition* false)
-           (st/emit! (dw/end-rename-shape nil))))
+           (st/emit! (dw/end-rename-shape shape-id nil))))
 
         on-key-down
         (mf/use-fn

frontend/src/app/main/ui/workspace/viewport/outline.cljs

@@ -113,8 +113,7 @@
 (defn- show-outline?
   [shape]
   (and (not (:hidden shape))
-       (not (:blocked shape))
+       (not (:blocked shape))))
-       (not (:transforming shape))))
 
 (mf/defc shape-outlines
   {::mf/wrap-props false}

frontend/src/app/main/ui/workspace/viewport/selection.cljs

@@ -36,6 +36,8 @@
 (def selection-rect-width 1)
 (def min-selrect-side 10)
 (def small-selrect-side 30)
+(def min-selrect-width 10)
+(def min-selrect-height 10)
 
 (mf/defc selection-rect
   {::mf/wrap-props false}
@@ -43,12 +45,27 @@
   (let [x      (dm/get-prop rect :x)
         y      (dm/get-prop rect :y)
         width  (dm/get-prop rect :width)
-        height (dm/get-prop rect :height)]
+        height (dm/get-prop rect :height)
+
+        ;; This is a calculation to create a "minimum" interactable rect
+        ;; Is necesary so that small shapes in x/y (like lines) can be moved
+        ;; better
+        [x width]
+        (if (< width (/ min-selrect-width zoom))
+          (let [width' (/ min-selrect-width zoom)]
+            [(- x (/ (- width' width) 2)) width'])
+          [x width])
+
+        [y height]
+        (if (< height (/ min-selrect-height zoom))
+          (let [height' (/ min-selrect-height zoom)]
+            [(- y (/ (- height' height) 2)) height'])
+          [y height])]
     [:rect.main.viewport-selrect
      {:x x
       :y y
-      :width width
+      :width (max width (/ 10 zoom))
-      :height height
+      :height (max height (/ 10 zoom))
       :transform (str transform)
       :on-pointer-down on-move-selected
       :on-context-menu on-context-menu
@@ -304,7 +321,6 @@
         transform      (gsh/transform-str shape)]
 
     (when (and (some? selrect)
-               (not (:transforming shape))
                (not (or (= transform-type :move)
                         (= transform-type :rotate))))
       [:g.controls {:pointer-events (if ^boolean disable-handlers "none" "visible")}
@@ -339,7 +355,6 @@
                            (and flip-y (not flip-x)))]
 
     (when (and (not ^boolean read-only?)
-               (not (:transforming shape))
                (not (or (= transform-type :move)
                         (= transform-type :rotate))))