@shopify/react-native-skia 0.1.172 → 0.1.174

package/cpp/rnskia/dom/base/DerivedNodeProp.h

@@ -15,7 +15,8 @@ namespace RNSkia {
  */
 class BaseDerivedProp : public BaseNodeProp {
 public:
-  BaseDerivedProp() : BaseNodeProp() {}
+  explicit BaseDerivedProp(const std::function<void(BaseNodeProp *)> &onChange)
+      : _onChange(onChange), BaseNodeProp() {}
 
   /**
    Starts the process of updating and reading props
@@ -70,7 +71,11 @@ public:
   /**
    Adds a property to the derived property child props.
    */
-  template <typename P = BaseNodeProp> P *addProperty(std::shared_ptr<P> prop) {
+  template <class _Tp, class... _Args,
+            class = std::_EnableIf<!std::is_array<_Tp>::value>>
+  _Tp *defineProperty(_Args &&...__args) {
+    auto prop =
+        std::make_shared<_Tp>(std::forward<_Args>(__args)..., _onChange);
     _properties.push_back(prop);
     return prop.get();
   }
@@ -104,6 +109,7 @@ protected:
 private:
   std::vector<std::shared_ptr<BaseNodeProp>> _properties;
   std::atomic<bool> _isChanged = {false};
+  std::function<void(BaseNodeProp *)> _onChange;
 };
 
 /**
@@ -111,12 +117,21 @@ private:
  */
 template <typename T> class DerivedProp : public BaseDerivedProp {
 public:
-  DerivedProp() : BaseDerivedProp() {}
+  explicit DerivedProp(const std::function<void(BaseNodeProp *)> &onChange)
+      : BaseDerivedProp(onChange) {}
 
   /**
   Returns the derived value
    */
-  std::shared_ptr<const T> getDerivedValue() { return _derivedValue; }
+  std::shared_ptr<const T> getDerivedValue() {
+    return std::const_pointer_cast<const T>(_derivedValue);
+  }
+
+  /**
+   Returns a mutable version of the derived value. Used by the paint props to
+   keep a drawing context
+   */
+  std::shared_ptr<T> getUnsafeDerivedValue() { return _derivedValue; }
 
   /**
    Returns true if is optional and one of the child props has a value, or all
@@ -128,7 +143,7 @@ protected:
   /**
    Set derived value from sub classes
    */
-  void setDerivedValue(std::shared_ptr<const T> value) {
+  void setDerivedValue(std::shared_ptr<T> value) {
     setIsChanged(_derivedValue != value);
     _derivedValue = value;
   }
@@ -136,13 +151,13 @@ protected:
   /**
    Set derived value from sub classes
    */
-  void setDerivedValue(const T &&value) {
+  void setDerivedValue(T &&value) {
     setIsChanged(true);
-    _derivedValue = std::make_shared<const T>(std::move(value));
+    _derivedValue = std::make_shared<T>(std::move(value));
   }
 
 private:
-  std::shared_ptr<const T> _derivedValue;
+  std::shared_ptr<T> _derivedValue;
 };
 
 /**
@@ -150,7 +165,8 @@ private:
  */
 template <typename T> class DerivedSkProp : public BaseDerivedProp {
 public:
-  DerivedSkProp() : BaseDerivedProp() {}
+  explicit DerivedSkProp(const std::function<void(BaseNodeProp *)> &onChange)
+      : BaseDerivedProp(onChange) {}
 
   /**
   Returns the derived value

package/cpp/rnskia/dom/base/DrawingContext.cpp

@@ -1,209 +1,55 @@
 #include "DrawingContext.h"
 
-namespace RNSkia {
-
-DrawingContext::DrawingContext(std::shared_ptr<SkPaint> paint)
-    : DrawingContext("root") {
-  _paint = paint;
-}
-
-DrawingContext::DrawingContext(DrawingContext *parent, const char *source)
-    : DrawingContext(source) {
-  _parent = parent;
-}
-
-std::shared_ptr<DrawingContext>
-DrawingContext::inheritContext(const char *source) {
-  auto result = std::make_shared<DrawingContext>(this, source);
-  _children.push_back(result);
-  return result;
-}
-
-std::string DrawingContext::getDebugDescription() {
-  std::string v = "ctx for " + std::string(_source) + ":";
-
-  if (_paint != nullptr) {
-    auto clr = _paint->getColor();
-    auto a = SkColorGetA(clr);
-    auto r = SkColorGetR(clr);
-    auto g = SkColorGetG(clr);
-    auto b = SkColorGetB(clr);
-
-    if (r > 0 || g > 0 || b > 0) {
-      v += " color:rgba(" + std::to_string(r) + ", " + std::to_string(g) +
-           ", " + std::to_string(b) + ", " + std::to_string(a) + ")";
-    }
-
-    if (_paint->getMaskFilter() != nullptr) {
-      v += " maskFilter:set";
-    }
-    auto blendMode = _paint->getBlendMode_or(SkBlendMode::kSrc);
-    if (blendMode != SkBlendMode::kSrc) {
-      v += " blendMode:" + std::to_string(static_cast<size_t>(blendMode));
-    }
-
-    auto opacity = _paint->getAlphaf();
-    v += " opacity:" + std::to_string(opacity);
+#include "ConcatablePaint.h"
+#include "JsiDomNode.h"
+#include "PaintProps.h"
 
-    if (_paint->getPathEffect() != nullptr) {
-      v += " [PathEffect]";
-    }
-
-    if (_paint->getShader() != nullptr) {
-      v += " [Shader]";
-    }
-
-    if (_paint->getImageFilter() != nullptr) {
-      v += " [ImageFilter]";
-    }
-
-    if (_paint->getMaskFilter() != nullptr) {
-      v += " [MaskFilter]";
-    }
-
-    if (_paint->getColorFilter() != nullptr) {
-      v += " [ColorFilter]";
-    }
-
-  } else {
-    v = v + "[inherited] " +
-        (_parent != nullptr ? _parent->getDebugDescription() : "");
-  }
-
-  v = v + "\n";
-
-  return v;
-}
-
-/**
- Invalidate cache
- */
-void DrawingContext::markAsChanged() {
-  markChildrenAsChanged();
-  _paint = nullptr;
-  _isChanged = true;
-}
+#include <numeric>
 
-/**
- Call to reset invalidate flag after render cycle
- */
-void DrawingContext::resetChangedFlag() { _isChanged = false; }
-
-/**
- Dispose and remove the drawing context from its parent.
- */
-void DrawingContext::dispose() {
-  if (_parent != nullptr) {
-    auto position = std::find(_parent->_children.begin(),
-                              _parent->_children.end(), shared_from_this());
+namespace RNSkia {
 
-    if (position != _parent->_children.end()) {
-      _parent->_children.erase(position);
-    }
-    // TODO: This is called from the JS thread so we need somehow to avoid
-    // rendering after setting this to null, and we also need to protect this
-    // section.
-    _parent = nullptr;
-  }
+DrawingContext::DrawingContext(std::shared_ptr<SkPaint> paint) {
+  _declarationContext = std::make_unique<DeclarationContext>();
+  paint->setAntiAlias(true);
+  _paints.push_back(paint);
 }
 
-/**
- Returns true if the current cache is changed
- */
-bool DrawingContext::isChanged() { return _isChanged; }
+DrawingContext::DrawingContext()
+    : DrawingContext(std::make_shared<SkPaint>()) {}
 
-/**
- Get/Sets the canvas object
- */
-SkCanvas *DrawingContext::getCanvas() {
-  if (_parent != nullptr) {
-    return _parent->getCanvas();
-  }
-
-  return _canvas;
-}
+bool DrawingContext::saveAndConcat(
+    PaintProps *paintProps,
+    const std::vector<std::shared_ptr<JsiDomNode>> &children,
+    std::shared_ptr<SkPaint> paintCache) {
 
-/**
- Sets the canvas
- */
-void DrawingContext::setCanvas(SkCanvas *canvas) { _canvas = canvas; }
-
-/**
- Gets the paint object
- */
-std::shared_ptr<const SkPaint> DrawingContext::getPaint() {
-  if (_paint != nullptr) {
-    return _paint;
+  if (paintCache) {
+    _paints.push_back(paintCache);
+    return true;
   }
-  return _parent->getPaint();
-}
 
-/**
- To be able to mutate and change the paint in a context we need to mutate the
- underlying paint object - otherwise we'll just use the parent paint object
- (to avoid having to create multiple paint objects for nodes that does not
- change the paint).
- */
-std::shared_ptr<SkPaint> DrawingContext::getMutablePaint() {
-  if (_paint == nullptr) {
-    auto parentPaint = _parent->getPaint();
-    _paint = std::make_shared<SkPaint>(*parentPaint);
+  ConcatablePaint paint(_declarationContext.get(), paintProps, children);
+  if (!paint.isEmpty()) {
+    save();
+    paint.concatTo(getPaint());
+    return true;
   }
-  // Calling the getMutablePaint accessor implies that the paint
-  // is about to be mutatet and will therefore invalidate
-  // any child contexts to pick up changes from this context as
-  // the parent context.
-  markChildrenAsChanged();
-  return _paint;
-}
-
-/**
- Sets the paint in the current sub context
- */
-void DrawingContext::setMutablePaint(std::shared_ptr<SkPaint> paint) {
-  _paint = paint;
-}
 
-float DrawingContext::getScaledWidth() {
-  if (_parent != nullptr) {
-    return _parent->getScaledWidth();
-  }
-  return _scaledWidth;
+  return false;
 }
 
-float DrawingContext::getScaledHeight() {
-  if (_parent != nullptr) {
-    return _parent->getScaledHeight();
-  }
-  return _scaledHeight;
+void DrawingContext::save() {
+  // Copy paint and push
+  _paints.push_back(std::make_shared<SkPaint>(*getPaint()));
 }
 
-DrawingContext *DrawingContext::getParent() { return _parent; }
+void DrawingContext::restore() { _paints.pop_back(); }
 
-void DrawingContext::setScaledWidth(float v) { _scaledWidth = v; }
-void DrawingContext::setScaledHeight(float v) { _scaledHeight = v; }
-
-void DrawingContext::setRequestRedraw(std::function<void()> &&requestRedraw) {
-  if (_parent != nullptr) {
-    _parent->setRequestRedraw(std::move(requestRedraw));
-  } else {
-    _requestRedraw = std::move(requestRedraw);
-  }
-}
+SkCanvas *DrawingContext::getCanvas() { return _canvas; }
 
-const std::function<void()> &DrawingContext::getRequestRedraw() {
-  if (_parent != nullptr) {
-    return _parent->getRequestRedraw();
-  }
-  return _requestRedraw;
-}
-
-DrawingContext::DrawingContext(const char *source) { _source = source; }
+void DrawingContext::setCanvas(SkCanvas *canvas) { _canvas = canvas; }
 
-void DrawingContext::markChildrenAsChanged() {
-  for (auto &child : _children) {
-    child->markAsChanged();
-  }
+std::shared_ptr<SkPaint> DrawingContext::getPaint() {
+  return _paints[_paints.size() - 1];
 }
 
 } // namespace RNSkia

package/cpp/rnskia/dom/base/DrawingContext.h

@@ -2,6 +2,9 @@
 
 #include "JsiHostObject.h"
 
+#include "Declaration.h"
+#include "DeclarationContext.h"
+
 #include <memory>
 #include <string>
 #include <utility>
@@ -12,47 +15,55 @@
 
 #include <SkCanvas.h>
 #include <SkPaint.h>
+#include <SkRefCnt.h>
 
 #pragma clang diagnostic pop
 
 namespace RNSkia {
 
-class DrawingContext : public std::enable_shared_from_this<DrawingContext> {
+class PaintProps;
+class JsiDomNode;
+
+class DomRenderContext {
 public:
-  /**
-   Creates a root drawing context with paint and opacity
-   */
-  explicit DrawingContext(std::shared_ptr<SkPaint> paint);
+  float getScaledWidth() { return _scaledWidth; }
+  float getScaledHeight() { return _scaledHeight; }
 
-  /**
-   Initilalizes a new draw context.
-   */
-  DrawingContext(DrawingContext *parent, const char *source);
+  void setScaledWidth(float v) { _scaledWidth = v; }
+  void setScaledHeight(float v) { _scaledHeight = v; }
 
-  /**
-   Factory for creating a child context that inherits from this context
-   */
-  std::shared_ptr<DrawingContext> inheritContext(const char *source);
+  void setRequestRedraw(std::function<void()> &&requestRedraw) {
+    _requestRedraw = std::move(requestRedraw);
+  }
 
-  /**
-   Returns the debug description for the context
-   */
-  std::string getDebugDescription();
+  const std::function<void()> &getRequestRedraw() { return _requestRedraw; }
+
+private:
+  float _scaledWidth = -1;
+  float _scaledHeight = -1;
+  std::function<void()> _requestRedraw;
+};
 
+class DrawingContext : public DomRenderContext,
+                       public std::enable_shared_from_this<DrawingContext> {
+public:
   /**
-   Mark the drawing context and any child contexts as changed
+   Creates a root drawing context with paint and opacity
    */
-  void markAsChanged();
+  DrawingContext();
 
   /**
-   Call to reset invalidate flag after render cycle
-   */
-  void resetChangedFlag();
+   Creates a drawing context with the given paint as its starting paint object
+  */
+  explicit DrawingContext(std::shared_ptr<SkPaint> paint);
 
   /**
-   Dispose and remove the drawing context from its parent.
+   Factory for saving/restoring the context for a node
    */
-  void dispose();
+  bool saveAndConcat(PaintProps *paintProps,
+                     const std::vector<std::shared_ptr<JsiDomNode>> &children,
+                     std::shared_ptr<SkPaint> paintCache);
+  void restore();
 
   /**
    Returns true if the current cache is changed
@@ -72,52 +83,22 @@ public:
   /**
    Gets the paint object
    */
-  std::shared_ptr<const SkPaint> getPaint();
-
-  /**
-   To be able to mutate and change the paint in a context we need to mutate the
-   underlying paint object - otherwise we'll just use the parent paint object
-   (to avoid having to create multiple paint objects for nodes that does not
-   change the paint).
-   */
-  std::shared_ptr<SkPaint> getMutablePaint();
+  std::shared_ptr<SkPaint> getPaint();
 
-  /**
-   Sets the paint in the current sub context
+  /*
+   Returns the root declaratiins object
    */
-  void setMutablePaint(std::shared_ptr<SkPaint> paint);
-
-  float getScaledWidth();
-
-  float getScaledHeight();
-
-  void setScaledWidth(float v);
-  void setScaledHeight(float v);
-
-  void setRequestRedraw(std::function<void()> &&requestRedraw);
-  const std::function<void()> &getRequestRedraw();
-
-  DrawingContext *getParent();
+  DeclarationContext *getDeclarationContext() {
+    return _declarationContext.get();
+  }
 
 private:
-  explicit DrawingContext(const char *source);
-
-  void markChildrenAsChanged();
-
-  bool _isChanged = true;
-
-  std::shared_ptr<SkPaint> _paint;
+  void save();
 
+  explicit DrawingContext(const char *source);
   SkCanvas *_canvas = nullptr;
-  const char *_source;
-
-  DrawingContext *_parent = nullptr;
-  std::vector<std::shared_ptr<DrawingContext>> _children;
-
-  float _scaledWidth = -1;
-  float _scaledHeight = -1;
-
-  std::function<void()> _requestRedraw;
+  std::vector<std::shared_ptr<SkPaint>> _paints;
+  std::unique_ptr<DeclarationContext> _declarationContext;
 };
 
 } // namespace RNSkia

package/cpp/rnskia/dom/base/JsiDomDeclarationNode.h

@@ -9,17 +9,29 @@
 
 namespace RNSkia {
 
-class JsiBaseDomDeclarationNode : public JsiDomNode {
+enum DeclarationType {
+  Unknown = 0,
+  Paint = 1,
+  Shader = 2,
+  ImageFilter = 3,
+  ColorFilter = 4,
+  PathEffect = 5,
+  MaskFilter = 6,
+};
+
+class JsiDomDeclarationNode : public JsiDomNode {
 public:
-  JsiBaseDomDeclarationNode(std::shared_ptr<RNSkPlatformContext> context,
-                            const char *type)
-      : JsiDomNode(context, type) {}
+  JsiDomDeclarationNode(std::shared_ptr<RNSkPlatformContext> context,
+                        const char *type, DeclarationType declarationType)
+      : JsiDomNode(context, type, NodeClass::DeclarationNode),
+        _declarationType(declarationType) {}
 
   JSI_PROPERTY_GET(declarationType) {
+    // FIXME: Shouldn't this be the declaration type instead? It has been
     return jsi::String::createFromUtf8(runtime, std::string(getType()));
   }
 
-  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiBaseDomDeclarationNode,
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiDomDeclarationNode,
                                                   declarationType),
                               JSI_EXPORT_PROP_GET(JsiDomNode, type))
 
@@ -34,30 +46,27 @@ public:
   /**
    Called when rendering the tree to create all derived values from all nodes.
    */
-  virtual void decorateContext(DrawingContext *context) {
+  void decorateContext(DeclarationContext *context) override {
+    JsiDomNode::decorateContext(context);
+
 #if SKIA_DOM_DEBUG
-    printDebugInfo("Begin Materialize " + std::string(getType()));
+    printDebugInfo("Begin decorate " + std::string(getType()));
 #endif
-    // Materialize children first so that any inner nodes get the opportunity
-    // to calculate their state before this node continues.
-    for (auto &child : getChildren()) {
-      if (child->getNodeClass() == JsiDomNodeClass::DeclarationNode) {
-        std::static_pointer_cast<JsiBaseDomDeclarationNode>(child)
-            ->decorateContext(context);
-      }
-    }
 
     // decorate drawing context
     decorate(context);
 
 #if SKIA_DOM_DEBUG
-    printDebugInfo("End / Commit Materialize " + std::string(getType()));
+    printDebugInfo("End / Commit decorate " + std::string(getType()));
 #endif
   }
 
-  JsiDomNodeClass getNodeClass() override {
-    return JsiDomNodeClass::DeclarationNode;
-  }
+  DeclarationType getDeclarationType() { return _declarationType; }
+
+  /**
+   Override to implement materialization
+   */
+  virtual void decorate(DeclarationContext *context) = 0;
 
 protected:
   /**
@@ -71,16 +80,15 @@ protected:
   }
 
   /**
-   Override to implement materialization
+   A property changed
    */
-  virtual void decorate(DrawingContext *context) = 0;
+  void onPropertyChanged(BaseNodeProp *prop) override { invalidateContext(); }
 
   /**
    Validates that only declaration nodes can be children
    */
   void addChild(std::shared_ptr<JsiDomNode> child) override {
-    if (std::dynamic_pointer_cast<JsiBaseDomDeclarationNode>(child) ==
-        nullptr) {
+    if (child->getNodeClass() != NodeClass::DeclarationNode) {
       getContext()->raiseError(std::runtime_error(
           "Cannot add a child of type \"" + std::string(child->getType()) +
           "\" to a \"" + std::string(getType()) + "\"."));
@@ -93,98 +101,19 @@ protected:
    */
   void insertChildBefore(std::shared_ptr<JsiDomNode> child,
                          std::shared_ptr<JsiDomNode> before) override {
-    if (std::dynamic_pointer_cast<JsiBaseDomDeclarationNode>(child) ==
-        nullptr) {
+    if (child->getNodeClass() != NodeClass::DeclarationNode) {
       getContext()->raiseError(std::runtime_error(
           "Cannot add a child of type \"" + std::string(child->getType()) +
           "\" to a \"" + std::string(getType()) + "\"."));
     }
     JsiDomNode::insertChildBefore(child, before);
   }
-};
-
-template <typename T, typename ST>
-class JsiDomDeclarationNode : public JsiBaseDomDeclarationNode {
-public:
-  JsiDomDeclarationNode(std::shared_ptr<RNSkPlatformContext> context,
-                        const char *type)
-      : JsiBaseDomDeclarationNode(context, type) {}
-
-  bool isChanged(DrawingContext *context) {
-    return getCurrent() == nullptr || context->isChanged() ||
-           getPropsContainer()->isChanged();
-  }
-
-  /**
-   Returns the inner element
-   */
-  ST getCurrent() { return _current; }
-
-  /**
-   Clears the current
-   */
-  void clearCurrent() { _current = nullptr; }
-
-protected:
-  /**
-   Sets the current value
-   */
-  void setCurrent(ST c) { _current = c; }
-
-  /**
-   Returns a required child image filter by index
-   */
-  ST requireChild(size_t index) {
-    auto filter = optionalChild(index);
-    if (filter == nullptr) {
-      throw std::runtime_error("Expected child node at index " +
-                               std::to_string(index) + " in node " + getType());
-    }
-    return filter;
-  }
-
-  /**
-   Returns an optional child image filter by index
-   */
-  ST optionalChild(size_t index) {
-    if (index >= getChildren().size()) {
-      return nullptr;
-    }
-
-    auto child = getChildren()[index];
-    // Support all types here!! ImageFilters, ColorFilters
-    // package/src/dom/nodes/paint/ImageFilters.ts#80
-    return resolve(child);
-  }
-
-  /**
-   Returns child as inner type or nullptr
-   */
-  virtual ST resolve(std::shared_ptr<JsiDomNode> child) = 0;
 
+private:
   /**
-   Sets or composes the image filter
+   Type of declaration
    */
-  virtual void set(DrawingContext *context, ST imageFilter) = 0;
-
-  void removeChild(std::shared_ptr<JsiDomNode> child) override {
-    JsiBaseDomDeclarationNode::removeChild(child);
-    clearCurrent();
-  }
-
-  void addChild(std::shared_ptr<JsiDomNode> child) override {
-    JsiBaseDomDeclarationNode::addChild(child);
-    clearCurrent();
-  }
-
-  void insertChildBefore(std::shared_ptr<JsiDomNode> child,
-                         std::shared_ptr<JsiDomNode> before) override {
-    JsiBaseDomDeclarationNode::insertChildBefore(child, before);
-    clearCurrent();
-  }
-
-private:
-  ST _current;
+  DeclarationType _declarationType;
 };
 
 } // namespace RNSkia