@shopify/react-native-skia 0.1.158 → 0.1.159

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

@@ -0,0 +1,83 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+#include "JsiSkPoint.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPoint.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class PointModeProp : public DerivedProp<SkCanvas::PointMode> {
+public:
+  explicit PointModeProp(PropId name) : DerivedProp<SkCanvas::PointMode>() {
+    _pointModeProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_pointModeProp->isSet()) {
+      setDerivedValue(
+          getPointModeFromStringValue(_pointModeProp->value().getAsString()));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  static SkCanvas::PointMode
+  getPointModeFromStringValue(const std::string &value) {
+    if (value == "points") {
+      return SkCanvas::PointMode::kPoints_PointMode;
+    } else if (value == "lines") {
+      return SkCanvas::PointMode::kLines_PointMode;
+    } else if (value == "polygon") {
+      return SkCanvas::PointMode::kPolygon_PointMode;
+    }
+    throw std::runtime_error(
+        "Expected valid point mode for Points node, got \"" + value + "\".");
+  }
+
+  NodeProp *_pointModeProp;
+};
+
+class PointsProp : public DerivedProp<std::vector<SkPoint>> {
+public:
+  explicit PointsProp(PropId name) : DerivedProp<std::vector<SkPoint>>() {
+    _pointsProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_pointsProp->isSet()) {
+      auto pointsArray = _pointsProp->value().getAsArray();
+      std::vector<SkPoint> points;
+      points.reserve(pointsArray.size());
+      for (size_t i = 0; i < pointsArray.size(); ++i) {
+        auto p = pointsArray[i];
+        auto point = PointProp::processValue(p);
+        if (point != EmptyPoint) {
+          points.push_back(point);
+        } else {
+          throw std::runtime_error(
+              "Expected array of points for points property.");
+        }
+      }
+      setDerivedValue(std::move(points));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  NodeProp *_pointsProp;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,134 @@
+#pragma once
+
+#include "JsiSkRRect.h"
+#include "NodeProp.h"
+#include "RectProp.h"
+
+#include <memory>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRRect.h>
+#include <SkRect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+static PropId PropNameRx = JsiPropId::get("rx");
+static PropId PropNameRy = JsiPropId::get("ry");
+static PropId PropNameR = JsiPropId::get("r");
+
+/**
+ Reads a rect from a given propety in the node. The name of the property is
+ provided on the constructor. The property can either be a Javascript property
+ or a host object representing an SkRect.
+ */
+class RRectProp : public DerivedProp<SkRRect> {
+public:
+  explicit RRectProp(PropId name) : DerivedProp() {
+    _prop = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_prop->isSet()) {
+      // Check for JsiSkRRect
+      if (_prop->value().getType() == PropType::HostObject) {
+        // Try reading as rect
+        auto rectPtr = std::dynamic_pointer_cast<JsiSkRRect>(
+            _prop->value().getAsHostObject());
+        if (rectPtr != nullptr) {
+          auto rrect = rectPtr->getObject();
+          setDerivedValue(SkRRect::MakeRectXY(
+              SkRect::MakeXYWH(rrect->rect().x(), rrect->rect().y(),
+                               rrect->rect().width(), rrect->rect().height()),
+              rrect->getSimpleRadii().x(), rrect->getSimpleRadii().y()));
+        }
+      } else {
+        if (_prop->isSet() && _prop->value().getType() == PropType::Object) {
+          auto p = _prop->value();
+          if (p.hasValue(PropNameX) && p.hasValue(PropNameY) &&
+              p.hasValue(PropNameWidth) && p.hasValue(PropNameHeight) &&
+              p.hasValue(PropNameRx) && p.hasValue(PropNameRy)) {
+            auto x = _prop->value().getValue(PropNameX);
+            auto y = _prop->value().getValue(PropNameY);
+            auto width = _prop->value().getValue(PropNameWidth);
+            auto height = _prop->value().getValue(PropNameHeight);
+            auto rx = _prop->value().getValue(PropNameRx);
+            auto ry = _prop->value().getValue(PropNameRy);
+
+            // Update cache from js object value
+            setDerivedValue(SkRRect::MakeRectXY(
+                SkRect::MakeXYWH(x.getAsNumber(), y.getAsNumber(),
+                                 width.getAsNumber(), height.getAsNumber()),
+                rx.getAsNumber(), ry.getAsNumber()));
+          }
+        }
+      }
+    }
+  }
+
+private:
+  NodeProp *_prop;
+};
+
+/**
+ Reads rect properties from a node's properties
+ */
+class RRectPropFromProps : public DerivedProp<SkRRect> {
+public:
+  RRectPropFromProps() : DerivedProp<SkRRect>() {
+    _x = addProperty(std::make_shared<NodeProp>(PropNameX));
+    _y = addProperty(std::make_shared<NodeProp>(PropNameY));
+    _width = addProperty(std::make_shared<NodeProp>(PropNameWidth));
+    _height = addProperty(std::make_shared<NodeProp>(PropNameHeight));
+    _r = addProperty(std::make_shared<NodeProp>(PropNameR));
+  }
+
+  void updateDerivedValue() override {
+    if (_x->isSet() && _y->isSet() && _width->isSet() && _height->isSet() &&
+        _r->isSet()) {
+      setDerivedValue(SkRRect::MakeRectXY(
+          SkRect::MakeXYWH(_x->value().getAsNumber(), _y->value().getAsNumber(),
+                           _width->value().getAsNumber(),
+                           _height->value().getAsNumber()),
+          _r->value().getAsNumber(), _r->value().getAsNumber()));
+    }
+  }
+
+private:
+  NodeProp *_x;
+  NodeProp *_y;
+  NodeProp *_width;
+  NodeProp *_height;
+  NodeProp *_r;
+};
+
+/**
+ Reads rect props from either a given property or from the property object
+ itself.
+ */
+class RRectProps : public DerivedProp<SkRRect> {
+public:
+  explicit RRectProps(PropId name) : DerivedProp<SkRRect>() {
+    _rectProp = addProperty<RRectProp>(std::make_shared<RRectProp>(name));
+    _rectPropFromProps =
+        addProperty<RRectPropFromProps>(std::make_shared<RRectPropFromProps>());
+  }
+
+  void updateDerivedValue() override {
+    if (_rectProp->isSet()) {
+      setDerivedValue(_rectProp->getDerivedValue());
+    } else if (_rectPropFromProps->isSet()) {
+      setDerivedValue(_rectPropFromProps->getDerivedValue());
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  RRectProp *_rectProp;
+  RRectPropFromProps *_rectPropFromProps;
+};
+} // namespace RNSkia

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

@@ -0,0 +1,43 @@
+#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 {
+
+class RadiusProp : public DerivedProp<SkPoint> {
+public:
+  explicit RadiusProp(PropId name) : DerivedProp<SkPoint>() {
+    _pointProp = addProperty(std::make_shared<PointProp>(name));
+    _radiusProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_pointProp->isSet()) {
+      setDerivedValue(_pointProp->getDerivedValue());
+      return;
+    }
+
+    if (_radiusProp->isSet()) {
+      setDerivedValue(SkPoint::Make(_radiusProp->value().getAsNumber(),
+                                    _radiusProp->value().getAsNumber()));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  PointProp *_pointProp;
+  NodeProp *_radiusProp;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,118 @@
+#pragma once
+
+#include "NodeProp.h"
+#include "PointProp.h"
+
+#include <memory>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+static PropId PropNameRect = JsiPropId::get("rect");
+static PropId PropNameWidth = JsiPropId::get("width");
+static PropId PropNameHeight = JsiPropId::get("height");
+
+/**
+ Reads a rect from a given propety in the node. The name of the property is
+ provided on the constructor. The property can either be a Javascript property
+ or a host object representing an SkRect.
+ */
+class RectProp : public DerivedProp<SkRect> {
+public:
+  explicit RectProp(PropId name) : DerivedProp() {
+    _prop = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_prop->isSet()) {
+      // Check for JsiSkRect
+      if (_prop->value().getType() == PropType::HostObject) {
+        auto rectPtr = std::dynamic_pointer_cast<JsiSkRect>(
+            _prop->value().getAsHostObject());
+        if (rectPtr != nullptr) {
+          setDerivedValue(SkRect::MakeXYWH(
+              rectPtr->getObject()->x(), rectPtr->getObject()->y(),
+              rectPtr->getObject()->width(), rectPtr->getObject()->height()));
+        }
+      } else {
+        auto p = _prop->value();
+        if (p.hasValue(PropNameX) && p.hasValue(PropNameY) &&
+            p.hasValue(PropNameWidth) && p.hasValue(PropNameHeight)) {
+          // Save props for fast access
+          auto x = p.getValue(PropNameX);
+          auto y = p.getValue(PropNameY);
+          auto width = p.getValue(PropNameWidth);
+          auto height = p.getValue(PropNameHeight);
+
+          // Update cache from js object value
+          setDerivedValue(SkRect::MakeXYWH(x.getAsNumber(), y.getAsNumber(),
+                                           width.getAsNumber(),
+                                           height.getAsNumber()));
+        }
+      }
+    }
+  }
+
+private:
+  NodeProp *_prop;
+};
+
+/**
+ Reads rect properties from a node's properties
+ */
+class RectPropFromProps : public DerivedProp<SkRect> {
+public:
+  RectPropFromProps() : DerivedProp<SkRect>() {
+    _x = addProperty(std::make_shared<NodeProp>(PropNameX));
+    _y = addProperty(std::make_shared<NodeProp>(PropNameY));
+    _width = addProperty(std::make_shared<NodeProp>(PropNameWidth));
+    _height = addProperty(std::make_shared<NodeProp>(PropNameHeight));
+  }
+
+  void updateDerivedValue() override {
+    if (_x->isSet() && _y->isSet() && _width->isSet() && _height->isSet()) {
+      setDerivedValue(SkRect::MakeXYWH(
+          _x->value().getAsNumber(), _y->value().getAsNumber(),
+          _width->value().getAsNumber(), _height->value().getAsNumber()));
+    }
+  }
+
+private:
+  NodeProp *_x;
+  NodeProp *_y;
+  NodeProp *_width;
+  NodeProp *_height;
+};
+
+/**
+ Reads rect props from either a given property or from the property object
+ itself.
+ */
+class RectProps : public DerivedProp<SkRect> {
+public:
+  explicit RectProps(PropId name) : DerivedProp<SkRect>() {
+    _rectProp = addProperty(std::make_shared<RectProp>(name));
+    _rectPropFromProps = addProperty(std::make_shared<RectPropFromProps>());
+  }
+
+  void updateDerivedValue() override {
+    if (_rectProp->isSet()) {
+      setDerivedValue(_rectProp->getDerivedValue());
+    } else if (_rectPropFromProps->isSet()) {
+      setDerivedValue(_rectPropFromProps->getDerivedValue());
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  RectProp *_rectProp;
+  RectPropFromProps *_rectPropFromProps;
+};
+} // namespace RNSkia

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

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include <memory>
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPaint.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class StrokeCapProp : public DerivedProp<SkPaint::Cap> {
+public:
+  explicit StrokeCapProp(PropId name) : DerivedProp<SkPaint::Cap>() {
+    _strokeCap = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_strokeCap->isSet() && (_strokeCap->isChanged())) {
+      auto capValue = _strokeCap->value().getAsString();
+      setDerivedValue(getCapFromString(capValue));
+    }
+  }
+
+  static SkPaint::Cap getCapFromString(const std::string &value) {
+    if (value == "round") {
+      return SkPaint::Cap::kRound_Cap;
+    } else if (value == "butt") {
+      return SkPaint::Cap::kButt_Cap;
+    } else if (value == "square") {
+      return SkPaint::Cap::kSquare_Cap;
+    }
+    throw std::runtime_error("Property value \"" + value +
+                             "\" is not a legal stroke cap.");
+  }
+
+private:
+  NodeProp *_strokeCap;
+};
+
+class StrokeJoinProp : public DerivedProp<SkPaint::Join> {
+public:
+  explicit StrokeJoinProp(PropId name) : DerivedProp<SkPaint::Join>() {
+    _strokeJoin = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_strokeJoin->isSet() && (_strokeJoin->isChanged())) {
+      auto joinValue = _strokeJoin->value().getAsString();
+      setDerivedValue(getJoinFromString(joinValue));
+    }
+  }
+
+  static SkPaint::Join getJoinFromString(const std::string &value) {
+    if (value == "miter") {
+      return SkPaint::Join::kMiter_Join;
+    } else if (value == "round") {
+      return SkPaint::Join::kRound_Join;
+    } else if (value == "bevel") {
+      return SkPaint::Join::kBevel_Join;
+    }
+    throw std::runtime_error("Property value \"" + value +
+                             "\" is not a legal stroke join.");
+  }
+
+private:
+  NodeProp *_strokeJoin;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "JsiSkSVG.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class SvgProp : public DerivedSkProp<SkSVGDOM> {
+public:
+  explicit SvgProp(PropId name) : DerivedSkProp<SkSVGDOM>() {
+    _imageSvgProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_imageSvgProp->value().getType() != PropType::HostObject) {
+      throw std::runtime_error(
+          "Expected SkSvgDom object for the svg property.");
+    }
+
+    auto ptr = std::dynamic_pointer_cast<JsiSkSVG>(
+        _imageSvgProp->value().getAsHostObject());
+    if (ptr == nullptr) {
+      throw std::runtime_error(
+          "Expected SkSvgDom object for the svg property.");
+    }
+
+    setDerivedValue(ptr->getObject());
+  }
+
+private:
+  NodeProp *_imageSvgProp;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,128 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "JsiSkTextBlob.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace RNSkia {
+
+class TextBlobProp : public DerivedSkProp<SkTextBlob> {
+public:
+  explicit TextBlobProp(PropId name) : DerivedSkProp<SkTextBlob>() {
+    _textBlobProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_textBlobProp->value().getType() != PropType::HostObject) {
+      throw std::runtime_error("Expected SkTextBlob object for the " +
+                               std::string(getName()) + " property.");
+    }
+
+    auto ptr = _textBlobProp->value().getAs<JsiSkTextBlob>();
+    if (ptr == nullptr) {
+      throw std::runtime_error("Expected SkTextBlob object for the " +
+                               std::string(getName()) + " property.");
+    }
+
+    setDerivedValue(ptr->getObject());
+  }
+
+private:
+  NodeProp *_textBlobProp;
+};
+
+class TextPathBlobProp : public DerivedSkProp<SkTextBlob> {
+public:
+  TextPathBlobProp() : DerivedSkProp<SkTextBlob>() {
+    _fontProp = addProperty(std::make_shared<FontProp>(JsiPropId::get("font")));
+    _textProp = addProperty(std::make_shared<NodeProp>(JsiPropId::get("text")));
+    _pathProp = addProperty(std::make_shared<PathProp>(JsiPropId::get("path")));
+    _offsetProp = addProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("initialOffset")));
+
+    _fontProp->require();
+    _textProp->require();
+    _pathProp->require();
+    _offsetProp->require();
+  }
+
+  void updateDerivedValue() override {
+    auto font = _fontProp->getDerivedValue();
+    auto text = _textProp->value().getAsString();
+    auto path = _pathProp->getDerivedValue();
+    auto offset = _offsetProp->value().getAsNumber();
+
+    // Get glyphs
+    auto numGlyphIds =
+        font->countText(text.c_str(), text.length(), SkTextEncoding::kUTF8);
+
+    std::vector<SkGlyphID> glyphIds;
+    glyphIds.reserve(numGlyphIds);
+    auto ids = font->textToGlyphs(
+        text.c_str(), text.length(), SkTextEncoding::kUTF8,
+        static_cast<SkGlyphID *>(glyphIds.data()), numGlyphIds);
+
+    // Get glyph widths
+    int glyphsSize = static_cast<int>(ids);
+    std::vector<SkScalar> widthPtrs;
+    widthPtrs.resize(glyphsSize);
+    font->getWidthsBounds(glyphIds.data(), numGlyphIds,
+                          static_cast<SkScalar *>(widthPtrs.data()), nullptr,
+                          nullptr); // TODO: Should we use paint somehow here?
+
+    std::vector<SkRSXform> rsx;
+    SkContourMeasureIter meas(*path, false, 1);
+
+    auto cont = meas.next();
+    auto dist = offset;
+
+    for (size_t i = 0; i < text.length() && cont != nullptr; ++i) {
+      auto width = widthPtrs[i];
+      dist += width / 2;
+      if (dist > cont->length()) {
+        // jump to next contour
+        cont = meas.next();
+        if (cont == nullptr) {
+          // We have come to the end of the path - terminate the string
+          // right here.
+          text = text.substr(0, i);
+          break;
+        }
+        dist = width / 2;
+      }
+      // Gives us the (x, y) coordinates as well as the cos/sin of the tangent
+      // line at that position.
+      SkPoint pos;
+      SkVector tan;
+      if (!cont->getPosTan(dist, &pos, &tan)) {
+        throw std::runtime_error(
+            "Could not calculate distance when resolving text path");
+      }
+      auto px = pos.x();
+      auto py = pos.y();
+      auto tx = tan.x();
+      auto ty = tan.y();
+
+      auto adjustedX = px - (width / 2) * tx;
+      auto adjustedY = py - (width / 2) * ty;
+
+      rsx.push_back(SkRSXform::Make(tx, ty, adjustedX, adjustedY));
+      dist += width / 2;
+    }
+
+    setDerivedValue(SkTextBlob::MakeFromRSXform(text.c_str(), text.length(),
+                                                rsx.data(), *font));
+  }
+
+private:
+  FontProp *_fontProp;
+  NodeProp *_textProp;
+  PathProp *_pathProp;
+  NodeProp *_offsetProp;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkTileMode.h>
+
+#include <memory>
+#include <string>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class TileModeProp : public DerivedProp<SkTileMode> {
+public:
+  explicit TileModeProp(PropId name) : DerivedProp<SkTileMode>() {
+    _tileModeProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_tileModeProp->isSet()) {
+      setDerivedValue(
+          getTileModeFromStringValue(_tileModeProp->value().getAsString()));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  SkTileMode getTileModeFromStringValue(const std::string &value) {
+    if (value == "clamp") {
+      return SkTileMode::kClamp;
+    } else if (value == "repeat") {
+      return SkTileMode::kRepeat;
+    } else if (value == "mirror") {
+      return SkTileMode::kMirror;
+    } else if (value == "decal") {
+      return SkTileMode::kDecal;
+    }
+    throw std::runtime_error("Value \"" + value +
+                             "\" is not a valid tile mode.");
+  }
+
+  NodeProp *_tileModeProp;
+};
+
+} // namespace RNSkia