mirror of
https://github.com/penpot/penpot.git
synced 2025-07-19 05:47:19 +02:00
320 lines
8.3 KiB
Clojure
320 lines
8.3 KiB
Clojure
;; This Source Code Form is subject to the terms of the Mozilla Public
|
|
;; License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
;;
|
|
;; Copyright (c) KALEIDOS INC
|
|
|
|
(ns app.render-wasm.shape
|
|
(:require
|
|
[app.common.data :as d]
|
|
[app.common.data.macros :as dm]
|
|
[app.common.transit :as t]
|
|
[app.common.types.shape :as shape]
|
|
[app.common.types.shape.layout :as ctl]
|
|
[app.render-wasm.api :as api]
|
|
[beicon.v2.core :as rx]
|
|
[clojure.core :as c]
|
|
[cuerdas.core :as str]))
|
|
|
|
(declare ^:private impl-assoc)
|
|
(declare ^:private impl-conj)
|
|
(declare ^:private impl-dissoc)
|
|
|
|
(defn map-entry
|
|
[k v]
|
|
(cljs.core/MapEntry. k v nil))
|
|
|
|
(deftype ShapeProxy [id type delegate]
|
|
Object
|
|
(toString [coll]
|
|
(str "{" (str/join ", " (for [[k v] coll] (str k " " v))) "}"))
|
|
|
|
(equiv [this other]
|
|
(-equiv this other))
|
|
|
|
;; Marker protocol
|
|
shape/IShape
|
|
|
|
IWithMeta
|
|
(-with-meta [_ meta]
|
|
(ShapeProxy. id type (with-meta delegate meta)))
|
|
|
|
IMeta
|
|
(-meta [_] (meta delegate))
|
|
|
|
ICollection
|
|
(-conj [coll entry]
|
|
(impl-conj coll entry))
|
|
|
|
IEquiv
|
|
(-equiv [coll other]
|
|
(c/equiv-map coll other))
|
|
|
|
IHash
|
|
(-hash [coll] (hash (into {} coll)))
|
|
|
|
ISequential
|
|
|
|
ISeqable
|
|
(-seq [_]
|
|
(cons (map-entry :id id)
|
|
(cons (map-entry :type type)
|
|
(c/-seq delegate))))
|
|
|
|
ICounted
|
|
(-count [_]
|
|
(+ 1 (count delegate)))
|
|
|
|
ILookup
|
|
(-lookup [coll k]
|
|
(-lookup coll k nil))
|
|
|
|
(-lookup [_ k not-found]
|
|
(case k
|
|
:id id
|
|
:type type
|
|
(c/-lookup delegate k not-found)))
|
|
|
|
IFind
|
|
(-find [_ k]
|
|
(case k
|
|
:id
|
|
(map-entry :id id)
|
|
:type
|
|
(map-entry :type type)
|
|
(c/-find delegate k)))
|
|
|
|
IAssociative
|
|
(-assoc [coll k v]
|
|
(impl-assoc coll k v))
|
|
|
|
(-contains-key? [_ k]
|
|
(or (= k :id)
|
|
(= k :type)
|
|
(contains? delegate k)))
|
|
|
|
IMap
|
|
(-dissoc [coll k]
|
|
(impl-dissoc coll k))
|
|
|
|
IFn
|
|
(-invoke [coll k]
|
|
(-lookup coll k nil))
|
|
|
|
(-invoke [coll k not-found]
|
|
(-lookup coll k not-found))
|
|
|
|
IPrintWithWriter
|
|
(-pr-writer [_ writer _]
|
|
(-write writer (str "#penpot/shape " (:id delegate)))))
|
|
|
|
;; --- SHAPE IMPL
|
|
|
|
(defn set-wasm-single-attr!
|
|
[shape k]
|
|
(let [v (get shape k)
|
|
id (get shape :id)]
|
|
(case k
|
|
:parent-id (api/set-parent-id v)
|
|
:type (api/set-shape-type v)
|
|
:bool-type (api/set-shape-bool-type v)
|
|
:selrect (api/set-shape-selrect v)
|
|
:show-content (if (= (:type shape) :frame)
|
|
(api/set-shape-clip-content (not v))
|
|
(api/set-shape-clip-content false))
|
|
:rotation (api/set-shape-rotation v)
|
|
:transform (api/set-shape-transform v)
|
|
:fills (into [] (api/set-shape-fills id v))
|
|
:strokes (into [] (api/set-shape-strokes id v))
|
|
:blend-mode (api/set-shape-blend-mode v)
|
|
:opacity (api/set-shape-opacity v)
|
|
:hidden (api/set-shape-hidden v)
|
|
:shapes (api/set-shape-children v)
|
|
:blur (api/set-shape-blur v)
|
|
:shadow (api/set-shape-shadows v)
|
|
:constraints-h (api/set-constraints-h v)
|
|
:constraints-v (api/set-constraints-v v)
|
|
|
|
(:r1 :r2 :r3 :r4)
|
|
(api/set-shape-corners [(dm/get-prop shape :r1)
|
|
(dm/get-prop shape :r2)
|
|
(dm/get-prop shape :r3)
|
|
(dm/get-prop shape :r4)])
|
|
|
|
:svg-attrs
|
|
(when (= (:type shape) :path)
|
|
(api/set-shape-path-attrs v))
|
|
|
|
:masked-group
|
|
(when (and (= (:type shape) :group) (:masked-group shape))
|
|
(api/set-masked (:masked-group shape)))
|
|
|
|
:content
|
|
(cond
|
|
(or (= (:type shape) :path)
|
|
(= (:type shape) :bool))
|
|
(api/set-shape-path-content v)
|
|
|
|
(= (:type shape) :svg-raw)
|
|
(api/set-shape-svg-raw-content (api/get-static-markup shape))
|
|
|
|
(= (:type shape) :text)
|
|
(api/set-shape-text id v))
|
|
|
|
:grow-type
|
|
(api/set-shape-grow-type v)
|
|
|
|
(:layout-item-align-self
|
|
:layout-item-margin
|
|
:layout-item-margin-type
|
|
:layout-item-h-sizing
|
|
:layout-item-v-sizing
|
|
:layout-item-max-h
|
|
:layout-item-min-h
|
|
:layout-item-max-w
|
|
:layout-item-min-w
|
|
:layout-item-absolute
|
|
:layout-item-z-index)
|
|
(api/set-layout-child shape)
|
|
|
|
:layout-grid-rows
|
|
(api/set-grid-layout-rows v)
|
|
|
|
:layout-grid-columns
|
|
(api/set-grid-layout-columns v)
|
|
|
|
:layout-grid-cells
|
|
(api/set-grid-layout-cells v)
|
|
|
|
(:layout
|
|
:layout-flex-dir
|
|
:layout-gap-type
|
|
:layout-gap
|
|
:layout-align-items
|
|
:layout-align-content
|
|
:layout-justify-items
|
|
:layout-justify-content
|
|
:layout-wrap-type
|
|
:layout-padding-type
|
|
:layout-padding)
|
|
(cond
|
|
(ctl/grid-layout? shape)
|
|
(api/set-grid-layout-data shape)
|
|
|
|
(ctl/flex-layout? shape)
|
|
(api/set-flex-layout shape))
|
|
|
|
nil)))
|
|
|
|
(defn set-wasm-multi-attrs!
|
|
[shape properties]
|
|
(api/use-shape (:id shape))
|
|
(let [result
|
|
(->> properties
|
|
(mapcat #(set-wasm-single-attr! shape %)))
|
|
pending (-> (d/index-by :key :callback result) vals)]
|
|
(if (and pending (seq pending))
|
|
(->> (rx/from pending)
|
|
(rx/mapcat (fn [callback] (callback)))
|
|
(rx/reduce conj [])
|
|
(rx/subs!
|
|
(fn [_]
|
|
(api/update-shape-tiles)
|
|
(api/clear-drawing-cache)
|
|
(api/request-render "set-wasm-attrs-pending"))))
|
|
(do
|
|
(api/update-shape-tiles)
|
|
(api/request-render "set-wasm-attrs")))))
|
|
|
|
(defn set-wasm-attrs!
|
|
[shape k v]
|
|
(let [shape (assoc shape k v)]
|
|
(api/use-shape (:id shape))
|
|
(let [result (set-wasm-single-attr! shape k)
|
|
pending (-> (d/index-by :key :callback result) vals)]
|
|
;; TODO: set-wasm-attrs is called twice with every set
|
|
(if (and pending (seq pending))
|
|
(->> (rx/from pending)
|
|
(rx/mapcat (fn [callback] (callback)))
|
|
(rx/reduce conj [])
|
|
(rx/subs!
|
|
(fn [_]
|
|
(api/update-shape-tiles)
|
|
(api/clear-drawing-cache)
|
|
(api/request-render "set-wasm-attrs-pending"))))
|
|
(do
|
|
(api/update-shape-tiles)
|
|
(api/request-render "set-wasm-attrs"))))))
|
|
|
|
(defn- impl-assoc
|
|
[self k v]
|
|
(when ^boolean shape/*wasm-sync*
|
|
(binding [shape/*wasm-sync* false]
|
|
(set-wasm-attrs! self k v)))
|
|
|
|
(case k
|
|
:id
|
|
(ShapeProxy. v
|
|
(.-type ^ShapeProxy self)
|
|
(.-delegate ^ShapeProxy self))
|
|
:type
|
|
(ShapeProxy. (.-id ^ShapeProxy self)
|
|
v
|
|
(.-delegate ^ShapeProxy self))
|
|
|
|
(let [delegate (.-delegate ^ShapeProxy self)
|
|
delegate' (assoc delegate k v)]
|
|
(if (identical? delegate' delegate)
|
|
self
|
|
(ShapeProxy. (.-id ^ShapeProxy self)
|
|
(.-type ^ShapeProxy self)
|
|
delegate')))))
|
|
|
|
(defn- impl-dissoc
|
|
[self k]
|
|
(when ^boolean shape/*wasm-sync*
|
|
(binding [shape/*wasm-sync* false]
|
|
(set-wasm-attrs! self k nil)))
|
|
|
|
(case k
|
|
:id
|
|
(ShapeProxy. nil
|
|
(.-type ^ShapeProxy self)
|
|
(.-delegate ^ShapeProxy self))
|
|
:type
|
|
(ShapeProxy. (.-id ^ShapeProxy self)
|
|
nil
|
|
(.-delegate ^ShapeProxy self))
|
|
(let [delegate (.-delegate ^ShapeProxy self)
|
|
delegate' (dissoc delegate k)]
|
|
(if (identical? delegate delegate')
|
|
self
|
|
(ShapeProxy. (.-id ^ShapeProxy self)
|
|
(.-type ^ShapeProxy self)
|
|
delegate')))))
|
|
|
|
(defn- impl-conj
|
|
[self entry]
|
|
(if (vector? entry)
|
|
(-assoc self (-nth entry 0) (-nth entry 1))
|
|
(loop [ret self es (seq entry)]
|
|
(if (nil? es)
|
|
ret
|
|
(let [e (first es)]
|
|
(if (vector? e)
|
|
(recur (-assoc ret (-nth e 0) (-nth e 1))
|
|
(next es))
|
|
(throw (js/Error. "conj on a map takes map entries or seqables of map entries"))))))))
|
|
|
|
(defn create-shape
|
|
"Instanciate a shape from a map"
|
|
[attrs]
|
|
(ShapeProxy. (:id attrs)
|
|
(:type attrs)
|
|
(dissoc attrs :id :type)))
|
|
|
|
(t/add-handlers!
|
|
;; We only add a write handler, read handler uses the dynamic dispatch
|
|
{:id "shape"
|
|
:class ShapeProxy
|
|
:wfn #(into {} %)})
|