@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/skia/modules/skparagraph/include/DartTypes.h

@@ -0,0 +1,153 @@
+// Copyright 2019 Google LLC.
+
+#ifndef DartTypes_DEFINED
+#define DartTypes_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkTypes.h"
+
+#include <algorithm>
+#include <iterator>
+#include <limits>
+
+namespace skia {
+namespace textlayout {
+
+enum Affinity { kUpstream, kDownstream };
+
+enum class RectHeightStyle {
+    // Provide tight bounding boxes that fit heights per run.
+    kTight,
+
+    // The height of the boxes will be the maximum height of all runs in the
+    // line. All rects in the same line will be the same height.
+    kMax,
+
+    // Extends the top and/or bottom edge of the bounds to fully cover any line
+    // spacing. The top edge of each line should be the same as the bottom edge
+    // of the line above. There should be no gaps in vertical coverage given any
+    // ParagraphStyle line_height.
+    //
+    // The top and bottom of each rect will cover half of the
+    // space above and half of the space below the line.
+    kIncludeLineSpacingMiddle,
+    // The line spacing will be added to the top of the rect.
+    kIncludeLineSpacingTop,
+    // The line spacing will be added to the bottom of the rect.
+    kIncludeLineSpacingBottom,
+    //
+    kStrut
+};
+
+enum class RectWidthStyle {
+    // Provide tight bounding boxes that fit widths to the runs of each line
+    // independently.
+    kTight,
+
+    // Extends the width of the last rect of each line to match the position of
+    // the widest rect over all the lines.
+    kMax
+};
+
+enum class TextAlign {
+    kLeft,
+    kRight,
+    kCenter,
+    kJustify,
+    kStart,
+    kEnd,
+};
+
+enum class TextDirection {
+    kRtl,
+    kLtr,
+};
+
+struct PositionWithAffinity {
+    int32_t position;
+    Affinity affinity;
+
+    PositionWithAffinity() : position(0), affinity(kDownstream) {}
+    PositionWithAffinity(int32_t p, Affinity a) : position(p), affinity(a) {}
+};
+
+struct TextBox {
+    SkRect rect;
+    TextDirection direction;
+
+    TextBox(SkRect r, TextDirection d) : rect(r), direction(d) {}
+};
+
+// -------------------------------------------------------------------
+// --- Reversed iterable
+
+template<typename C, typename UnaryFunction>
+UnaryFunction directional_for_each(C& c, bool forwards, UnaryFunction f) {
+    return forwards
+              ? std::for_each(std::begin(c), std::end(c), f)
+              : std::for_each(std::rbegin(c), std::rend(c), f);
+}
+
+const size_t EMPTY_INDEX = std::numeric_limits<size_t>::max();
+template <typename T> struct SkRange {
+    SkRange() : start(), end() {}
+    SkRange(T s, T e) : start(s), end(e) {}
+
+    using SignedT = std::make_signed_t<T>;
+
+    T start, end;
+
+    bool operator==(const SkRange<T>& other) const {
+        return start == other.start && end == other.end;
+    }
+
+    T width() const { return end - start; }
+
+    void Shift(SignedT delta) {
+        start += delta;
+        end += delta;
+    }
+
+    bool contains(SkRange<size_t> other) const {
+        return start <= other.start && end >= other.end;
+    }
+
+    bool intersects(SkRange<size_t> other) const {
+        return std::max(start, other.start) <= std::min(end, other.end);
+    }
+
+    SkRange<size_t> intersection(SkRange<size_t> other) const {
+        return SkRange<size_t>(std::max(start, other.start), std::min(end, other.end));
+    }
+
+    bool empty() const {
+        return start == EMPTY_INDEX && end == EMPTY_INDEX;
+    }
+};
+
+const SkRange<size_t> EMPTY_RANGE = SkRange<size_t>(EMPTY_INDEX, EMPTY_INDEX);
+
+
+enum class TextBaseline {
+    kAlphabetic,
+    kIdeographic,
+};
+
+enum TextHeightBehavior {
+    kAll = 0x0,
+    kDisableFirstAscent = 0x1,
+    kDisableLastDescent = 0x2,
+    kDisableAll = 0x1 | 0x2,
+};
+
+enum class LineMetricStyle : uint8_t {
+    // Use ascent, descent, etc from a fixed baseline.
+    Typographic,
+    // Use ascent, descent, etc like css with the leading split and with height adjustments
+    CSS
+};
+
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // DartTypes_DEFINED

package/cpp/skia/modules/skparagraph/include/FontArguments.h

@@ -0,0 +1,46 @@
+// Copyright 2019 Google LLC.
+#ifndef FontArguments_DEFINED
+#define FontArguments_DEFINED
+
+#include <functional>
+#include <vector>
+#include "include/core/SkFontArguments.h"
+#include "include/core/SkTypeface.h"
+
+namespace skia {
+namespace textlayout {
+
+class FontArguments {
+public:
+    FontArguments(const SkFontArguments&);
+    FontArguments(const FontArguments&) = default;
+    FontArguments(FontArguments&&) = default;
+
+    FontArguments& operator=(const FontArguments&) = default;
+    FontArguments& operator=(FontArguments&&) = default;
+
+    sk_sp<SkTypeface> CloneTypeface(sk_sp<SkTypeface> typeface) const;
+
+    friend bool operator==(const FontArguments& a, const FontArguments& b);
+    friend bool operator!=(const FontArguments& a, const FontArguments& b);
+    friend struct std::hash<FontArguments>;
+
+private:
+    FontArguments() = delete;
+
+    int fCollectionIndex;
+    std::vector<SkFontArguments::VariationPosition::Coordinate> fCoordinates;
+    int fPaletteIndex;
+    std::vector<SkFontArguments::Palette::Override> fPaletteOverrides;
+};
+
+}  // namespace textlayout
+}  // namespace skia
+
+namespace std {
+    template<> struct hash<skia::textlayout::FontArguments> {
+        size_t operator()(const skia::textlayout::FontArguments& args) const;
+    };
+}
+
+#endif  // FontArguments_DEFINED

package/cpp/skia/modules/skparagraph/include/FontCollection.h

@@ -0,0 +1,84 @@
+// Copyright 2019 Google LLC.
+#ifndef FontCollection_DEFINED
+#define FontCollection_DEFINED
+
+#include <memory>
+#include <optional>
+#include <set>
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkTHash.h"
+#include "modules/skparagraph/include/FontArguments.h"
+#include "modules/skparagraph/include/ParagraphCache.h"
+#include "modules/skparagraph/include/TextStyle.h"
+
+namespace skia {
+namespace textlayout {
+
+class TextStyle;
+class Paragraph;
+class FontCollection : public SkRefCnt {
+public:
+    FontCollection();
+
+    size_t getFontManagersCount() const;
+
+    void setAssetFontManager(sk_sp<SkFontMgr> fontManager);
+    void setDynamicFontManager(sk_sp<SkFontMgr> fontManager);
+    void setTestFontManager(sk_sp<SkFontMgr> fontManager);
+    void setDefaultFontManager(sk_sp<SkFontMgr> fontManager);
+    void setDefaultFontManager(sk_sp<SkFontMgr> fontManager, const char defaultFamilyName[]);
+    void setDefaultFontManager(sk_sp<SkFontMgr> fontManager, const std::vector<SkString>& defaultFamilyNames);
+
+    sk_sp<SkFontMgr> getFallbackManager() const { return fDefaultFontManager; }
+
+    std::vector<sk_sp<SkTypeface>> findTypefaces(const std::vector<SkString>& familyNames, SkFontStyle fontStyle);
+    std::vector<sk_sp<SkTypeface>> findTypefaces(const std::vector<SkString>& familyNames, SkFontStyle fontStyle, const std::optional<FontArguments>& fontArgs);
+
+    sk_sp<SkTypeface> defaultFallback(SkUnichar unicode, SkFontStyle fontStyle, const SkString& locale);
+    sk_sp<SkTypeface> defaultFallback();
+
+    void disableFontFallback();
+    void enableFontFallback();
+    bool fontFallbackEnabled() { return fEnableFontFallback; }
+
+    ParagraphCache* getParagraphCache() { return &fParagraphCache; }
+
+    void clearCaches();
+
+private:
+    std::vector<sk_sp<SkFontMgr>> getFontManagerOrder() const;
+
+    sk_sp<SkTypeface> matchTypeface(const SkString& familyName, SkFontStyle fontStyle);
+
+    struct FamilyKey {
+        FamilyKey(const std::vector<SkString>& familyNames, SkFontStyle style, const std::optional<FontArguments>& args)
+                : fFamilyNames(familyNames), fFontStyle(style), fFontArguments(args) {}
+
+        FamilyKey() {}
+
+        std::vector<SkString> fFamilyNames;
+        SkFontStyle fFontStyle;
+        std::optional<FontArguments> fFontArguments;
+
+        bool operator==(const FamilyKey& other) const;
+
+        struct Hasher {
+            size_t operator()(const FamilyKey& key) const;
+        };
+    };
+
+    bool fEnableFontFallback;
+    SkTHashMap<FamilyKey, std::vector<sk_sp<SkTypeface>>, FamilyKey::Hasher> fTypefaces;
+    sk_sp<SkFontMgr> fDefaultFontManager;
+    sk_sp<SkFontMgr> fAssetFontManager;
+    sk_sp<SkFontMgr> fDynamicFontManager;
+    sk_sp<SkFontMgr> fTestFontManager;
+
+    std::vector<SkString> fDefaultFamilyNames;
+    ParagraphCache fParagraphCache;
+};
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // FontCollection_DEFINED

package/cpp/skia/modules/skparagraph/include/Metrics.h

@@ -0,0 +1,98 @@
+// Copyright 2019 Google LLC.
+#ifndef Metrics_DEFINED
+#define Metrics_DEFINED
+
+#include <map>
+#include "modules/skparagraph/include/TextStyle.h"
+
+namespace skia {
+namespace textlayout {
+class StyleMetrics {
+public:
+    StyleMetrics(const TextStyle* style) : text_style(style) {}
+
+    StyleMetrics(const TextStyle* style, SkFontMetrics& metrics)
+            : text_style(style), font_metrics(metrics) {}
+
+    const TextStyle* text_style;
+
+    // SkFontMetrics contains the following metrics:
+    //
+    // * Top                 distance to reserve above baseline
+    // * Ascent              distance to reserve below baseline
+    // * Descent             extent below baseline
+    // * Bottom              extent below baseline
+    // * Leading             distance to add between lines
+    // * AvgCharWidth        average character width
+    // * MaxCharWidth        maximum character width
+    // * XMin                minimum x
+    // * XMax                maximum x
+    // * XHeight             height of lower-case 'x'
+    // * CapHeight           height of an upper-case letter
+    // * UnderlineThickness  underline thickness
+    // * UnderlinePosition   underline position relative to baseline
+    // * StrikeoutThickness  strikeout thickness
+    // * StrikeoutPosition   strikeout position relative to baseline
+    SkFontMetrics font_metrics;
+};
+
+class LineMetrics {
+public:
+    LineMetrics() { }
+
+    LineMetrics(size_t start,
+                size_t end,
+                size_t end_excluding_whitespace,
+                size_t end_including_newline,
+                bool hard_break)
+            : fStartIndex(start)
+            , fEndIndex(end)
+            , fEndExcludingWhitespaces(end_excluding_whitespace)
+            , fEndIncludingNewline(end_including_newline)
+            , fHardBreak(hard_break) {}
+    // The following fields are used in the layout process itself.
+
+    // The indexes in the text buffer the line begins and ends.
+    size_t fStartIndex = 0;
+    size_t fEndIndex = 0;
+    size_t fEndExcludingWhitespaces = 0;
+    size_t fEndIncludingNewline = 0;
+    bool fHardBreak = false;
+
+    // The following fields are tracked after or during layout to provide to
+    // the user as well as for computing bounding boxes.
+
+    // The final computed ascent and descent for the line. This can be impacted by
+    // the strut, height, scaling, as well as outlying runs that are very tall.
+    //
+    // The top edge is `baseline - ascent` and the bottom edge is `baseline +
+    // descent`. Ascent and descent are provided as positive numbers. Raw numbers
+    // for specific runs of text can be obtained in run_metrics_map. These values
+    // are the cumulative metrics for the entire line.
+    double fAscent = SK_ScalarMax;
+    double fDescent = SK_ScalarMin;
+    double fUnscaledAscent = SK_ScalarMax;
+    // Total height of the paragraph including the current line.
+    //
+    // The height of the current line is `round(ascent + descent)`.
+    double fHeight = 0.0;
+    // Width of the line.
+    double fWidth = 0.0;
+    // The left edge of the line. The right edge can be obtained with `left +
+    // width`
+    double fLeft = 0.0;
+    // The y position of the baseline for this line from the top of the paragraph.
+    double fBaseline = 0.0;
+    // Zero indexed line number
+    size_t fLineNumber = 0;
+
+    // Mapping between text index ranges and the FontMetrics associated with
+    // them. The first run will be keyed under start_index. The metrics here
+    // are before layout and are the base values we calculate from.
+    std::map<size_t, StyleMetrics> fLineMetrics;
+};
+
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // Metrics_DEFINED

package/cpp/skia/modules/skparagraph/include/Paragraph.h

@@ -0,0 +1,111 @@
+// Copyright 2019 Google LLC.
+#ifndef Paragraph_DEFINED
+#define Paragraph_DEFINED
+
+#include "modules/skparagraph/include/FontCollection.h"
+#include "modules/skparagraph/include/Metrics.h"
+#include "modules/skparagraph/include/ParagraphStyle.h"
+#include "modules/skparagraph/include/TextStyle.h"
+
+class SkCanvas;
+
+namespace skia {
+namespace textlayout {
+
+class Paragraph {
+
+public:
+    Paragraph(ParagraphStyle style, sk_sp<FontCollection> fonts);
+
+    virtual ~Paragraph() = default;
+
+    SkScalar getMaxWidth() { return fWidth; }
+
+    SkScalar getHeight() { return fHeight; }
+
+    SkScalar getMinIntrinsicWidth() { return fMinIntrinsicWidth; }
+
+    SkScalar getMaxIntrinsicWidth() { return fMaxIntrinsicWidth; }
+
+    SkScalar getAlphabeticBaseline() { return fAlphabeticBaseline; }
+
+    SkScalar getIdeographicBaseline() { return fIdeographicBaseline; }
+
+    SkScalar getLongestLine() { return fLongestLine; }
+
+    bool didExceedMaxLines() { return fExceededMaxLines; }
+
+    virtual void layout(SkScalar width) = 0;
+
+    virtual void paint(SkCanvas* canvas, SkScalar x, SkScalar y) = 0;
+
+    // Returns a vector of bounding boxes that enclose all text between
+    // start and end glyph indexes, including start and excluding end
+    virtual std::vector<TextBox> getRectsForRange(unsigned start,
+                                                  unsigned end,
+                                                  RectHeightStyle rectHeightStyle,
+                                                  RectWidthStyle rectWidthStyle) = 0;
+
+    virtual std::vector<TextBox> getRectsForPlaceholders() = 0;
+
+    // Returns the index of the glyph that corresponds to the provided coordinate,
+    // with the top left corner as the origin, and +y direction as down
+    virtual PositionWithAffinity getGlyphPositionAtCoordinate(SkScalar dx, SkScalar dy) = 0;
+
+    // Finds the first and last glyphs that define a word containing
+    // the glyph at index offset
+    virtual SkRange<size_t> getWordBoundary(unsigned offset) = 0;
+
+    virtual void getLineMetrics(std::vector<LineMetrics>&) = 0;
+
+    virtual size_t lineNumber() = 0;
+
+    virtual void markDirty() = 0;
+
+    // This function will return the number of unresolved glyphs or
+    // -1 if not applicable (has not been shaped yet - valid case)
+    virtual int32_t unresolvedGlyphs() = 0;
+
+    // Experimental API that allows fast way to update "immutable" paragraph
+    virtual void updateTextAlign(TextAlign textAlign) = 0;
+    virtual void updateText(size_t from, SkString text) = 0;
+    virtual void updateFontSize(size_t from, size_t to, SkScalar fontSize) = 0;
+    virtual void updateForegroundPaint(size_t from, size_t to, SkPaint paint) = 0;
+    virtual void updateBackgroundPaint(size_t from, size_t to, SkPaint paint) = 0;
+
+    enum VisitorFlags {
+        kWhiteSpace_VisitorFlag = 1 << 0,
+    };
+    struct VisitorInfo {
+        const SkFont&   font;
+        SkPoint         origin;
+        SkScalar        advanceX;
+        int             count;
+        const uint16_t* glyphs;     // count values
+        const SkPoint*  positions;  // count values
+        const uint32_t* utf8Starts; // count+1 values
+        unsigned        flags;
+    };
+
+    // lineNumber begins at 0. If info is null, this signals the end of that line.
+    using Visitor = std::function<void(int lineNumber, const VisitorInfo*)>;
+    virtual void visit(const Visitor&) = 0;
+
+protected:
+    sk_sp<FontCollection> fFontCollection;
+    ParagraphStyle fParagraphStyle;
+
+    // Things for Flutter
+    SkScalar fAlphabeticBaseline;
+    SkScalar fIdeographicBaseline;
+    SkScalar fHeight;
+    SkScalar fWidth;
+    SkScalar fMaxIntrinsicWidth;
+    SkScalar fMinIntrinsicWidth;
+    SkScalar fLongestLine;
+    bool fExceededMaxLines;
+};
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // Paragraph_DEFINED

package/cpp/skia/modules/skparagraph/include/ParagraphBuilder.h

@@ -0,0 +1,69 @@
+// Copyright 2019 Google LLC.
+#ifndef ParagraphBuilder_DEFINED
+#define ParagraphBuilder_DEFINED
+
+#include <memory>
+#include <stack>
+#include <string>
+#include <tuple>
+#include "modules/skparagraph/include/FontCollection.h"
+#include "modules/skparagraph/include/Paragraph.h"
+#include "modules/skparagraph/include/ParagraphStyle.h"
+#include "modules/skparagraph/include/TextStyle.h"
+
+namespace skia {
+namespace textlayout {
+
+class ParagraphBuilder {
+public:
+    ParagraphBuilder(const ParagraphStyle&, sk_sp<FontCollection>) { }
+
+    virtual ~ParagraphBuilder() = default;
+
+    // Push a style to the stack. The corresponding text added with AddText will
+    // use the top-most style.
+    virtual void pushStyle(const TextStyle& style) = 0;
+
+    // Remove a style from the stack. Useful to apply different styles to chunks
+    // of text such as bolding.
+    // Example:
+    //   builder.PushStyle(normal_style);
+    //   builder.AddText("Hello this is normal. ");
+    //
+    //   builder.PushStyle(bold_style);
+    //   builder.AddText("And this is BOLD. ");
+    //
+    //   builder.Pop();
+    //   builder.AddText(" Back to normal again.");
+    virtual void pop() = 0;
+
+    virtual TextStyle peekStyle() = 0;
+
+    // Adds UTF16-encoded text to the builder. Forms the proper runs to use the upper-most style
+    // on the style_stack.
+    virtual void addText(const std::u16string& text) = 0;
+
+    // Adds UTF8-encoded text to the builder, using the top-most style on the style_stack.
+    virtual void addText(const char* text) = 0;
+    virtual void addText(const char* text, size_t len) = 0;
+
+    // Pushes the information required to leave an open space, where Flutter may
+    // draw a custom placeholder into.
+    // Internally, this method adds a single object replacement character (0xFFFC)
+    virtual void addPlaceholder(const PlaceholderStyle& placeholderStyle) = 0;
+
+    // Constructs a SkParagraph object that can be used to layout and paint the text to a SkCanvas.
+    virtual std::unique_ptr<Paragraph> Build() = 0;
+
+    // Resets this builder to its initial state, discarding any text, styles, placeholders that have
+    // been added, but keeping the initial ParagraphStyle.
+    virtual void Reset() = 0;
+
+    // Just until we fix all the google3 code
+    static std::unique_ptr<ParagraphBuilder> make(const ParagraphStyle& style,
+                                                  sk_sp<FontCollection> fontCollection);
+};
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // ParagraphBuilder_DEFINED

package/cpp/skia/modules/skparagraph/include/ParagraphCache.h

@@ -0,0 +1,77 @@
+// Copyright 2019 Google LLC.
+#ifndef ParagraphCache_DEFINED
+#define ParagraphCache_DEFINED
+
+#include "include/private/SkMutex.h"
+#include "src/core/SkLRUCache.h"
+#include <functional>  // std::function
+
+#define PARAGRAPH_CACHE_STATS
+
+namespace skia {
+namespace textlayout {
+
+enum InternalState {
+  kUnknown = 0,
+  kShaped = 2,
+  kClusterized = 3,
+  kMarked = 4,
+  kLineBroken = 5,
+  kFormatted = 6,
+  kDrawn = 7
+};
+
+class ParagraphImpl;
+class ParagraphCacheKey;
+class ParagraphCacheValue;
+
+class ParagraphCache {
+public:
+    ParagraphCache();
+    ~ParagraphCache();
+
+    void abandon();
+    void reset();
+    bool updateParagraph(ParagraphImpl* paragraph);
+    bool findParagraph(ParagraphImpl* paragraph);
+
+    // For testing
+    void setChecker(std::function<void(ParagraphImpl* impl, const char*, bool)> checker) {
+        fChecker = std::move(checker);
+    }
+    void printStatistics();
+    void turnOn(bool value) { fCacheIsOn = value; }
+    int count() { return fLRUCacheMap.count(); }
+
+    bool isPossiblyTextEditing(ParagraphImpl* paragraph);
+
+ private:
+
+    struct Entry;
+    void updateFrom(const ParagraphImpl* paragraph, Entry* entry);
+    void updateTo(ParagraphImpl* paragraph, const Entry* entry);
+
+     mutable SkMutex fParagraphMutex;
+     std::function<void(ParagraphImpl* impl, const char*, bool)> fChecker;
+
+    static const int kMaxEntries = 128;
+
+    struct KeyHash {
+        uint32_t operator()(const ParagraphCacheKey& key) const;
+    };
+
+    SkLRUCache<ParagraphCacheKey, std::unique_ptr<Entry>, KeyHash> fLRUCacheMap;
+    bool fCacheIsOn;
+    ParagraphCacheValue* fLastCachedValue;
+
+#ifdef PARAGRAPH_CACHE_STATS
+    int fTotalRequests;
+    int fCacheMisses;
+    int fHashMisses; // cache hit but hash table missed
+#endif
+};
+
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // ParagraphCache_DEFINED