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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
/*
* Copyright (C) 2012 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_SHAPING_SHAPE_RESULT_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_SHAPING_SHAPE_RESULT_H_
#include <memory>
#include "third_party/blink/renderer/platform/fonts/canvas_rotation_in_vertical.h"
#include "third_party/blink/renderer/platform/geometry/float_rect.h"
#include "third_party/blink/renderer/platform/layout_unit.h"
#include "third_party/blink/renderer/platform/platform_export.h"
#include "third_party/blink/renderer/platform/text/text_direction.h"
#include "third_party/blink/renderer/platform/wtf/forward.h"
#include "third_party/blink/renderer/platform/wtf/hash_set.h"
#include "third_party/blink/renderer/platform/wtf/noncopyable.h"
#include "third_party/blink/renderer/platform/wtf/ref_counted.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"
struct hb_buffer_t;
namespace blink {
struct CharacterRange;
class Font;
template <typename TextContainerType>
class PLATFORM_EXPORT ShapeResultSpacing;
class SimpleFontData;
class TextRun;
enum class AdjustMidCluster {
// Adjust the middle of a grapheme cluster to the logical end boundary.
kToEnd,
// Adjust the middle of a grapheme cluster to the logical start boundary.
kToStart
};
class PLATFORM_EXPORT ShapeResult : public RefCounted<ShapeResult> {
public:
static scoped_refptr<ShapeResult> Create(const Font* font,
unsigned num_characters,
TextDirection direction) {
return base::AdoptRef(new ShapeResult(font, num_characters, direction));
}
static scoped_refptr<ShapeResult> CreateForTabulationCharacters(
const Font*,
const TextRun&,
float position_offset,
unsigned count);
~ShapeResult();
// Returns a mutable unique instance. If |this| has more than 1 ref count,
// a clone is created.
scoped_refptr<ShapeResult> MutableUnique() const;
// The logical width of this result.
float Width() const { return width_; }
LayoutUnit SnappedWidth() const { return LayoutUnit::FromFloatCeil(width_); }
// The glyph bounding box, in logical coordinates, using alphabetic baseline
// even when the result is in vertical flow.
const FloatRect& Bounds() const { return glyph_bounding_box_; }
unsigned NumCharacters() const { return num_characters_; }
CharacterRange GetCharacterRange(unsigned from, unsigned to) const;
// The character start/end index of a range shape result.
unsigned StartIndexForResult() const;
unsigned EndIndexForResult() const;
void FallbackFonts(HashSet<const SimpleFontData*>*) const;
TextDirection Direction() const {
return static_cast<TextDirection>(direction_);
}
bool Rtl() const { return Direction() == TextDirection::kRtl; }
// True if at least one glyph in this result has vertical offsets.
//
// Vertical result always has vertical offsets, but horizontal result may also
// have vertical offsets.
bool HasVerticalOffsets() const { return has_vertical_offsets_; }
// For memory reporting.
size_t ByteSize() const;
// Returns the next or previous offsets respectively at which it is safe to
// break without reshaping.
// The |offset| given and the return value is for the original string, between
// |StartIndexForResult| and |EndIndexForResult|.
unsigned NextSafeToBreakOffset(unsigned offset) const;
unsigned PreviousSafeToBreakOffset(unsigned offset) const;
unsigned OffsetForPosition(float target_x, bool include_partial_glyphs) const;
float PositionForOffset(unsigned offset,
AdjustMidCluster = AdjustMidCluster::kToEnd) const;
LayoutUnit SnappedStartPositionForOffset(unsigned offset) const {
return LayoutUnit::FromFloatFloor(PositionForOffset(offset));
}
LayoutUnit SnappedEndPositionForOffset(unsigned offset) const {
return LayoutUnit::FromFloatCeil(PositionForOffset(offset));
}
// Apply spacings (letter-spacing, word-spacing, and justification) as
// configured to |ShapeResultSpacing|.
// |text_start_offset| adjusts the character index in the ShapeResult before
// giving it to |ShapeResultSpacing|. It can be negative if
// |StartIndexForResult()| is larger than the text in |ShapeResultSpacing|.
void ApplySpacing(ShapeResultSpacing<String>&, int text_start_offset = 0);
scoped_refptr<ShapeResult> ApplySpacingToCopy(ShapeResultSpacing<TextRun>&,
const TextRun&) const;
void CopyRange(unsigned start, unsigned end, ShapeResult*) const;
scoped_refptr<ShapeResult> SubRange(unsigned start_offset,
unsigned end_offset) const;
// Computes the list of fonts along with the number of glyphs for each font.
struct RunFontData {
SimpleFontData* font_data_;
size_t glyph_count_;
};
void GetRunFontData(Vector<RunFontData>* font_data) const;
String ToString() const;
void ToString(StringBuilder*) const;
struct RunInfo;
RunInfo* InsertRunForTesting(unsigned start_index,
unsigned num_characters,
TextDirection,
Vector<uint16_t> safe_break_offsets = {});
#if DCHECK_IS_ON()
void CheckConsistency() const;
#endif
protected:
ShapeResult(const SimpleFontData*, unsigned num_characters, TextDirection);
ShapeResult(const Font*, unsigned num_characters, TextDirection);
ShapeResult(const ShapeResult&);
static scoped_refptr<ShapeResult> Create(const SimpleFontData* font_data,
unsigned num_characters,
TextDirection direction) {
return base::AdoptRef(
new ShapeResult(font_data, num_characters, direction));
}
static scoped_refptr<ShapeResult> Create(const ShapeResult& other) {
return base::AdoptRef(new ShapeResult(other));
}
template <typename TextContainerType>
void ApplySpacingImpl(ShapeResultSpacing<TextContainerType>&,
int text_start_offset = 0);
template <bool is_horizontal_run>
void ComputeGlyphPositions(ShapeResult::RunInfo*,
unsigned start_glyph,
unsigned num_glyphs,
hb_buffer_t*,
FloatRect* glyph_bounding_box);
void InsertRun(std::unique_ptr<ShapeResult::RunInfo>,
unsigned start_glyph,
unsigned num_glyphs,
hb_buffer_t*);
void InsertRun(std::unique_ptr<ShapeResult::RunInfo>);
void InsertRunForIndex(unsigned start_character_index);
void ReorderRtlRuns(unsigned run_size_before);
float width_;
FloatRect glyph_bounding_box_;
Vector<std::unique_ptr<RunInfo>> runs_;
scoped_refptr<const SimpleFontData> primary_font_;
unsigned num_characters_;
unsigned num_glyphs_ : 30;
// Overall direction for the TextRun, dictates which order each individual
// sub run (represented by RunInfo structs in the m_runs vector) can have a
// different text direction.
unsigned direction_ : 1;
// Tracks whether any runs contain glyphs with a y-offset != 0.
unsigned has_vertical_offsets_ : 1;
friend class HarfBuzzShaper;
friend class ShapeResultBuffer;
friend class ShapeResultBloberizer;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_SHAPING_SHAPE_RESULT_H_
|
