• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_TEXT_SPAN_SPAN_OBJECT_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_TEXT_SPAN_SPAN_OBJECT_H
18 
19 #include <string>
20 #include <utility>
21 #include <vector>
22 
23 #include "base/memory/ace_type.h"
24 #include "base/memory/referenced.h"
25 #include "core/components/common/layout/constants.h"
26 #include "core/components_ng/pattern/text/span/tlv_util.h"
27 #include "core/components_ng/pattern/text/span_node.h"
28 #include "core/components_ng/pattern/text/text_model.h"
29 #include "core/components_ng/pattern/text/text_styles.h"
30 #include "core/components_ng/pattern/text_field/text_field_model.h"
31 #include "core/components_ng/render/paragraph.h"
32 
33 namespace OHOS::Ace {
34 
35 enum class SpanType {
36     Font = 0,
37     Decoration,
38     BaselineOffset,
39     LetterSpacing,
40     TextShadow = 4,
41     LineHeight = 5,
42     Gesture = 100,
43     ParagraphStyle = 200,
44     Image = 300,
45     CustomSpan = 400,
46     ExtSpan = 500
47 };
48 
49 struct SpanParagraphStyle {
50     std::optional<TextAlign> align;
51     std::optional<int32_t> maxLines;
52     std::optional<WordBreak> wordBreak;
53     std::optional<TextOverflow> textOverflow;
54     std::optional<NG::LeadingMargin> leadingMargin;
55     std::optional<Dimension> textIndent;
56 
EqualSpanParagraphStyle57     bool Equal(const SpanParagraphStyle& other) const
58     {
59         auto flag = align == other.align && maxLines == other.maxLines && wordBreak == other.wordBreak &&
60                     textOverflow == other.textOverflow && textIndent == other.textIndent;
61         if (leadingMargin.has_value() && other.leadingMargin.has_value()) {
62             flag &= leadingMargin.value().CheckLeadingMargin(other.leadingMargin.value());
63         } else if (!leadingMargin.has_value() && !other.textOverflow.has_value()) {
64             flag &= true;
65         } else {
66             flag &= false;
67         }
68         return flag;
69     }
70 };
71 
72 enum class SpanOperation {
73     ADD = 0,
74     REMOVE,
75 };
76 
77 class SpanWatcher : public virtual AceType {
78     DECLARE_ACE_TYPE(SpanWatcher, AceType);
79 
80 public:
81     virtual void UpdateSpanItems(const std::list<RefPtr<NG::SpanItem>>& spanItems) = 0;
82 };
83 
84 struct GestureStyle {
85     std::optional<GestureEventFunc> onClick;
86     std::optional<GestureEventFunc> onLongPress;
87 
IsEqualGestureStyle88     bool IsEqual(const GestureStyle& other) const
89     {
90         return false;
91     }
92 };
93 
94 class SpanBase : public virtual AceType {
95     DECLARE_ACE_TYPE(SpanBase, AceType);
96 
97 public:
98     SpanBase() = default;
SpanBase(int32_t start,int32_t end)99     SpanBase(int32_t start, int32_t end) : start_(start), end_(end) {}
100     virtual bool IsAttributesEqual(const RefPtr<SpanBase>& other) const = 0;
101     virtual RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) = 0;
102     virtual SpanType GetSpanType() const = 0;
103     virtual void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const = 0;
104     virtual std::string ToString() const = 0;
105 
106     int32_t GetStartIndex() const;
107     int32_t GetEndIndex() const;
108     void UpdateStartIndex(int32_t startIndex);
109     void UpdateEndIndex(int32_t endIndex);
110     int32_t GetLength() const;
111     std::optional<std::pair<int32_t, int32_t>> GetIntersectionInterval(std::pair<int32_t, int32_t> interval) const;
112 
113 private:
114     int32_t start_ = 0;
115     int32_t end_ = 0; // The interval rules are closed on the left and open on the right
116 };
117 
118 class FontSpan : public SpanBase {
119     DECLARE_ACE_TYPE(FontSpan, SpanBase);
120 
121 public:
122     FontSpan() = default;
123     explicit FontSpan(Font font);
124     FontSpan(Font font, int32_t start, int32_t end);
125     Font GetFont() const;
126     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
127     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
128     SpanType GetSpanType() const override;
129     std::string ToString() const override;
130     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
131     static RefPtr<SpanBase> CreateDefaultSpan();
132 
133 private:
134     void AddSpanStyle(const RefPtr<NG::SpanItem>& spanItem) const;
135     static void RemoveSpanStyle(const RefPtr<NG::SpanItem>& spanItem);
136 
137     Font font_;
138 };
139 
140 class DecorationSpan : public SpanBase {
141     DECLARE_ACE_TYPE(DecorationSpan, SpanBase);
142 
143 public:
144     DecorationSpan() = default;
145     explicit DecorationSpan(TextDecoration type, std::optional<Color> color, std::optional<TextDecorationStyle> style);
146     DecorationSpan(TextDecoration type, std::optional<Color> color, std::optional<TextDecorationStyle> style,
147         int32_t start, int32_t end);
148     TextDecoration GetTextDecorationType() const;
149     std::optional<Color> GetColor() const;
150     std::optional<TextDecorationStyle> GetTextDecorationStyle() const;
151     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
152     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
153     SpanType GetSpanType() const override;
154     std::string ToString() const override;
155     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
156 
157 private:
158     void AddDecorationStyle(const RefPtr<NG::SpanItem>& spanItem) const;
159     static void RemoveDecorationStyle(const RefPtr<NG::SpanItem>& spanItem);
160 
161     TextDecoration type_;
162     std::optional<Color> color_;
163     std::optional<TextDecorationStyle> style_;
164 };
165 
166 class BaselineOffsetSpan : public SpanBase {
167     DECLARE_ACE_TYPE(BaselineOffsetSpan, SpanBase);
168 
169 public:
170     BaselineOffsetSpan() = default;
171     explicit BaselineOffsetSpan(Dimension baselineOffset);
172     BaselineOffsetSpan(Dimension baselineOffset, int32_t start, int32_t end);
173     Dimension GetBaselineOffset() const;
174     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
175     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
176     SpanType GetSpanType() const override;
177     std::string ToString() const override;
178     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
179 
180 private:
181     void AddBaselineOffsetStyle(const RefPtr<NG::SpanItem>& spanItem) const;
182     static void RemoveBaselineOffsetStyle(const RefPtr<NG::SpanItem>& spanItem);
183     Dimension baselineOffset_;
184 };
185 
186 class LetterSpacingSpan : public SpanBase {
187     DECLARE_ACE_TYPE(LetterSpacingSpan, SpanBase);
188 
189 public:
190     LetterSpacingSpan() = default;
191     explicit LetterSpacingSpan(Dimension letterSpacing);
192     LetterSpacingSpan(Dimension letterSpacing, int32_t start, int32_t end);
193     Dimension GetLetterSpacing() const;
194     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
195     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
196     SpanType GetSpanType() const override;
197     std::string ToString() const override;
198     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
199 
200 private:
201     void AddLetterSpacingStyle(const RefPtr<NG::SpanItem>& spanItem) const;
202     static void RemoveLetterSpacingStyle(const RefPtr<NG::SpanItem>& spanItem);
203 
204     Dimension letterSpacing_;
205 };
206 
207 class GestureSpan : public SpanBase {
208     DECLARE_ACE_TYPE(GestureSpan, SpanBase);
209 
210 public:
211     GestureSpan() = default;
212     explicit GestureSpan(GestureStyle gestureInfo);
213     ~GestureSpan() override = default;
214     GestureSpan(GestureStyle gestureInfo, int32_t start, int32_t end);
215     GestureStyle GetGestureStyle() const;
216     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
217     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
218     SpanType GetSpanType() const override;
219     std::string ToString() const override;
220     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
221 
222 private:
223     void AddSpanStyle(const RefPtr<NG::SpanItem>& spanItem) const;
224     static void RemoveSpanStyle(const RefPtr<NG::SpanItem>& spanItem);
225 
226     GestureStyle gestureInfo_;
227 };
228 
229 class TextShadowSpan : public SpanBase {
230     DECLARE_ACE_TYPE(TextShadowSpan, SpanBase);
231 
232 public:
233     TextShadowSpan() = default;
234     explicit TextShadowSpan(std::vector<Shadow> font);
235     TextShadowSpan(std::vector<Shadow> font, int32_t start, int32_t end);
236     std::vector<Shadow> GetTextShadow() const;
237     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
238     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
239     SpanType GetSpanType() const override;
240     std::string ToString() const override;
241     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
242 
243 private:
244     void AddSpanStyle(const RefPtr<NG::SpanItem>& spanItem) const;
245     static void RemoveSpanStyle(const RefPtr<NG::SpanItem>& spanItem);
246 
247     std::optional<std::vector<Shadow>> textShadow_ = std::nullopt;
248 };
249 
250 class ImageSpan : public SpanBase {
251     DECLARE_ACE_TYPE(ImageSpan, SpanBase);
252 
253 public:
254     explicit ImageSpan(const ImageSpanOptions& options);
255     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
256     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
257     SpanType GetSpanType() const override;
258     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
259     std::string ToString() const override;
260 
261     const ImageSpanOptions& GetImageSpanOptions();
262     const std::optional<ImageSpanAttribute>& GetImageAttribute() const;
263 
264 private:
265     ImageSpanOptions imageOptions_;
266 };
267 
268 class CustomSpan : public SpanBase {
269     DECLARE_ACE_TYPE(CustomSpan, SpanBase);
270 
271 public:
272     CustomSpan();
273     explicit CustomSpan(std::optional<std::function<CustomSpanMetrics(CustomSpanMeasureInfo)>> onMeasure,
274         std::optional<std::function<void(NG::DrawingContext&, CustomSpanOptions)>> onDraw);
275 
276     explicit CustomSpan(std::optional<std::function<CustomSpanMetrics(CustomSpanMeasureInfo)>> onMeasure,
277         std::optional<std::function<void(NG::DrawingContext&, CustomSpanOptions)>> onDraw, int32_t start, int32_t end);
278     virtual ~CustomSpan() override = default;
279     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
280     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
281     SpanType GetSpanType() const override;
282     void SetOnMeasure(std::function<CustomSpanMetrics(CustomSpanMeasureInfo)> onMeasure);
283     void SetOnDraw(std::function<void(NG::DrawingContext&, CustomSpanOptions)> onDraw);
284     std::optional<std::function<CustomSpanMetrics(CustomSpanMeasureInfo)>> GetOnMeasure();
285     std::optional<std::function<void(NG::DrawingContext&, CustomSpanOptions)>> GetOnDraw();
286     std::string ToString() const override;
287     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
AddStyledString(const WeakPtr<SpanStringBase> & spanString)288     virtual void AddStyledString(const WeakPtr<SpanStringBase>& spanString) {}
RemoveStyledString(const WeakPtr<SpanStringBase> & spanString)289     virtual void RemoveStyledString(const WeakPtr<SpanStringBase>& spanString) {}
290 
291 private:
292     std::optional<std::function<CustomSpanMetrics(CustomSpanMeasureInfo)>> onMeasure_;
293     std::optional<std::function<void(NG::DrawingContext&, CustomSpanOptions)>> onDraw_;
294 };
295 
296 class ParagraphStyleSpan : public SpanBase {
297     DECLARE_ACE_TYPE(ParagraphStyleSpan, SpanBase);
298 
299 public:
300     ParagraphStyleSpan() = default;
301     explicit ParagraphStyleSpan(SpanParagraphStyle paragraphStyle);
302     ParagraphStyleSpan(SpanParagraphStyle paragraphStyle, int32_t start, int32_t end);
303     SpanParagraphStyle GetParagraphStyle() const;
304     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
305     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
306     SpanType GetSpanType() const override;
307     std::string ToString() const override;
308     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
309 
310 private:
311     void AddParagraphStyle(const RefPtr<NG::SpanItem>& spanItem) const;
312     void RemoveParagraphStyle(const RefPtr<NG::SpanItem>& spanItem) const;
313 
314     SpanParagraphStyle paragraphStyle_;
315 };
316 
317 class LineHeightSpan : public SpanBase {
318     DECLARE_ACE_TYPE(LineHeightSpan, SpanBase);
319 
320 public:
321     LineHeightSpan() = default;
322     explicit LineHeightSpan(Dimension lineHeight);
323     LineHeightSpan(Dimension lineHeight, int32_t start, int32_t end);
324     Dimension GetLineHeight() const;
325     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
326     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
327     SpanType GetSpanType() const override;
328     std::string ToString() const override;
329     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
330 
331 private:
332     void AddLineHeightStyle(const RefPtr<NG::SpanItem>& spanItem) const;
333     void RemoveLineHeightStyle(const RefPtr<NG::SpanItem>& spanItem) const;
334 
335     Dimension lineHeight_;
336 };
337 
338 class ExtSpan : public SpanBase {
339     DECLARE_ACE_TYPE(ExtSpan, SpanBase);
340 
341 public:
342     ExtSpan() = default;
343     ExtSpan(int32_t start, int32_t end);
344     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
345     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
346     SpanType GetSpanType() const override;
347     std::string ToString() const override;
ApplyToSpanItem(const RefPtr<NG::SpanItem> & spanItem,SpanOperation operation)348     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override {}
349 };
350 } // namespace OHOS::Ace
351 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_TEXT_SPAN_SPAN_OBJECT_H