@pompadour/react-native-skia 1.4.0

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(const 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,86 @@
+// 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/core/SkSpan.h"
+#include "modules/skparagraph/include/FontArguments.h"
+#include "modules/skparagraph/include/ParagraphCache.h"
+#include "modules/skparagraph/include/TextStyle.h"
+#include "src/core/SkTHash.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> defaultEmojiFallback(SkUnichar emojiStart, 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;
+    skia_private::THashMap<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,289 @@
+// Copyright 2019 Google LLC.
+#ifndef Paragraph_DEFINED
+#define Paragraph_DEFINED
+
+#include "include/core/SkPath.h"
+#include "modules/skparagraph/include/FontCollection.h"
+#include "modules/skparagraph/include/Metrics.h"
+#include "modules/skparagraph/include/ParagraphStyle.h"
+#include "modules/skparagraph/include/TextStyle.h"
+#include <unordered_set>
+
+class SkCanvas;
+
+namespace skia {
+namespace textlayout {
+
+class ParagraphPainter;
+
+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;
+
+    virtual void paint(ParagraphPainter* painter, 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;
+    virtual std::unordered_set<SkUnichar> unresolvedCodepoints() = 0;
+
+    // Experimental API that allows fast way to update some of "immutable" paragraph attributes
+    // but not the text itself
+    virtual void updateTextAlign(TextAlign textAlign) = 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;
+
+    struct ExtendedVisitorInfo {
+        const SkFont&   font;
+        SkPoint         origin;
+        SkSize          advance;
+        int             count;
+        const uint16_t* glyphs;     // count values
+        SkPoint*        positions;  // count values
+        const SkRect*   bounds;     // count values
+        const uint32_t* utf8Starts; // count+1 values
+        unsigned        flags;
+    };
+    using ExtendedVisitor = std::function<void(int lineNumber, const ExtendedVisitorInfo*)>;
+    virtual void extendedVisit(const ExtendedVisitor&) = 0;
+
+    /* Returns path for a given line
+     *
+     * @param lineNumber  a line number
+     * @param dest        a resulting path
+     * @return            a number glyphs that could not be converted to path
+     */
+    virtual int getPath(int lineNumber, SkPath* dest) = 0;
+
+    /* Returns path for a text blob
+     *
+     * @param textBlob    a text blob
+     * @return            a path
+     */
+    static SkPath GetPath(SkTextBlob* textBlob);
+
+    /* Checks if a given text blob contains
+     * glyph with emoji
+     *
+     * @param textBlob    a text blob
+     * @return            true if there is such a glyph
+     */
+    virtual bool containsEmoji(SkTextBlob* textBlob) = 0;
+
+    /* Checks if a given text blob contains colored font or bitmap
+     *
+     * @param textBlob    a text blob
+     * @return            true if there is such a glyph
+     */
+    virtual bool containsColorFontOrBitmap(SkTextBlob* textBlob) = 0;
+
+    // Editing API
+
+    /* Finds the line number of the line that contains the given UTF-8 index.
+    *
+    * @param index         a UTF-8 TextIndex into the paragraph
+    * @return              the line number the glyph that corresponds to the
+    *                      given codeUnitIndex is in, or -1 if the codeUnitIndex
+    *                      is out of bounds, or when the glyph is truncated or
+    *                      ellipsized away.
+    */
+    virtual int getLineNumberAt(TextIndex codeUnitIndex) const = 0;
+
+    /* Finds the line number of the line that contains the given UTF-16 index.
+    *
+    * @param index         a UTF-16 offset into the paragraph
+    * @return              the line number the glyph that corresponds to the
+    *                      given codeUnitIndex is in, or -1 if the codeUnitIndex
+    *                      is out of bounds, or when the glyph is truncated or
+    *                      ellipsized away.
+    */
+    virtual int getLineNumberAtUTF16Offset(size_t codeUnitIndex) = 0;
+
+    /* Returns line metrics info for the line
+     *
+     * @param lineNumber    a line number
+     * @param lineMetrics   an address to return the info (in case of null just skipped)
+     * @return              true if the line is found; false if not
+     */
+    virtual bool getLineMetricsAt(int lineNumber, LineMetrics* lineMetrics) const = 0;
+
+    /* Returns the visible text on the line (excluding a possible ellipsis)
+     *
+     * @param lineNumber    a line number
+     * @param includeSpaces indicates if the whitespaces should be included
+     * @return              the range of the text that is shown in the line
+     */
+    virtual TextRange getActualTextRange(int lineNumber, bool includeSpaces) const = 0;
+
+    struct GlyphClusterInfo {
+        SkRect fBounds;
+        TextRange fClusterTextRange;
+        TextDirection fGlyphClusterPosition;
+    };
+
+    /** Finds a glyph cluster for text index
+     *
+     * @param codeUnitIndex   a text index
+     * @param glyphInfo       a glyph cluster info filled if not null
+     * @return                true if glyph cluster was found; false if not
+     */
+    virtual bool getGlyphClusterAt(TextIndex codeUnitIndex, GlyphClusterInfo* glyphInfo) = 0;
+
+    /** Finds the closest glyph cluster for a visual text position
+     *
+     * @param dx              x coordinate
+     * @param dy              y coordinate
+     * @param glyphInfo       a glyph cluster info filled if not null
+     * @return                true if glyph cluster was found; false if not
+     *                        (which usually means the paragraph is empty)
+     */
+    virtual bool getClosestGlyphClusterAt(SkScalar dx,
+                                          SkScalar dy,
+                                          GlyphClusterInfo* glyphInfo) = 0;
+
+    // The glyph and grapheme cluster information assoicated with a unicode
+    // codepoint in the paragraph.
+    struct GlyphInfo {
+        SkRect fGraphemeLayoutBounds;
+        TextRange fGraphemeClusterTextRange;
+        TextDirection fDirection;
+        bool fIsEllipsis;
+    };
+
+    /** Retrives the information associated with the glyph located at the given
+     *  codeUnitIndex.
+     *
+     * @param codeUnitIndex   a UTF-16 offset into the paragraph
+     * @param glyphInfo       an optional GlyphInfo struct to hold the
+     *                        information associated with the glyph found at the
+     *                        given index
+     * @return                false only if the offset is out of bounds
+     */
+    virtual bool getGlyphInfoAtUTF16Offset(size_t codeUnitIndex, GlyphInfo* glyphInfo) = 0;
+
+    /** Finds the information associated with the closest glyph to the given
+     *  paragraph coordinates.
+     *
+     * @param dx              x coordinate
+     * @param dy              y coordinate
+     * @param glyphInfo       an optional GlyphInfo struct to hold the
+     *                        information associated with the glyph found. The
+     *                        text indices and text ranges are described using
+     *                        UTF-16 offsets
+     * @return                true if a graphme cluster was found; false if not
+     *                        (which usually means the paragraph is empty)
+     */
+    virtual bool getClosestUTF16GlyphInfoAt(SkScalar dx, SkScalar dy, GlyphInfo* glyphInfo) = 0;
+
+    struct FontInfo {
+        FontInfo(const SkFont& font, const TextRange textRange)
+                : fFont(font), fTextRange(textRange) {}
+        virtual ~FontInfo() = default;
+        FontInfo(const FontInfo& ) = default;
+        SkFont fFont;
+        TextRange fTextRange;
+    };
+
+    /** Returns the font that is used to shape the text at the position
+     *
+     * @param codeUnitIndex   text index
+     * @return                font info or an empty font info if the text is not found
+     */
+    virtual SkFont getFontAt(TextIndex codeUnitIndex) const = 0;
+
+    /** Returns the font used to shape the text at the given UTF-16 offset.
+     *
+     * @param codeUnitIndex   a UTF-16 offset in the paragraph
+     * @return                font info or an empty font info if the text is not found
+     */
+    virtual SkFont getFontAtUTF16Offset(size_t codeUnitIndex) = 0;
+
+    /** Returns the information about all the fonts used to shape the paragraph text
+     *
+     * @return                a list of fonts and text ranges
+     */
+    virtual std::vector<FontInfo> getFonts() const = 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