@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/rnskia/dom/nodes/JsiTextNode.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+
+#include "FontProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiTextNode : public JsiDomDrawingNode,
+                    public JsiDomNodeCtor<JsiTextNode> {
+public:
+  explicit JsiTextNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skText") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    auto text = _textProp->value().getAsString().c_str();
+    auto x = _xProp->value().getAsNumber();
+    auto y = _yProp->value().getAsNumber();
+    auto font = _fontProp->getDerivedValue();
+
+    context->getCanvas()->drawSimpleText(text, strlen(text),
+                                         SkTextEncoding::kUTF8, x, y, *font,
+                                         *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+
+    _fontProp = container->defineProperty(
+        std::make_shared<FontProp>(JsiPropId::get("font")));
+    _textProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("text")));
+    _xProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("x")));
+    _yProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("y")));
+
+    _fontProp->require();
+    _textProp->require();
+    _xProp->require();
+    _yProp->require();
+  }
+
+private:
+  FontProp *_fontProp;
+  NodeProp *_textProp;
+  NodeProp *_xProp;
+  NodeProp *_yProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiTextPathNode.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "TextBlobProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiTextPathNode : public JsiDomDrawingNode,
+                        public JsiDomNodeCtor<JsiTextPathNode> {
+public:
+  explicit JsiTextPathNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skTextPath") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    auto blob = _textBlobProp->getDerivedValue();
+    context->getCanvas()->drawTextBlob(blob, 0, 0, *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _textBlobProp =
+        container->defineProperty(std::make_shared<TextPathBlobProp>());
+  }
+
+private:
+  TextPathBlobProp *_textBlobProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiVerticesNode.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+
+#include "BlendModeProp.h"
+#include "VerticesProps.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiVerticesNode : public JsiDomDrawingNode,
+                        public JsiDomNodeCtor<JsiVerticesNode> {
+public:
+  explicit JsiVerticesNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skVertices") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    SkBlendMode defaultBlendMode = _verticesProps->hasColors()
+                                       ? SkBlendMode::kDstOver
+                                       : SkBlendMode::kSrcOver;
+    context->getCanvas()->drawVertices(_verticesProps->getDerivedValue(),
+                                       _blendModeProp->isSet()
+                                           ? *_blendModeProp->getDerivedValue()
+                                           : defaultBlendMode,
+                                       *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _verticesProps =
+        container->defineProperty(std::make_shared<VerticesProps>());
+    _blendModeProp = container->defineProperty(
+        std::make_shared<BlendModeProp>(JsiPropId::get("blendMode")));
+  }
+
+private:
+  VerticesProps *_verticesProps;
+  BlendModeProp *_blendModeProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/BezierProps.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "JsiSkPicture.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace RNSkia {
+
+class BezierProp : public DerivedProp<std::vector<SkPoint>> {
+public:
+  explicit BezierProp(PropId name) : DerivedProp<std::vector<SkPoint>>() {
+    _bezierProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_bezierProp->value().getType() == PropType::Array) {
+      // Patch requires a path with the following constraints:
+      // M tl
+      // C c1 c2 br
+      // C c1 c2 bl
+      // C c1 c2 tl (the redundant point in the last command is removed)
+      auto arr = _bezierProp->value().getAsArray();
+      std::vector<SkPoint> points;
+      points.reserve(12);
+
+      points.push_back(
+          PointProp::processValue(arr[0].getValue(JsiPropId::get("pos"))));
+      points.push_back(
+          PointProp::processValue(arr[0].getValue(JsiPropId::get("c2"))));
+      points.push_back(
+          PointProp::processValue(arr[1].getValue(JsiPropId::get("c1"))));
+      points.push_back(
+          PointProp::processValue(arr[1].getValue(JsiPropId::get("pos"))));
+      points.push_back(
+          PointProp::processValue(arr[1].getValue(JsiPropId::get("c2"))));
+      points.push_back(
+          PointProp::processValue(arr[2].getValue(JsiPropId::get("c1"))));
+      points.push_back(
+          PointProp::processValue(arr[2].getValue(JsiPropId::get("pos"))));
+      points.push_back(
+          PointProp::processValue(arr[2].getValue(JsiPropId::get("c2"))));
+      points.push_back(
+          PointProp::processValue(arr[3].getValue(JsiPropId::get("c1"))));
+      points.push_back(
+          PointProp::processValue(arr[3].getValue(JsiPropId::get("pos"))));
+      points.push_back(
+          PointProp::processValue(arr[3].getValue(JsiPropId::get("c2"))));
+      points.push_back(
+          PointProp::processValue(arr[0].getValue(JsiPropId::get("c1"))));
+
+      setDerivedValue(std::move(points));
+    }
+  }
+
+private:
+  NodeProp *_bezierProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/BlendModeProp.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkBlendMode.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class BlendModeProp : public DerivedProp<SkBlendMode> {
+public:
+  explicit BlendModeProp(PropId name) : DerivedProp<SkBlendMode>() {
+    _blendMode = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_blendMode->isSet() && (_blendMode->isChanged())) {
+      auto blendModeValue = _blendMode->value().getAsString();
+      setDerivedValue(getBlendModeFromString(blendModeValue));
+    }
+  }
+
+private:
+  SkBlendMode getBlendModeFromString(const std::string &value) {
+    if (value == "clear") {
+      return SkBlendMode::kClear;
+    } else if (value == "src") {
+      return SkBlendMode::kSrc;
+    } else if (value == "dst") {
+      return SkBlendMode::kDst;
+    } else if (value == "srcOver") {
+      return SkBlendMode::kSrcOver;
+    } else if (value == "dstOver") {
+      return SkBlendMode::kDstOver;
+    } else if (value == "srcIn") {
+      return SkBlendMode::kSrcIn;
+    } else if (value == "kDstIn") {
+      return SkBlendMode::kDstIn;
+    } else if (value == "srcOut") {
+      return SkBlendMode::kSrcOut;
+    } else if (value == "dtsOut") {
+      return SkBlendMode::kDstOut;
+    } else if (value == "srcATop") {
+      return SkBlendMode::kSrcATop;
+    } else if (value == "dstATop") {
+      return SkBlendMode::kDstATop;
+    } else if (value == "xor") {
+      return SkBlendMode::kXor;
+    } else if (value == "plus") {
+      return SkBlendMode::kPlus;
+    } else if (value == "modulate") {
+      return SkBlendMode::kModulate;
+    } else if (value == "screen") {
+      return SkBlendMode::kScreen;
+    } else if (value == "overlay") {
+      return SkBlendMode::kOverlay;
+    } else if (value == "darken") {
+      return SkBlendMode::kDarken;
+    } else if (value == "lighten") {
+      return SkBlendMode::kLighten;
+    } else if (value == "colorDodge") {
+      return SkBlendMode::kColorDodge;
+    } else if (value == "colorBurn") {
+      return SkBlendMode::kColorBurn;
+    } else if (value == "hardLight") {
+      return SkBlendMode::kHardLight;
+    } else if (value == "softLight") {
+      return SkBlendMode::kSoftLight;
+    } else if (value == "difference") {
+      return SkBlendMode::kDifference;
+    } else if (value == "exclusion") {
+      return SkBlendMode::kExclusion;
+    } else if (value == "multiply") {
+      return SkBlendMode::kMultiply;
+    } else if (value == "hue") {
+      return SkBlendMode::kHue;
+    } else if (value == "saturation") {
+      return SkBlendMode::kSaturation;
+    } else if (value == "color") {
+      return SkBlendMode::kColor;
+    } else if (value == "luminosity") {
+      return SkBlendMode::kLuminosity;
+    }
+
+    throw std::runtime_error("Property value \"" + value +
+                             "\" is not a legal blend mode.");
+  }
+
+  NodeProp *_blendMode;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/BoxShadowProps.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "NodeProp.h"
+
+#include <memory>
+#include <utility>
+
+namespace RNSkia {
+
+class BoxShadowProps : public DerivedProp<SkPaint> {
+public:
+  BoxShadowProps() : DerivedProp<SkPaint>() {
+    _dxProp = addProperty(std::make_shared<NodeProp>(JsiPropId::get("dx")));
+    _dyProp = addProperty(std::make_shared<NodeProp>(JsiPropId::get("dy")));
+    _spreadProp =
+        addProperty(std::make_shared<NodeProp>(JsiPropId::get("spread")));
+    _blurProp = addProperty(std::make_shared<NodeProp>(JsiPropId::get("blur")));
+    _colorProp =
+        addProperty(std::make_shared<ColorProp>(JsiPropId::get("color")));
+    _innerProp =
+        addProperty(std::make_shared<NodeProp>(JsiPropId::get("inner")));
+
+    _blurProp->require();
+  }
+
+  void updateDerivedValue() override {
+    SkColor color =
+        _colorProp->isSet() ? *_colorProp->getDerivedValue() : SK_ColorBLACK;
+    SkScalar blur = _blurProp->value().getAsNumber();
+
+    auto paint = SkPaint();
+    paint.setColor(color);
+    auto filter = SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, blur, true);
+    paint.setMaskFilter(filter);
+
+    setDerivedValue(std::move(paint));
+  }
+
+  bool isInner() {
+    return _innerProp->isSet() ? _innerProp->value().getAsBool() : false;
+  }
+  SkScalar getDx() {
+    return _dxProp->isSet() ? _dxProp->value().getAsNumber() : 0;
+  }
+  SkScalar getDy() {
+    return _dyProp->isSet() ? _dyProp->value().getAsNumber() : 0;
+  }
+  SkScalar getSpread() {
+    return _spreadProp->isSet() ? _spreadProp->value().getAsNumber() : 0;
+  }
+
+private:
+  NodeProp *_dxProp;
+  NodeProp *_dyProp;
+  NodeProp *_spreadProp;
+  NodeProp *_blurProp;
+  ColorProp *_colorProp;
+  NodeProp *_innerProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/CircleProp.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "NodeProp.h"
+#include "PointProp.h"
+
+#include <memory>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPoint.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+static PropId PropNameCx = JsiPropId::get("cx");
+static PropId PropNameCy = JsiPropId::get("cy");
+static PropId PropNameC = JsiPropId::get("c");
+
+class CircleProp : public DerivedProp<SkPoint> {
+public:
+  CircleProp() : DerivedProp<SkPoint>() {
+    _c = addProperty(std::make_shared<PointProp>(PropNameC));
+    _cx = addProperty(std::make_shared<NodeProp>(PropNameCx));
+    _cy = addProperty(std::make_shared<NodeProp>(PropNameCy));
+  }
+
+  void updateDerivedValue() override {
+    // Read in this order since point with x:0/y:0 is default for
+    // the c property.
+    if (_cx->isSet() && _cy->isSet()) {
+      setDerivedValue(SkPoint::Make(_cx->value().getAsNumber(),
+                                    _cy->value().getAsNumber()));
+    } else if (_c->isSet()) {
+      setDerivedValue(_c->getDerivedValue());
+    }
+  }
+
+private:
+  PointProp *_c;
+  NodeProp *_cx;
+  NodeProp *_cy;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/ClipProp.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "NodeProp.h"
+
+#include "PathProp.h"
+#include "RRectProp.h"
+#include "RectProp.h"
+
+#include <memory>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPath.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class ClipProp : public BaseDerivedProp {
+public:
+  explicit ClipProp(PropId name) : BaseDerivedProp() {
+    _pathProp = addProperty(std::make_shared<PathProp>(name));
+    _rectProp = addProperty(std::make_shared<RectProp>(name));
+    _rrectProp = addProperty(std::make_shared<RRectProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_pathProp->isSet()) {
+      _rect = nullptr;
+      _rrect = nullptr;
+      _path = _pathProp->getDerivedValue();
+    } else if (_rrectProp->isSet()) {
+      _rect = nullptr;
+      _rrect = _rrectProp->getDerivedValue();
+      _path = nullptr;
+    } else if (_rectProp->isSet()) {
+      _rect = _rectProp->getDerivedValue();
+      _rrect = nullptr;
+      _path = nullptr;
+    }
+  }
+
+  bool isSet() override {
+    return _pathProp->isSet() || _rectProp->isSet() || _rrectProp->isSet();
+  }
+
+  SkPath *getPath() { return _path.get(); }
+  SkRect *getRect() { return _rect.get(); }
+  SkRRect *getRRect() { return _rrect.get(); }
+
+private:
+  PathProp *_pathProp;
+  RectProp *_rectProp;
+  RRectProp *_rrectProp;
+
+  std::shared_ptr<SkPath> _path;
+  std::shared_ptr<SkRect> _rect;
+  std::shared_ptr<SkRRect> _rrect;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/ColorProp.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+#include "third_party/CSSColorParser.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace RNSkia {
+
+class ColorProp : public DerivedProp<SkColor> {
+public:
+  explicit ColorProp(PropId name) : DerivedProp<SkColor>() {
+    _colorProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_colorProp->isSet()) {
+      // Color might be a number, a string or a Float32Array of rgba values
+      setDerivedValue(
+          std::make_shared<SkColor>(parseColorValue(_colorProp->value())));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+  static SkColor parseColorValue(const JsiValue &color) {
+    if (color.getType() == PropType::Object) {
+      // Float array
+      auto r = color.getValue(JsiPropId::get("0"));
+      auto g = color.getValue(JsiPropId::get("1"));
+      auto b = color.getValue(JsiPropId::get("2"));
+      auto a = color.getValue(JsiPropId::get("3"));
+      return SkColorSetARGB(a.getAsNumber() * 255.0f, r.getAsNumber() * 255.0f,
+                            g.getAsNumber() * 255.0f, b.getAsNumber() * 255.0f);
+
+    } else if (color.getType() == PropType::Number) {
+      return static_cast<SkColor>(color.getAsNumber());
+    } else {
+      auto parsedColor = CSSColorParser::parse(color.getAsString());
+      if (parsedColor.a == -1.0f) {
+        return SK_ColorBLACK;
+      } else {
+        return SkColorSetARGB(parsedColor.a * 255, parsedColor.r, parsedColor.g,
+                              parsedColor.b);
+      }
+    }
+  }
+
+private:
+  NodeProp *_colorProp;
+};
+
+class ColorsProp : public DerivedProp<std::vector<SkColor>> {
+public:
+  explicit ColorsProp(PropId name) : DerivedProp<std::vector<SkColor>>() {
+    _colorsProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_colorsProp->isSet()) {
+      auto colors = _colorsProp->value().getAsArray();
+      std::vector<SkColor> derivedColors;
+      derivedColors.reserve(colors.size());
+
+      for (size_t i = 0; i < colors.size(); ++i) {
+        derivedColors.push_back(ColorProp::parseColorValue(colors[i]));
+      }
+      setDerivedValue(std::move(derivedColors));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  NodeProp *_colorsProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/DrawingProp.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "JsiSkFont.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+using NotifyNeedRenderCallback =
+    std::function<void(jsi::HostFunctionType drawing)>;
+
+class DrawingProp : public DerivedSkProp<SkPicture> {
+public:
+  DrawingProp(PropId name, NotifyNeedRenderCallback notifyPictureNeeded)
+      : _notifyPictureNeeded(notifyPictureNeeded), DerivedSkProp<SkPicture>() {
+    _drawingProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    auto drawingFunc = _drawingProp->value().getAsFunction();
+    _notifyPictureNeeded(drawingFunc);
+  }
+
+  void setPicture(sk_sp<SkPicture> picture) { setDerivedValue(picture); }
+
+private:
+  NodeProp *_drawingProp;
+  NotifyNeedRenderCallback _notifyPictureNeeded;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/FontProp.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "JsiSkFont.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class FontProp : public DerivedProp<SkFont> {
+public:
+  explicit FontProp(PropId name) : DerivedProp<SkFont>() {
+    _fontProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_fontProp->value().getType() != PropType::HostObject) {
+      throw std::runtime_error("Expected SkFont object for the Font property.");
+    }
+
+    auto ptr = _fontProp->value().getAs<JsiSkFont>();
+    if (ptr == nullptr) {
+      throw std::runtime_error("Expected SkFont object for the Font property.");
+    }
+
+    setDerivedValue(ptr->getObject());
+  }
+
+private:
+  NodeProp *_fontProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/GlyphsProp.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+#include "PointProp.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace RNSkia {
+
+static PropId PropNamePos = JsiPropId::get("pos");
+static PropId PropNameId = JsiPropId::get("id");
+
+struct GlyphInfo {
+  std::vector<SkGlyphID> glyphIds;
+  std::vector<SkPoint> positions;
+};
+
+class GlyphsProp : public DerivedProp<GlyphInfo> {
+public:
+  explicit GlyphsProp(PropId name) : DerivedProp<GlyphInfo>() {
+    _glyphsProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    auto arr = _glyphsProp->value().getAsArray();
+
+    GlyphInfo glyphInfo;
+
+    std::vector<SkGlyphID> glyphIds;
+    std::vector<SkPoint> positions;
+
+    glyphIds.reserve(arr.size());
+    positions.reserve(arr.size());
+
+    for (size_t i = 0; i < arr.size(); ++i) {
+      auto obj = arr[i];
+      auto pos = PointProp::processValue(obj.getValue(PropNamePos));
+      auto identifier =
+          static_cast<SkGlyphID>(obj.getValue(PropNameId).getAsNumber());
+      glyphInfo.positions.push_back(pos);
+      glyphInfo.glyphIds.push_back(identifier);
+    }
+
+    setDerivedValue(std::move(glyphInfo));
+  }
+
+private:
+  NodeProp *_glyphsProp;
+};
+
+} // namespace RNSkia