@react-native-ohos/react-native-svg 15.12.1-rc.1

package/harmony/svg/src/main/cpp/utils/GlyphContext.cpp

@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ *
+ * This file incorporates from the react-native-svg project, licensed under
+ * the MIT License. Specifically:
+ * - [software-mansion/react-native-svg] (https://github.com/software-mansion/react-native-svg)
+ */
+
+#include "GlyphContext.h"
+
+namespace rnoh {
+namespace svg {
+
+void GlyphContext::pushContext(bool reset, const std::shared_ptr<SvgNode> &node, DimensionArray x, DimensionArray y,
+                               DimensionArray deltaX, DimensionArray deltaY, DimensionArray rotate) {
+    if (reset) {
+        this->reset();
+    }
+
+    DLOG(INFO) << "GLYPH PUSHING"
+               << " mTop = " << mTop << " node = " << node;
+    pushNode(node);
+
+    if (!x.empty()) {
+        mXsIndex++;
+        mXIndex = -1;
+        mXIndices.push_back(mXIndex);
+        mXs = x;
+        mXsContext.push_back(mXs);
+    }
+
+    if (!y.empty()) {
+        mYsIndex++;
+        mYIndex = -1;
+        mYIndices.push_back(mYIndex);
+        mYs = y;
+        mYsContext.push_back(mYs);
+    }
+
+    if (!deltaX.empty()) {
+        mDXsIndex++;
+        mDXIndex = -1;
+        mDXIndices.push_back(mDXIndex);
+        mDXs = deltaX;
+        mDXsContext.push_back(mDXs);
+    }
+
+    if (!deltaY.empty()) {
+        mDYsIndex++;
+        mDYIndex = -1;
+        mDYIndices.push_back(mDYIndex);
+        mDYs = deltaY;
+        mDYsContext.push_back(mDYs);
+    }
+
+    if (!rotate.empty()) {
+        mRsIndex++;
+        mRIndex = -1;
+        mRIndices.push_back(mRIndex);
+        // convert Dimension vector to double
+        mRs.clear();
+        for (const auto &ro : rotate) {
+            mRs.emplace_back(ro.Value());
+        }
+        mRsContext.push_back(mRs);
+    }
+
+    pushIndices();
+}
+void GlyphContext::popContext() {
+    mXsIndices.pop_back();
+    mYsIndices.pop_back();
+    mDXsIndices.pop_back();
+    mDYsIndices.pop_back();
+    mRsIndices.pop_back();
+
+    mTop--;
+
+    int x = mXsIndex;
+    int y = mYsIndex;
+    int dx = mDXsIndex;
+    int dy = mDYsIndex;
+    int r = mRsIndex;
+
+    DLOG(INFO) << "GLYPH mTop = " << mTop << " mXsIndices size = " << mXsIndices.size();
+    mXsIndex = mXsIndices[mTop];
+    mYsIndex = mYsIndices[mTop];
+    mDXsIndex = mDXsIndices[mTop];
+    mDYsIndex = mDYsIndices[mTop];
+    mRsIndex = mRsIndices[mTop];
+
+    if (x != mXsIndex) {
+        mXsContext.erase(mXsContext.begin() + x);
+        mXs = mXsContext[mXsIndex];
+        mXIndex = mXIndices[mXsIndex];
+    }
+    if (y != mYsIndex) {
+        mYsContext.erase(mYsContext.begin() + y);
+        mYs = mYsContext[mYsIndex];
+        mYIndex = mYIndices[mYsIndex];
+    }
+    if (dx != mDXsIndex) {
+        mDXsContext.erase(mDXsContext.begin() + dx);
+        mDXs = mDXsContext[mDXsIndex];
+        mDXIndex = mDXIndices[mDXsIndex];
+    }
+    if (dy != mDYsIndex) {
+        mDYsContext.erase(mDYsContext.begin() + dy);
+        mDYs = mDYsContext[mDYsIndex];
+        mDYIndex = mDYIndices[mDYsIndex];
+    }
+    if (r != mRsIndex) {
+        mRsContext.erase(mRsContext.begin() + r);
+        mRs = mRsContext[mRsIndex];
+        mRIndex = mRIndices[mRsIndex];
+    }
+}
+double GlyphContext::nextX(double advance) {
+    incrementIndices(mXIndices, mXsIndex);
+
+    int nextIndex = mXIndex + 1;
+    if (nextIndex < mXs.size()) {
+        mDX = 0;
+        mXIndex = nextIndex;
+        Dimension string = mXs[nextIndex];
+        mX = string.RelativeConvertToPx(mWidth, mScale);
+    }
+
+    mX += advance;
+
+    return mX;
+}
+double GlyphContext::nextDeltaX() {
+    incrementIndices(mDXIndices, mDXsIndex);
+
+    int nextIndex = mDXIndex + 1;
+    if (nextIndex < mDXs.size()) {
+        mDXIndex = nextIndex;
+        Dimension string = mDXs[nextIndex];
+        double val = string.RelativeConvertToPx(mWidth, mScale);
+        mDX += val;
+    }
+
+    return mDX;
+}
+double GlyphContext::nextDeltaY() {
+    incrementIndices(mDYIndices, mDYsIndex);
+
+    int nextIndex = mDYIndex + 1;
+    if (nextIndex < mDYs.size()) {
+        mDYIndex = nextIndex;
+        Dimension string = mDYs[nextIndex];
+        double val = string.RelativeConvertToPx(mHeight, mScale);
+        mDY += val;
+    }
+
+    return mDY;
+}
+
+double GlyphContext::nextRotation() {
+    incrementIndices(mRIndices, mRsIndex);
+
+    mRIndex = std::min(mRIndex + 1, static_cast<int>(mRs.size()) - 1);
+
+    if (mRIndex < 0) {
+        // DLOG(INF0) << "ROTATION IS NULL";
+        return 0.0;
+    }
+    return mRs[mRIndex];
+}
+double GlyphContext::nextY() {
+    incrementIndices(mYIndices, mYsIndex);
+
+    int nextIndex = mYIndex + 1;
+    if (nextIndex < mYs.size()) {
+        mDY = 0;
+        mYIndex = nextIndex;
+        Dimension string = mYs[nextIndex];
+        mY = string.RelativeConvertToPx(mHeight, mScale);
+    }
+
+    return mY;
+}
+void GlyphContext::incrementIndices(std::vector<int> &indices, int topIndex) {
+    for (int index = topIndex; index >= 0; index--) {
+        int xIndex = indices[index];
+        indices[index] = xIndex + 1;
+    }
+}
+GlyphContext::GlyphContext(float scale, float width, float height) : mScale(scale), mWidth(width), mHeight(height) {
+    mXsContext.push_back(mXs);
+    mYsContext.push_back(mYs);
+    mDXsContext.push_back(mDXs);
+    mDYsContext.push_back(mDYs);
+    mRsContext.push_back(mRs);
+
+    mXIndices.push_back(mXIndex);
+    mYIndices.push_back(mYIndex);
+    mDXIndices.push_back(mDXIndex);
+    mDYIndices.push_back(mDYIndex);
+    mRIndices.push_back(mRIndex);
+
+    pushIndices();
+}
+void GlyphContext::pushIndices() {
+    mXsIndices.push_back(mXsIndex);
+    mYsIndices.push_back(mYsIndex);
+    mDXsIndices.push_back(mDXsIndex);
+    mDYsIndices.push_back(mDYsIndex);
+    mRsIndices.push_back(mRsIndex);
+}
+void GlyphContext::reset() {
+    mXsIndex = mYsIndex = mDXsIndex = mDYsIndex = mRsIndex = 0;
+    mXIndex = mYIndex = mDXIndex = mDYIndex = mRIndex = -1;
+    mX = mY = mDX = mDY = 0;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/utils/GlyphContext.h

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ *
+ * This file incorporates from the react-native-svg project, licensed under
+ * the MIT License. Specifically:
+ * - [software-mansion/react-native-svg] (https://github.com/software-mansion/react-native-svg)
+ */
+
+#pragma once
+
+#include <vector>
+#include <memory>
+#include "properties/Dimension.h"
+#include "SvgNode.h"
+
+namespace rnoh {
+namespace svg {
+
+class GlyphContext {
+
+private:
+    std::vector<Dimension> mXs;
+    std::vector<Dimension> mYs;
+    std::vector<Dimension> mDXs;
+    std::vector<Dimension> mDYs;
+    std::vector<double> mRs;
+    int mXsIndex = 0;
+    int mYsIndex = 0;
+    int mDXsIndex = 0;
+    int mDYsIndex = 0;
+    int mRsIndex = 0;
+    int mXIndex = 0;
+    int mYIndex = 0;
+    int mDXIndex = 0;
+    int mDYIndex = 0;
+    int mRIndex = 0;
+    int mTop = 0;
+    float mScale = 0.0f;
+    float mWidth = 0.0f;
+    float mHeight = 0.0f;
+    std::vector<int> mXsIndices;
+    std::vector<int> mYsIndices;
+    std::vector<int> mDXsIndices;
+    std::vector<int> mDYsIndices;
+    std::vector<int> mRsIndices;
+    std::vector<std::vector<Dimension>> mXsContext;
+    std::vector<std::vector<Dimension>> mYsContext;
+    std::vector<std::vector<Dimension>> mDXsContext;
+    std::vector<std::vector<Dimension>> mDYsContext;
+    std::vector<std::vector<double>> mRsContext;
+    std::vector<int> mXIndices;
+    std::vector<int> mYIndices;
+    std::vector<int> mDXIndices;
+    std::vector<int> mDYIndices;
+    std::vector<int> mRIndices;
+    double mX = 0.0;
+    double mY = 0.0;
+    double mDX = 0.0;
+    double mDY = 0.0;
+
+    void pushIndices();
+
+    void reset();
+
+    void pushNode(const std::shared_ptr<SvgNode> &node) { mTop++; }
+
+public:
+    GlyphContext(float scale, float width, float height);
+
+    void pushContext(const std::shared_ptr<SvgNode> &node) {
+        pushNode(node);
+        pushIndices();
+    }
+
+    using DimensionArray = const std::vector<Dimension> &;
+    void pushContext(bool reset, const std::shared_ptr<SvgNode> &node, DimensionArray x, DimensionArray y,
+                     DimensionArray deltaX, DimensionArray deltaY, DimensionArray rotate);
+
+    void popContext();
+
+    static void incrementIndices(std::vector<int> &indices, int topIndex);
+
+    /**
+     * @param advance in x position by the next span.
+     * @return x position for this next span.
+     */
+    double nextX(double advance);
+
+    double nextY();
+
+    double nextDeltaX();
+
+    double nextDeltaY();
+
+    double nextRotation();
+
+    float getWidth() { return mWidth; }
+
+
+    float getHeight() { return mHeight; }
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/utils/LinearMap.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+
+// from ArkUI "frameworks/base/utils/linear_map.h"
+#pragma once
+
+#include <algorithm>
+#include <cstring>
+
+namespace rnoh {
+namespace svg {
+
+template<typename T>
+struct LinearMapNode {
+    const char* key;
+    T value;
+};
+
+// the key type K must can be compared.
+template<typename K, typename V>
+struct LinearEnumMapNode {
+    K key;
+    V value;
+};
+
+// these binary search functions in linear map, so the map must be sorted by key.
+template<typename T>
+int64_t BinarySearchFindIndex(const LinearMapNode<T>* vec, size_t length, const char* key)
+{
+    auto it = std::lower_bound(
+        vec, vec + length, key, [](LinearMapNode<T> lhs, const char* key) { return strcmp(lhs.key, key) < 0; });
+    if (it == vec + length || strcmp(it->key, key) != 0) {
+        return -1;
+    } else {
+        return it - vec;
+    }
+}
+
+template<typename K, typename V>
+int64_t BinarySearchFindIndex(const LinearEnumMapNode<K, V>* vec, size_t length, K key)
+{
+    auto it =
+        std::lower_bound(vec, vec + length, key, [](LinearEnumMapNode<K, V> lhs, K key) { return lhs.key < key; });
+    if (it == vec + length || it->key != key) {
+        return -1;
+    } else {
+        return it - vec;
+    }
+}
+} // namespace svg
+} // namespace rnoh