blob: 6bd7c94457fb135529e5af60638d5ab0dad73235 [file] [log] [blame]
// Copyright 2019 Google LLC.
#ifndef ParagraphImpl_DEFINED
#define ParagraphImpl_DEFINED
#include "include/core/SkFont.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSpan.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "include/private/SkBitmaskEnum.h"
#include "include/private/base/SkOnce.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTemplates.h"
#include "modules/skparagraph/include/DartTypes.h"
#include "modules/skparagraph/include/FontCollection.h"
#include "modules/skparagraph/include/Paragraph.h"
#include "modules/skparagraph/include/ParagraphCache.h"
#include "modules/skparagraph/include/ParagraphStyle.h"
#include "modules/skparagraph/include/TextShadow.h"
#include "modules/skparagraph/include/TextStyle.h"
#include "modules/skparagraph/src/Run.h"
#include "modules/skparagraph/src/TextLine.h"
#include "modules/skunicode/include/SkUnicode.h"
#include "src/core/SkTHash.h"
#include <memory>
#include <string>
#include <vector>
class SkCanvas;
namespace skia {
namespace textlayout {
class LineMetrics;
class TextLine;
template <typename T> bool operator==(const SkSpan<T>& a, const SkSpan<T>& b) {
return a.size() == b.size() && a.begin() == b.begin();
}
template <typename T> bool operator<=(const SkSpan<T>& a, const SkSpan<T>& b) {
return a.begin() >= b.begin() && a.end() <= b.end();
}
template <typename TStyle>
struct StyleBlock {
StyleBlock() : fRange(EMPTY_RANGE), fStyle() { }
StyleBlock(size_t start, size_t end, const TStyle& style) : fRange(start, end), fStyle(style) {}
StyleBlock(TextRange textRange, const TStyle& style) : fRange(textRange), fStyle(style) {}
void add(TextRange tail) {
SkASSERT(fRange.end == tail.start);
fRange = TextRange(fRange.start, fRange.start + fRange.width() + tail.width());
}
TextRange fRange;
TStyle fStyle;
};
struct ResolvedFontDescriptor {
ResolvedFontDescriptor(TextIndex index, SkFont font)
: fFont(font), fTextStart(index) { }
SkFont fFont;
TextIndex fTextStart;
};
enum InternalState {
kUnknown = 0,
kIndexed = 1, // Text is indexed
kShaped = 2, // Text is shaped
kLineBroken = 5,
kFormatted = 6,
kDrawn = 7
};
/*
struct BidiRegion {
BidiRegion(size_t start, size_t end, uint8_t dir)
: text(start, end), direction(dir) { }
TextRange text;
uint8_t direction;
};
*/
class ParagraphImpl final : public Paragraph {
public:
ParagraphImpl(const SkString& text,
ParagraphStyle style,
SkTArray<Block, true> blocks,
SkTArray<Placeholder, true> placeholders,
sk_sp<FontCollection> fonts,
std::shared_ptr<SkUnicode> unicode);
ParagraphImpl(const std::u16string& utf16text,
ParagraphStyle style,
SkTArray<Block, true> blocks,
SkTArray<Placeholder, true> placeholders,
sk_sp<FontCollection> fonts,
std::shared_ptr<SkUnicode> unicode);
~ParagraphImpl() override;
void layout(SkScalar width) override;
void paint(SkCanvas* canvas, SkScalar x, SkScalar y) override;
void paint(ParagraphPainter* canvas, SkScalar x, SkScalar y) override;
std::vector<TextBox> getRectsForRange(unsigned start,
unsigned end,
RectHeightStyle rectHeightStyle,
RectWidthStyle rectWidthStyle) override;
std::vector<TextBox> getRectsForPlaceholders() override;
void getLineMetrics(std::vector<LineMetrics>&) override;
PositionWithAffinity getGlyphPositionAtCoordinate(SkScalar dx, SkScalar dy) override;
SkRange<size_t> getWordBoundary(unsigned offset) override;
size_t lineNumber() override { return fLines.size(); }
TextLine& addLine(SkVector offset, SkVector advance,
TextRange textExcludingSpaces, TextRange text, TextRange textIncludingNewlines,
ClusterRange clusters, ClusterRange clustersWithGhosts, SkScalar widthWithSpaces,
InternalLineMetrics sizes);
SkSpan<const char> text() const { return SkSpan<const char>(fText.c_str(), fText.size()); }
InternalState state() const { return fState; }
SkSpan<Run> runs() { return SkSpan<Run>(fRuns.data(), fRuns.size()); }
SkSpan<Block> styles() {
return SkSpan<Block>(fTextStyles.data(), fTextStyles.size());
}
SkSpan<Placeholder> placeholders() {
return SkSpan<Placeholder>(fPlaceholders.data(), fPlaceholders.size());
}
SkSpan<TextLine> lines() { return SkSpan<TextLine>(fLines.data(), fLines.size()); }
const ParagraphStyle& paragraphStyle() const { return fParagraphStyle; }
SkSpan<Cluster> clusters() { return SkSpan<Cluster>(fClusters.begin(), fClusters.size()); }
sk_sp<FontCollection> fontCollection() const { return fFontCollection; }
void formatLines(SkScalar maxWidth);
void ensureUTF16Mapping();
TextIndex findNextGraphemeBoundary(TextIndex utf8);
TextIndex findPreviousGraphemeBoundary(TextIndex utf8);
TextIndex findNextGlyphClusterBoundary(TextIndex utf8);
TextIndex findPreviousGlyphClusterBoundary(TextIndex utf8);
size_t getUTF16Index(TextIndex index) {
return fUTF16IndexForUTF8Index[index];
}
bool strutEnabled() const { return paragraphStyle().getStrutStyle().getStrutEnabled(); }
bool strutForceHeight() const {
return paragraphStyle().getStrutStyle().getForceStrutHeight();
}
bool strutHeightOverride() const {
return paragraphStyle().getStrutStyle().getHeightOverride();
}
InternalLineMetrics strutMetrics() const { return fStrutMetrics; }
SkString getEllipsis() const;
SkSpan<const char> text(TextRange textRange);
SkSpan<Cluster> clusters(ClusterRange clusterRange);
Cluster& cluster(ClusterIndex clusterIndex);
ClusterIndex clusterIndex(TextIndex textIndex) {
auto clusterIndex = this->fClustersIndexFromCodeUnit[textIndex];
SkASSERT(clusterIndex != EMPTY_INDEX);
return clusterIndex;
}
Run& run(RunIndex runIndex) {
SkASSERT(runIndex < SkToSizeT(fRuns.size()));
return fRuns[runIndex];
}
Run& runByCluster(ClusterIndex clusterIndex);
SkSpan<Block> blocks(BlockRange blockRange);
Block& block(BlockIndex blockIndex);
SkTArray<ResolvedFontDescriptor> resolvedFonts() const { return fFontSwitches; }
void markDirty() override {
if (fState > kIndexed) {
fState = kIndexed;
}
}
int32_t unresolvedGlyphs() override;
void setState(InternalState state);
sk_sp<SkPicture> getPicture() { return fPicture; }
SkScalar widthWithTrailingSpaces() { return fMaxWidthWithTrailingSpaces; }
void resetContext();
void resolveStrut();
bool computeCodeUnitProperties();
void applySpacingAndBuildClusterTable();
void buildClusterTable();
bool shapeTextIntoEndlessLine();
void breakShapedTextIntoLines(SkScalar maxWidth);
void updateTextAlign(TextAlign textAlign) override;
void updateFontSize(size_t from, size_t to, SkScalar fontSize) override;
void updateForegroundPaint(size_t from, size_t to, SkPaint paint) override;
void updateBackgroundPaint(size_t from, size_t to, SkPaint paint) override;
void visit(const Visitor&) override;
InternalLineMetrics getEmptyMetrics() const { return fEmptyMetrics; }
InternalLineMetrics getStrutMetrics() const { return fStrutMetrics; }
BlockRange findAllBlocks(TextRange textRange);
void resetShifts() {
for (auto& run : fRuns) {
run.resetJustificationShifts();
}
}
bool codeUnitHasProperty(size_t index, SkUnicode::CodeUnitFlags property) const {
return (fCodeUnitProperties[index] & property) == property;
}
SkUnicode* getUnicode() { return fUnicode.get(); }
private:
friend class ParagraphBuilder;
friend class ParagraphCacheKey;
friend class ParagraphCacheValue;
friend class ParagraphCache;
friend class TextWrapper;
friend class OneLineShaper;
void computeEmptyMetrics();
// Input
SkTArray<StyleBlock<SkScalar>> fLetterSpaceStyles;
SkTArray<StyleBlock<SkScalar>> fWordSpaceStyles;
SkTArray<StyleBlock<SkPaint>> fBackgroundStyles;
SkTArray<StyleBlock<SkPaint>> fForegroundStyles;
SkTArray<StyleBlock<std::vector<TextShadow>>> fShadowStyles;
SkTArray<StyleBlock<Decoration>> fDecorationStyles;
SkTArray<Block, true> fTextStyles; // TODO: take out only the font stuff
SkTArray<Placeholder, true> fPlaceholders;
SkString fText;
// Internal structures
InternalState fState;
SkTArray<Run, false> fRuns; // kShaped
SkTArray<Cluster, true> fClusters; // kClusterized (cached: text, word spacing, letter spacing, resolved fonts)
SkTArray<SkUnicode::CodeUnitFlags, true> fCodeUnitProperties;
SkTArray<size_t, true> fClustersIndexFromCodeUnit;
std::vector<size_t> fWords;
std::vector<SkUnicode::BidiRegion> fBidiRegions;
// These two arrays are used in measuring methods (getRectsForRange, getGlyphPositionAtCoordinate)
// They are filled lazily whenever they need and cached
SkTArray<TextIndex, true> fUTF8IndexForUTF16Index;
SkTArray<size_t, true> fUTF16IndexForUTF8Index;
SkOnce fillUTF16MappingOnce;
size_t fUnresolvedGlyphs;
SkTArray<TextLine, false> fLines; // kFormatted (cached: width, max lines, ellipsis, text align)
sk_sp<SkPicture> fPicture; // kRecorded (cached: text styles)
SkTArray<ResolvedFontDescriptor> fFontSwitches;
InternalLineMetrics fEmptyMetrics;
InternalLineMetrics fStrutMetrics;
SkScalar fOldWidth;
SkScalar fOldHeight;
SkScalar fMaxWidthWithTrailingSpaces;
std::shared_ptr<SkUnicode> fUnicode;
bool fHasLineBreaks;
bool fHasWhitespacesInside;
TextIndex fTrailingSpaces;
};
} // namespace textlayout
} // namespace skia
#endif // ParagraphImpl_DEFINED