✨ Improved hover behavior

common/src/app/common/pages/focus.cljc

@@ -8,7 +8,6 @@
   (:require
    [app.common.data :as d]
    [app.common.pages.helpers :as cph]
-   [app.common.pages.indices :as cpi]
    [app.common.uuid :as uuid]))
 
 (defn focus-objects

common/src/app/common/pages/helpers.cljc

@@ -18,14 +18,24 @@
 ;; GENERIC SHAPE SELECTORS AND PREDICATES
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defn root-frame?
+(defn root?
   [{:keys [id type]}]
-  (and (= type :frame)
-       (= id uuid/zero)))
+  (and (= type :frame) (= id uuid/zero)))
+
+(defn root-frame?
+  ([objects id]
+   (root-frame? (get objects id)))
+
+  ([{:keys [frame-id type]}]
+   (and (= type :frame)
+        (= frame-id uuid/zero))))
 
 (defn frame-shape?
-  [{:keys [type]}]
-  (= type :frame))
+  ([objects id]
+   (frame-shape? (get objects id)))
+
+  ([{:keys [type]}]
+   (= type :frame)))
 
 (defn group-shape?
   [{:keys [type]}]
@@ -230,13 +240,29 @@
       (< parent-a parent-b))))
 
 (defn sort-z-index
-  [objects ids]
-  (letfn [(comp [id-a id-b]
-            (cond
-              (= id-a id-b) 0
-              (is-shape-over-shape? objects id-a id-b) 1
-              :else -1))]
-    (sort comp ids)))
+  ([objects ids]
+   (sort-z-index objects ids nil))
+
+  ([objects ids {:keys [bottom-frames?]}]
+   (letfn [(comp [id-a id-b]
+             (let [type-a (dm/get-in objects [id-a :type])
+                   type-b (dm/get-in objects [id-b :type])]
+               (cond
+                 (and bottom-frames? (= :frame type-a) (not= :frame type-b))
+                 1
+
+                 (and bottom-frames? (not= :frame type-a) (= :frame type-b))
+                 -1
+
+                 (= id-a id-b)
+                 0
+
+                 (is-shape-over-shape? objects id-a id-b)
+                 1
+
+                 :else
+                 -1)))]
+     (sort comp ids))))
 
 (defn frame-id-by-position
   [objects position]

common/src/app/common/pages/indices.cljc

@@ -8,78 +8,7 @@
   (:require
    [app.common.data :as d]
    [app.common.pages.helpers :as cph]
-   [app.common.uuid :as uuid]
-   [clojure.set :as set]))
-
-#_(defn calculate-frame-z-index
-  [z-index frame-id base-idx objects]
-
-  (let [is-root-frame?    (fn [id]
-                            (and (= :frame (get-in objects [id :type]))
-                                 (= uuid/zero (get-in objects [id :parent-id]))))
-        children     (or (get-in objects [frame-id :shapes]) [])]
-
-    (if (empty? children)
-      z-index
-      (loop [current (peek children)
-             pending (pop children)
-             current-idx base-idx
-             z-index z-index]
-
-        (let [children  (get-in objects [current :shapes])
-              is-root-frame? (is-root-frame? current)
-              pending   (if (not is-root-frame?)
-                          (d/concat-vec pending children)
-                          pending)]
-
-          (if (empty? pending)
-            (assoc z-index current current-idx)
-            (recur (peek pending)
-                   (pop pending)
-                   (dec current-idx)
-                   (assoc z-index current current-idx))))))))
-
-;; The z-index is really calculated per-frame. Every frame will have its own
-;; internal z-index. To calculate the "final" z-index we add the shape z-index with
-;; the z-index of its frame. This way we can update the z-index per frame without
-;; the need of recalculate all the frames
-#_(defn calculate-z-index
-  "Given a collection of shapes calculates their z-index. Greater index
-  means is displayed over other shapes with less index."
-  [objects]
-
-  (let [frames  (cph/get-root-frames objects)
-
-        by-frame (cph/objects-by-frame objects)
-        frame-base-idx (d/update-vals by-frame count)
-
-        z-index (calculate-frame-z-index {} uuid/zero (get frame-base-idx uuid/zero) objects)]
-    (->> frames
-         (reduce
-          (fn [z-index {:keys [id]}]
-            (calculate-frame-z-index z-index id (get frame-base-idx id) objects)) z-index))))
-
-#_(defn update-z-index
-  "Updates the z-index given a set of ids to change and the old and new objects
-  representations"
-  [z-index changed-ids old-objects new-objects]
-
-  (let [old-frames (into #{} (map #(get-in old-objects [% :frame-id])) changed-ids)
-        new-frames (into #{} (map #(get-in new-objects [% :frame-id])) changed-ids)
-
-        changed-frames (set/union old-frames new-frames)
-
-        frames (->> (cph/get-frames new-objects)
-                    (map :id)
-                    (filter #(contains? changed-frames %)))
-
-        by-frame       (cph/objects-by-frame new-objects)
-        frame-base-idx (d/update-vals by-frame count)
-        z-index (calculate-frame-z-index z-index uuid/zero (get frame-base-idx uuid/zero) new-objects)]
-
-    (->> frames
-         (reduce (fn [z-index id]
-                   (calculate-frame-z-index z-index id (get frame-base-idx id) new-objects)) z-index))))
+   [app.common.uuid :as uuid]))
 
 (defn generate-child-parent-index
   [objects]
@@ -104,11 +33,16 @@
   "Retrieves the mask information for an object"
   [objects parents-index]
   (let [retrieve-clips
-        (fn [_ parents]
+        (fn [parents]
           (let [lookup-object (fn [id] (get objects id))
                 get-clip-parents
                 (fn [shape]
                   (cond-> []
+                    (and (= :frame (:type shape))
+                         (not (:show-content shape))
+                         (not= uuid/zero (:id shape)))
+                    (conj shape)
+
                     (:masked-group? shape)
                     (conj (get objects (->> shape :shapes first)))
 
@@ -119,5 +53,5 @@
                   (comp (map lookup-object)
                         (mapcat get-clip-parents))
                   parents)))]
-    (->> parents-index
-         (d/mapm retrieve-clips))))
+    (-> parents-index
+        (d/update-vals retrieve-clips))))