react-native-tgfx 0.0.0 → 0.0.2-alpha.0

package/cpp/third_party/tgfx/src/svg/SVGParseColor.cpp

@@ -0,0 +1,363 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2024 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include "svg/SVGUtils.h"
+#include "tgfx/core/Color.h"
+
+namespace {
+constexpr const char* colorNames[] = {
+    "aliceblue",
+    "antiquewhite",
+    "aqua",
+    "aquamarine",
+    "azure",
+    "beige",
+    "bisque",
+    "black",
+    "blanchedalmond",
+    "blue",
+    "blueviolet",
+    "brown",
+    "burlywood",
+    "cadetblue",
+    "chartreuse",
+    "chocolate",
+    "coral",
+    "cornflowerblue",
+    "cornsilk",
+    "crimson",
+    "cyan",
+    "darkblue",
+    "darkcyan",
+    "darkgoldenrod",
+    "darkgray",
+    "darkgreen",
+    "darkgrey",
+    "darkkhaki",
+    "darkmagenta",
+    "darkolivegreen",
+    "darkorange",
+    "darkorchid",
+    "darkred",
+    "darksalmon",
+    "darkseagreen",
+    "darkslateblue",
+    "darkslategray",
+    "darkslategrey",
+    "darkturquoise",
+    "darkviolet",
+    "deeppink",
+    "deepskyblue",
+    "dimgray",
+    "dimgrey",
+    "dodgerblue",
+    "firebrick",
+    "floralwhite",
+    "forestgreen",
+    "fuchsia",
+    "gainsboro",
+    "ghostwhite",
+    "gold",
+    "goldenrod",
+    "gray",
+    "green",
+    "greenyellow",
+    "grey",
+    "honeydew",
+    "hotpink",
+    "indianred",
+    "indigo",
+    "ivory",
+    "khaki",
+    "lavender",
+    "lavenderblush",
+    "lawngreen",
+    "lemonchiffon",
+    "lightblue",
+    "lightcoral",
+    "lightcyan",
+    "lightgoldenrodyellow",
+    "lightgray",
+    "lightgreen",
+    "lightgrey",
+    "lightpink",
+    "lightsalmon",
+    "lightseagreen",
+    "lightskyblue",
+    "lightslategray",
+    "lightslategrey",
+    "lightsteelblue",
+    "lightyellow",
+    "lime",
+    "limegreen",
+    "linen",
+    "magenta",
+    "maroon",
+    "mediumaquamarine",
+    "mediumblue",
+    "mediumorchid",
+    "mediumpurple",
+    "mediumseagreen",
+    "mediumslateblue",
+    "mediumspringgreen",
+    "mediumturquoise",
+    "mediumvioletred",
+    "midnightblue",
+    "mintcream",
+    "mistyrose",
+    "moccasin",
+    "navajowhite",
+    "navy",
+    "oldlace",
+    "olive",
+    "olivedrab",
+    "orange",
+    "orangered",
+    "orchid",
+    "palegoldenrod",
+    "palegreen",
+    "paleturquoise",
+    "palevioletred",
+    "papayawhip",
+    "peachpuff",
+    "peru",
+    "pink",
+    "plum",
+    "powderblue",
+    "purple",
+    "rebeccapurple",
+    "red",
+    "rosybrown",
+    "royalblue",
+    "saddlebrown",
+    "salmon",
+    "sandybrown",
+    "seagreen",
+    "seashell",
+    "sienna",
+    "silver",
+    "skyblue",
+    "slateblue",
+    "slategray",
+    "slategrey",
+    "snow",
+    "springgreen",
+    "steelblue",
+    "tan",
+    "teal",
+    "thistle",
+    "tomato",
+    "turquoise",
+    "violet",
+    "wheat",
+    "white",
+    "whitesmoke",
+    "yellow",
+    "yellowgreen",
+};
+
+// Compile-time check to ensure colorNames is sorted for binary search (std::lower_bound).
+constexpr bool ColorNamesSorted() {
+  for (size_t i = 1; i < std::size(colorNames); ++i) {
+    if (std::string_view(colorNames[i - 1]) >= std::string_view(colorNames[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static_assert(ColorNamesSorted(), "colorNames must be sorted alphabetically");
+
+struct ColorRec {
+  uint8_t r, g, b;
+};
+
+constexpr ColorRec colors[] = {
+    {0xf0, 0xf8, 0xff},  // aliceblue
+    {0xfa, 0xeb, 0xd7},  // antiquewhite
+    {0x00, 0xff, 0xff},  // aqua
+    {0x7f, 0xff, 0xd4},  // aquamarine
+    {0xf0, 0xff, 0xff},  // azure
+    {0xf5, 0xf5, 0xdc},  // beige
+    {0xff, 0xe4, 0xc4},  // bisque
+    {0x00, 0x00, 0x00},  // black
+    {0xff, 0xeb, 0xcd},  // blanchedalmond
+    {0x00, 0x00, 0xff},  // blue
+    {0x8a, 0x2b, 0xe2},  // blueviolet
+    {0xa5, 0x2a, 0x2a},  // brown
+    {0xde, 0xb8, 0x87},  // burlywood
+    {0x5f, 0x9e, 0xa0},  // cadetblue
+    {0x7f, 0xff, 0x00},  // chartreuse
+    {0xd2, 0x69, 0x1e},  // chocolate
+    {0xff, 0x7f, 0x50},  // coral
+    {0x64, 0x95, 0xed},  // cornflowerblue
+    {0xff, 0xf8, 0xdc},  // cornsilk
+    {0xdc, 0x14, 0x3c},  // crimson
+    {0x00, 0xff, 0xff},  // cyan
+    {0x00, 0x00, 0x8b},  // darkblue
+    {0x00, 0x8b, 0x8b},  // darkcyan
+    {0xb8, 0x86, 0x0b},  // darkgoldenrod
+    {0xa9, 0xa9, 0xa9},  // darkgray
+    {0x00, 0x64, 0x00},  // darkgreen
+    {0xa9, 0xa9, 0xa9},  // darkgrey
+    {0xbd, 0xb7, 0x6b},  // darkkhaki
+    {0x8b, 0x00, 0x8b},  // darkmagenta
+    {0x55, 0x6b, 0x2f},  // darkolivegreen
+    {0xff, 0x8c, 0x00},  // darkorange
+    {0x99, 0x32, 0xcc},  // darkorchid
+    {0x8b, 0x00, 0x00},  // darkred
+    {0xe9, 0x96, 0x7a},  // darksalmon
+    {0x8f, 0xbc, 0x8f},  // darkseagreen
+    {0x48, 0x3d, 0x8b},  // darkslateblue
+    {0x2f, 0x4f, 0x4f},  // darkslategray
+    {0x2f, 0x4f, 0x4f},  // darkslategrey
+    {0x00, 0xce, 0xd1},  // darkturquoise
+    {0x94, 0x00, 0xd3},  // darkviolet
+    {0xff, 0x14, 0x93},  // deeppink
+    {0x00, 0xbf, 0xff},  // deepskyblue
+    {0x69, 0x69, 0x69},  // dimgray
+    {0x69, 0x69, 0x69},  // dimgrey
+    {0x1e, 0x90, 0xff},  // dodgerblue
+    {0xb2, 0x22, 0x22},  // firebrick
+    {0xff, 0xfa, 0xf0},  // floralwhite
+    {0x22, 0x8b, 0x22},  // forestgreen
+    {0xff, 0x00, 0xff},  // fuchsia
+    {0xdc, 0xdc, 0xdc},  // gainsboro
+    {0xf8, 0xf8, 0xff},  // ghostwhite
+    {0xff, 0xd7, 0x00},  // gold
+    {0xda, 0xa5, 0x20},  // goldenrod
+    {0x80, 0x80, 0x80},  // gray
+    {0x00, 0x80, 0x00},  // green
+    {0xad, 0xff, 0x2f},  // greenyellow
+    {0x80, 0x80, 0x80},  // grey
+    {0xf0, 0xff, 0xf0},  // honeydew
+    {0xff, 0x69, 0xb4},  // hotpink
+    {0xcd, 0x5c, 0x5c},  // indianred
+    {0x4b, 0x00, 0x82},  // indigo
+    {0xff, 0xff, 0xf0},  // ivory
+    {0xf0, 0xe6, 0x8c},  // khaki
+    {0xe6, 0xe6, 0xfa},  // lavender
+    {0xff, 0xf0, 0xf5},  // lavenderblush
+    {0x7c, 0xfc, 0x00},  // lawngreen
+    {0xff, 0xfa, 0xcd},  // lemonchiffon
+    {0xad, 0xd8, 0xe6},  // lightblue
+    {0xf0, 0x80, 0x80},  // lightcoral
+    {0xe0, 0xff, 0xff},  // lightcyan
+    {0xfa, 0xfa, 0xd2},  // lightgoldenrodyellow
+    {0xd3, 0xd3, 0xd3},  // lightgray
+    {0x90, 0xee, 0x90},  // lightgreen
+    {0xd3, 0xd3, 0xd3},  // lightgrey
+    {0xff, 0xb6, 0xc1},  // lightpink
+    {0xff, 0xa0, 0x7a},  // lightsalmon
+    {0x20, 0xb2, 0xaa},  // lightseagreen
+    {0x87, 0xce, 0xfa},  // lightskyblue
+    {0x77, 0x88, 0x99},  // lightslategray
+    {0x77, 0x88, 0x99},  // lightslategrey
+    {0xb0, 0xc4, 0xde},  // lightsteelblue
+    {0xff, 0xff, 0xe0},  // lightyellow
+    {0x00, 0xff, 0x00},  // lime
+    {0x32, 0xcd, 0x32},  // limegreen
+    {0xfa, 0xf0, 0xe6},  // linen
+    {0xff, 0x00, 0xff},  // magenta
+    {0x80, 0x00, 0x00},  // maroon
+    {0x66, 0xcd, 0xaa},  // mediumaquamarine
+    {0x00, 0x00, 0xcd},  // mediumblue
+    {0xba, 0x55, 0xd3},  // mediumorchid
+    {0x93, 0x70, 0xdb},  // mediumpurple
+    {0x3c, 0xb3, 0x71},  // mediumseagreen
+    {0x7b, 0x68, 0xee},  // mediumslateblue
+    {0x00, 0xfa, 0x9a},  // mediumspringgreen
+    {0x48, 0xd1, 0xcc},  // mediumturquoise
+    {0xc7, 0x15, 0x85},  // mediumvioletred
+    {0x19, 0x19, 0x70},  // midnightblue
+    {0xf5, 0xff, 0xfa},  // mintcream
+    {0xff, 0xe4, 0xe1},  // mistyrose
+    {0xff, 0xe4, 0xb5},  // moccasin
+    {0xff, 0xde, 0xad},  // navajowhite
+    {0x00, 0x00, 0x80},  // navy
+    {0xfd, 0xf5, 0xe6},  // oldlace
+    {0x80, 0x80, 0x00},  // olive
+    {0x6b, 0x8e, 0x23},  // olivedrab
+    {0xff, 0xa5, 0x00},  // orange
+    {0xff, 0x45, 0x00},  // orangered
+    {0xda, 0x70, 0xd6},  // orchid
+    {0xee, 0xe8, 0xaa},  // palegoldenrod
+    {0x98, 0xfb, 0x98},  // palegreen
+    {0xaf, 0xee, 0xee},  // paleturquoise
+    {0xdb, 0x70, 0x93},  // palevioletred
+    {0xff, 0xef, 0xd5},  // papayawhip
+    {0xff, 0xda, 0xb9},  // peachpuff
+    {0xcd, 0x85, 0x3f},  // peru
+    {0xff, 0xc0, 0xcb},  // pink
+    {0xdd, 0xa0, 0xdd},  // plum
+    {0xb0, 0xe0, 0xe6},  // powderblue
+    {0x80, 0x00, 0x80},  // purple
+    {0x66, 0x33, 0x99},  // rebeccapurple
+    {0xff, 0x00, 0x00},  // red
+    {0xbc, 0x8f, 0x8f},  // rosybrown
+    {0x41, 0x69, 0xe1},  // royalblue
+    {0x8b, 0x45, 0x13},  // saddlebrown
+    {0xfa, 0x80, 0x72},  // salmon
+    {0xf4, 0xa4, 0x60},  // sandybrown
+    {0x2e, 0x8b, 0x57},  // seagreen
+    {0xff, 0xf5, 0xee},  // seashell
+    {0xa0, 0x52, 0x2d},  // sienna
+    {0xc0, 0xc0, 0xc0},  // silver
+    {0x87, 0xce, 0xeb},  // skyblue
+    {0x6a, 0x5a, 0xcd},  // slateblue
+    {0x70, 0x80, 0x90},  // slategray
+    {0x70, 0x80, 0x90},  // slategrey
+    {0xff, 0xfa, 0xfa},  // snow
+    {0x00, 0xff, 0x7f},  // springgreen
+    {0x46, 0x82, 0xb4},  // steelblue
+    {0xd2, 0xb4, 0x8c},  // tan
+    {0x00, 0x80, 0x80},  // teal
+    {0xd8, 0xbf, 0xd8},  // thistle
+    {0xff, 0x63, 0x47},  // tomato
+    {0x40, 0xe0, 0xd0},  // turquoise
+    {0xee, 0x82, 0xee},  // violet
+    {0xf5, 0xde, 0xb3},  // wheat
+    {0xff, 0xff, 0xff},  // white
+    {0xf5, 0xf5, 0xf5},  // whitesmoke
+    {0xff, 0xff, 0x00},  // yellow
+    {0x9a, 0xcd, 0x32},  // yellowgreen
+};
+}  // namespace
+
+namespace tgfx {
+const char* SVGParse::FindNamedColor(const char* name, Color* color) {
+  const auto rec =
+      std::lower_bound(std::begin(colorNames), std::end(colorNames),
+                       name,  // key
+                       [](const char* name, const char* key) { return strcmp(name, key) < 0; });
+
+  if (rec == std::end(colorNames) || 0 != strcmp(name, *rec)) {
+    return nullptr;
+  }
+
+  if (color) {
+    int64_t index = rec - colorNames;
+    *color = Color::FromRGBA(colors[index].r, colors[index].g, colors[index].b);
+  }
+
+  return name + strlen(*rec);
+}
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/svg/SVGPathParser.cpp

@@ -0,0 +1,292 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2025 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "tgfx/svg/SVGPathParser.h"
+#include "core/NoConicsPathIterator.h"
+#include "core/utils/Log.h"
+#include "svg/SVGUtils.h"
+#include "tgfx/core/Path.h"
+
+namespace tgfx {
+
+namespace {
+inline bool is_lower(int c) {
+  return c >= 'a' && c <= 'z';
+}
+
+inline int to_upper(int c) {
+  return c - 'a' + 'A';
+}
+
+inline bool is_ws(int c) {
+  return c >= 1 && c <= 32;
+}
+
+inline bool is_sep(int c) {
+  return is_ws(c) || c == ',' || c == ';';
+}
+
+const char* skip_sep(const char str[]) {
+  ASSERT(str);
+  while (is_sep(*str)) {
+    str++;
+  }
+  return str;
+}
+
+inline bool is_digit(int c) {
+  return c >= '0' && c <= '9';
+}
+
+const char* skip_ws(const char str[]) {
+  ASSERT(str);
+  while (is_ws(*str)) {
+    str++;
+  }
+  return str;
+}
+
+// If unable to read count points from str into value, this will return nullptr
+// to signal the failure. Otherwise, it will return the next offset to read from.
+const char* find_points(const char str[], Point value[], int count, bool isRelative,
+                        Point* relative) {
+  str = SVGParse::FindScalars(str, &value[0].x, count * 2);
+  if (isRelative) {
+    for (int index = 0; index < count; index++) {
+      value[index].x += relative->x;
+      value[index].y += relative->y;
+    }
+  }
+  return str;
+}
+
+// If unable to read a scalar from str into value, this will return nullptr
+// to signal the failure. Otherwise, it will return the next offset to read from.
+const char* find_scalar(const char str[], float* value, bool isRelative, float relative) {
+  str = SVGParse::FindScalar(str, value);
+  if (!str) {
+    return nullptr;
+  }
+  if (isRelative) {
+    *value += relative;
+  }
+  str = skip_sep(str);
+  return str;
+}
+
+// https://www.w3.org/TR/SVG11/paths.html#PathDataBNF
+// flag:
+//    "0" | "1"
+const char* find_flag(const char str[], bool* value) {
+  if (!str) {
+    return nullptr;
+  }
+  if (str[0] != '1' && str[0] != '0') {
+    return nullptr;
+  }
+  *value = str[0] != '0';
+  str = skip_sep(str + 1);
+  return str;
+}
+}  // namespace
+
+std::string SVGPathParser::ToSVGString(const Path& path, PathEncoding encoding) {
+  Point currentPoint = {};
+  const int relSelector = encoding == PathEncoding::Relative ? 1 : 0;
+
+  const auto appendCommand = [&](std::string& inputString, char commandChar, const Point points[],
+                                 size_t offset, size_t count) {
+    // Use lower case cmds for relative encoding.
+    commandChar = static_cast<char>(commandChar + (32 * relSelector));
+    inputString.push_back(commandChar);
+    for (size_t i = 0; i < count; ++i) {
+      const auto pt = points[offset + i] - currentPoint;
+      if (i > 0) {
+        inputString.push_back(' ');
+      }
+      inputString.append(FloatToString(pt.x) + " " + FloatToString(pt.y));
+    }
+
+    DEBUG_ASSERT(count > 0);
+    // For relative encoding, track the current point (otherwise == origin).
+    currentPoint = {points[offset + count - 1].x * static_cast<float>(relSelector),
+                    points[offset + count - 1].y * static_cast<float>(relSelector)};
+  };
+
+  std::string svgString;
+  NoConicsPathIterator iterator(path);
+  for (auto segment : iterator) {
+    switch (segment.verb) {
+      case PathVerb::Move:
+        appendCommand(svgString, 'M', segment.points, 0, 1);
+        break;
+      case PathVerb::Line:
+        appendCommand(svgString, 'L', segment.points, 1, 1);
+        break;
+      case PathVerb::Quad:
+        appendCommand(svgString, 'Q', segment.points, 1, 2);
+        break;
+      case PathVerb::Cubic:
+        appendCommand(svgString, 'C', segment.points, 1, 3);
+        break;
+      case PathVerb::Close:
+        svgString.push_back('Z');
+        break;
+      default:
+        break;
+    }
+  }
+  return svgString;
+}
+
+std::shared_ptr<Path> SVGPathParser::FromSVGString(const std::string& pathString) {
+  const char* data = pathString.c_str();
+  // We will write all data to this local path and only write it to result if the whole parsing
+  // succeeds.
+  auto path = std::make_shared<Path>();
+  Point first = {};
+  Point opOrigin = {};
+  Point lastOpOrigin = {};
+
+  // We will use find_points and find_scalar to read into these. There might not be enough data to
+  // fill them, so to avoid MSAN warnings about using uninitialized bytes, we initialize them there.
+  Point points[3] = {};
+  float scratch = 0;
+  char op = '\0';
+  char previousOp = '\0';
+  bool relative = false;
+  for (;;) {
+    if (!data) {
+      // Truncated data
+      return nullptr;
+    }
+    data = skip_ws(data);
+    if (data[0] == '\0') {
+      break;
+    }
+    char ch = data[0];
+    if (is_digit(ch) || ch == '-' || ch == '+' || ch == '.') {
+      if (op == '\0' || op == 'Z') {
+        return nullptr;
+      }
+    } else if (is_sep(ch)) {
+      data = skip_sep(data);
+    } else {
+      op = ch;
+      relative = false;
+      if (is_lower(op)) {
+        op = static_cast<char>(to_upper(op));
+        relative = true;
+      }
+      data++;
+      data = skip_sep(data);
+    }
+    switch (op) {
+      case 'M':  // Move
+        data = find_points(data, points, 1, relative, &opOrigin);
+        // find_points might have failed, so this might be the previous point. However, data will be
+        // set to nullptr if it failed, so we will check this at the top of the loop.
+        path->moveTo(points[0]);
+        previousOp = '\0';
+        op = 'L';
+        opOrigin = points[0];
+        break;
+      case 'L':  // Line
+        data = find_points(data, points, 1, relative, &opOrigin);
+        path->lineTo(points[0]);
+        opOrigin = points[0];
+        break;
+      case 'H':  // Horizontal Line
+        data = find_scalar(data, &scratch, relative, opOrigin.x);
+        // Similarly, if there wasn't a scalar to read, data will be set to nullptr and this lineTo
+        // is bogus but will be ultimately ignored when the next time through the loop  detects that
+        // and bails out.
+        path->lineTo(scratch, opOrigin.y);
+        opOrigin.x = scratch;
+        break;
+      case 'V':  // Vertical Line
+        data = find_scalar(data, &scratch, relative, opOrigin.y);
+        path->lineTo(opOrigin.x, scratch);
+        opOrigin.y = scratch;
+        break;
+      case 'C':  // Cubic Bezier Curve
+        data = find_points(data, points, 3, relative, &opOrigin);
+        goto cubicCommon;
+      case 'S':  // Continued "Smooth" Cubic Bezier Curve
+        data = find_points(data, &points[1], 2, relative, &opOrigin);
+        points[0] = opOrigin;
+        if (previousOp == 'C' || previousOp == 'S') {
+          points[0].x -= lastOpOrigin.x - opOrigin.x;
+          points[0].y -= lastOpOrigin.y - opOrigin.y;
+        }
+      cubicCommon:
+        path->cubicTo(points[0], points[1], points[2]);
+        lastOpOrigin = points[1];
+        opOrigin = points[2];
+        break;
+      case 'Q':  // Quadratic Bezier Curve
+        data = find_points(data, points, 2, relative, &opOrigin);
+        goto quadraticCommon;
+      case 'T':  // Continued Quadratic Bezier Curve
+        data = find_points(data, &points[1], 1, relative, &opOrigin);
+        points[0] = opOrigin;
+        if (previousOp == 'Q' || previousOp == 'T') {
+          points[0].x -= lastOpOrigin.x - opOrigin.x;
+          points[0].y -= lastOpOrigin.y - opOrigin.y;
+        }
+      quadraticCommon:
+        path->quadTo(points[0], points[1]);
+        lastOpOrigin = points[0];
+        opOrigin = points[1];
+        break;
+      case 'A': {  // Arc (Elliptical)
+        Point xyRadii = {};
+        float angle = 0.0f;
+        bool largeArc = true;
+        bool sweep = true;
+
+        if (data = find_points(data, &xyRadii, 1, false, nullptr); !data) break;
+        if (data = skip_sep(data); !data) break;
+        if (data = find_scalar(data, &angle, false, 0); !data) break;
+        if (data = skip_sep(data); !data) break;
+        if (data = find_flag(data, &largeArc); !data) break;
+        if (data = skip_sep(data); !data) break;
+        if (data = find_flag(data, &sweep); !data) break;
+        if (data = skip_sep(data); !data) break;
+        if (data = find_points(data, &points[0], 1, relative, &opOrigin); !data) break;
+
+        auto arcSize = largeArc ? PathArcSize::Large : PathArcSize::Small;
+        path->arcTo(xyRadii.x, xyRadii.y, angle, arcSize, !sweep, points[0]);
+        path->getLastPoint(&opOrigin);
+      } break;
+      case 'Z':  // Close Path
+        path->close();
+        opOrigin = first;
+        break;
+      default:
+        return nullptr;
+    }
+    if (previousOp == 0) {
+      first = opOrigin;
+    }
+    previousOp = op;
+  }
+  return path;
+}
+
+}  // namespace tgfx