1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrTextUtils_DEFINED
#define GrTextUtils_DEFINED
#include "GrColor.h"
#include "GrColorSpaceInfo.h"
#include "SkColorFilter.h"
#include "SkPaint.h"
#include "SkScalar.h"
#include "SkTextToPathIter.h"
#include "SkTLazy.h"
class GrAtlasGlyphCache;
class GrAtlasTextBlob;
class GrAtlasTextOp;
class GrAtlasTextStrike;
class GrClip;
class GrColorSpaceXform;
class GrContext;
class GrPaint;
class GrShaderCaps;
class SkColorSpace;
class SkDrawFilter;
class SkGlyph;
class SkMatrix;
struct SkIRect;
struct SkPoint;
class SkGlyphCache;
class SkTextBlobRunIterator;
class SkSurfaceProps;
/**
* A class to house a bunch of common text utilities. This class should *ONLY* have static
* functions. It is not a namespace only because we wish to friend SkPaint
*/
class GrTextUtils {
public:
class Target {
public:
virtual ~Target() = default;
int width() const { return fWidth; }
int height() const { return fHeight; }
const GrColorSpaceInfo& colorSpaceInfo() const { return fColorSpaceInfo; }
virtual void addDrawOp(const GrClip&, std::unique_ptr<GrAtlasTextOp> op) = 0;
virtual void drawPath(const GrClip&, const SkPath&, const SkPaint&,
const SkMatrix& viewMatrix, const SkMatrix* pathMatrix,
const SkIRect& clipBounds) = 0;
virtual void makeGrPaint(GrMaskFormat, const SkPaint&, const SkMatrix& viewMatrix,
GrPaint*) = 0;
protected:
Target(int width, int height, const GrColorSpaceInfo& colorSpaceInfo)
: fWidth(width), fHeight(height), fColorSpaceInfo(colorSpaceInfo) {}
private:
int fWidth;
int fHeight;
const GrColorSpaceInfo& fColorSpaceInfo;
};
/**
* This is used to wrap a SkPaint and its post-color filter color. It is also used by RunPaint
* (below). This keeps a pointer to the SkPaint it is initialized with and expects it to remain
* const. It is also used to transform to GrPaint.
*/
class Paint {
public:
explicit Paint(const SkPaint* paint, const GrColorSpaceInfo* dstColorSpaceInfo)
: fPaint(paint), fDstColorSpaceInfo(dstColorSpaceInfo) {
this->initFilteredColor();
}
// These expose the paint's color run through its color filter (if any). This is only valid
// when drawing grayscale/lcd glyph masks and not when drawing color glyphs.
GrColor filteredPremulColor() const { return fFilteredPremulColor; }
SkColor luminanceColor() const { return fPaint->computeLuminanceColor(); }
const SkPaint& skPaint() const { return *fPaint; }
operator const SkPaint&() const { return this->skPaint(); }
// Just for RunPaint's constructor
const GrColorSpaceInfo* dstColorSpaceInfo() const { return fDstColorSpaceInfo; }
protected:
void initFilteredColor();
Paint() = default;
const SkPaint* fPaint;
const GrColorSpaceInfo* fDstColorSpaceInfo;
// This is the paint's color run through its color filter, if present. This color should
// be used except when rendering bitmap text, in which case the bitmap must be filtered in
// the fragment shader.
GrColor fFilteredPremulColor;
};
/**
* An extension of Paint that incorporated per-run modifications to the paint text settings and
* application of a draw filter. It expects its constructor arguments to remain alive and const
* during its lifetime.
*/
class RunPaint : public Paint {
public:
RunPaint(const Paint* paint, SkDrawFilter* filter, const SkSurfaceProps& props)
: fOriginalPaint(paint), fFilter(filter), fProps(props) {
// Initially we represent the original paint.
fPaint = &fOriginalPaint->skPaint();
fDstColorSpaceInfo = fOriginalPaint->dstColorSpaceInfo();
fFilteredPremulColor = fOriginalPaint->filteredPremulColor();
}
bool modifyForRun(std::function<void(SkPaint*)> paintModFunc);
private:
SkTLazy<SkPaint> fModifiedPaint;
const Paint* fOriginalPaint;
SkDrawFilter* fFilter;
const SkSurfaceProps& fProps;
};
static uint32_t FilterTextFlags(const SkSurfaceProps& surfaceProps, const SkPaint& paint);
static bool ShouldDisableLCD(const SkPaint& paint);
class PathTextIter : SkTextBaseIter {
public:
PathTextIter(const char text[], size_t length, const SkPaint& paint,
bool applyStrokeAndPathEffects)
: SkTextBaseIter(text, length, paint, applyStrokeAndPathEffects) {
}
const SkPaint& getPaint() const { return fPaint; }
SkScalar getPathScale() const { return fScale; }
const char* getText() const { return fText; }
/**
* Returns false when all of the text has been consumed
* Will set skGlyph if the maskformat is ARGB, and path otherwise. The other will be null.
* If the glyph is zero-width, both will be null.
*/
bool next(const SkGlyph** skGlyph, const SkPath** path, SkScalar* xpos);
};
};
#endif
|
