• 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     BackgroundColor = 6,
43     Url = 7,
44     HalfLeading,
45     Gesture = 100,
46     ParagraphStyle = 200,
47     Image = 300,
48     CustomSpan = 400,
49     ExtSpan = 500
50 };
51 
52 struct SpanParagraphStyle {
53     std::optional<TextAlign> align;
54     std::optional<TextVerticalAlign> textVerticalAlign;
55     std::optional<int32_t> maxLines;
56     std::optional<WordBreak> wordBreak;
57     std::optional<TextOverflow> textOverflow;
58     std::optional<NG::LeadingMargin> leadingMargin;
59     std::optional<Dimension> textIndent;
60     std::optional<Dimension> paragraphSpacing;
61 
EqualSpanParagraphStyle62     bool Equal(const SpanParagraphStyle& other) const
63     {
64         auto flag = align == other.align && textVerticalAlign == other.textVerticalAlign &&
65                     maxLines == other.maxLines && wordBreak == other.wordBreak &&
66                     textOverflow == other.textOverflow && textIndent == other.textIndent &&
67                     paragraphSpacing == other.paragraphSpacing;
68         if (leadingMargin.has_value() && other.leadingMargin.has_value()) {
69             flag &= leadingMargin.value().CheckLeadingMargin(other.leadingMargin.value());
70         } else if (!leadingMargin.has_value() && !other.textOverflow.has_value()) {
71             flag &= true;
72         } else {
73             flag &= false;
74         }
75         return flag;
76     }
77 };
78 
79 enum class SpanOperation {
80     ADD = 0,
81     REMOVE,
82 };
83 
84 class SpanWatcher : public virtual AceType {
85     DECLARE_ACE_TYPE(SpanWatcher, AceType);
86 
87 public:
88     virtual void UpdateSpanItems(const std::list<RefPtr<NG::SpanItem>>& spanItems) = 0;
89 };
90 
91 struct GestureStyle {
92     std::optional<GestureEventFunc> onClick;
93     std::optional<GestureEventFunc> onLongPress;
94     std::optional<std::function<void(TouchEventInfo&)>> onTouch;
95 
IsEqualGestureStyle96     bool IsEqual(const GestureStyle& other) const
97     {
98         return false;
99     }
100 };
101 
102 class SpanBase : public virtual AceType {
103     DECLARE_ACE_TYPE(SpanBase, AceType);
104 
105 public:
106     SpanBase() = default;
SpanBase(int32_t start,int32_t end)107     SpanBase(int32_t start, int32_t end) : start_(start), end_(end) {}
108     virtual bool IsAttributesEqual(const RefPtr<SpanBase>& other) const = 0;
109     virtual RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) = 0;
110     virtual SpanType GetSpanType() const = 0;
111     virtual void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const = 0;
112     virtual std::string ToString() const = 0;
113 
114     int32_t GetStartIndex() const;
115     int32_t GetEndIndex() const;
116     void UpdateStartIndex(int32_t startIndex);
117     void UpdateEndIndex(int32_t endIndex);
118     int32_t GetLength() const;
119     std::optional<std::pair<int32_t, int32_t>> GetIntersectionInterval(std::pair<int32_t, int32_t> interval) const;
120 
121 private:
122     int32_t start_ = 0;
123     int32_t end_ = 0; // The interval rules are closed on the left and open on the right
124 };
125 
126 class FontSpan : public SpanBase {
127     DECLARE_ACE_TYPE(FontSpan, SpanBase);
128 
129 public:
130     FontSpan() = default;
131     explicit FontSpan(Font font);
132     FontSpan(Font font, int32_t start, int32_t end);
133     Font GetFont() const;
134     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
135     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
136     SpanType GetSpanType() const override;
137     std::string ToString() const override;
138     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
139     static RefPtr<SpanBase> CreateDefaultSpan();
140 
141 private:
142     void AddSpanStyle(const RefPtr<NG::SpanItem>& spanItem) const;
143     static void RemoveSpanStyle(const RefPtr<NG::SpanItem>& spanItem);
144 
145     Font font_;
146 };
147 
148 class DecorationSpan : public SpanBase {
149     DECLARE_ACE_TYPE(DecorationSpan, SpanBase);
150 
151 public:
152     DecorationSpan() = default;
153     // remove when richEditor ready
154     explicit DecorationSpan(const std::vector<TextDecoration>& types, std::optional<Color> color,
155         std::optional<TextDecorationStyle> style, std::optional<TextDecorationOptions> options);
156     DecorationSpan(const std::vector<TextDecoration>& types, std::optional<Color> color,
157         std::optional<TextDecorationStyle> style, std::optional<TextDecorationOptions> options,
158         int32_t start, int32_t end);
159     explicit DecorationSpan(const std::vector<TextDecoration>& types, std::optional<Color> color,
160         std::optional<TextDecorationStyle> style, std::optional<float> lineThicknessScale,
161         std::optional<TextDecorationOptions> options);
162     DecorationSpan(const std::vector<TextDecoration>& types, std::optional<Color> color,
163         std::optional<TextDecorationStyle> style, std::optional<float> lineThicknessScale,
164         std::optional<TextDecorationOptions> options, int32_t start, int32_t end);
165     TextDecoration GetTextDecorationFirst() const;
166     std::vector<TextDecoration> GetTextDecorationTypes() const;
167     void SetTextDecorationTypes(const std::vector<TextDecoration>& types);
168     void RemoveTextDecorationType(TextDecoration value);
169     void AddTextDecorationType(TextDecoration value);
170     std::optional<Color> GetColor() const;
171     std::optional<TextDecorationStyle> GetTextDecorationStyle() const;
172     std::optional<float> GetTextDecorationLineThicknessScale() const;
173     std::optional<TextDecorationOptions> GetTextDecorationOptions() const;
174     void SetTextDecorationOptions(const TextDecorationOptions& options);
175     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
176     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
177     SpanType GetSpanType() const override;
178     std::string DecorationTypesToString() const;
179     std::string ToString() const override;
180     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
181     std::optional<float> GetLineThicknessScale() const;
182 
183 private:
184     void AddDecorationStyle(const RefPtr<NG::SpanItem>& spanItem) const;
185     static void RemoveDecorationStyle(const RefPtr<NG::SpanItem>& spanItem);
186 
187     std::vector<TextDecoration> types_;
188     std::optional<Color> color_;
189     std::optional<TextDecorationStyle> style_;
190     std::optional<float> lineThicknessScale_;
191     std::optional<TextDecorationOptions> options_;
192 };
193 
194 class BaselineOffsetSpan : public SpanBase {
195     DECLARE_ACE_TYPE(BaselineOffsetSpan, SpanBase);
196 
197 public:
198     BaselineOffsetSpan() = default;
199     explicit BaselineOffsetSpan(Dimension baselineOffset);
200     BaselineOffsetSpan(Dimension baselineOffset, int32_t start, int32_t end);
201     Dimension GetBaselineOffset() const;
202     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
203     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
204     SpanType GetSpanType() const override;
205     std::string ToString() const override;
206     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
207 
208 private:
209     void AddBaselineOffsetStyle(const RefPtr<NG::SpanItem>& spanItem) const;
210     static void RemoveBaselineOffsetStyle(const RefPtr<NG::SpanItem>& spanItem);
211     Dimension baselineOffset_;
212 };
213 
214 class LetterSpacingSpan : public SpanBase {
215     DECLARE_ACE_TYPE(LetterSpacingSpan, SpanBase);
216 
217 public:
218     LetterSpacingSpan() = default;
219     explicit LetterSpacingSpan(Dimension letterSpacing);
220     LetterSpacingSpan(Dimension letterSpacing, int32_t start, int32_t end);
221     Dimension GetLetterSpacing() const;
222     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
223     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
224     SpanType GetSpanType() const override;
225     std::string ToString() const override;
226     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
227 
228 private:
229     void AddLetterSpacingStyle(const RefPtr<NG::SpanItem>& spanItem) const;
230     static void RemoveLetterSpacingStyle(const RefPtr<NG::SpanItem>& spanItem);
231 
232     Dimension letterSpacing_;
233 };
234 
235 class GestureSpan : public SpanBase {
236     DECLARE_ACE_TYPE(GestureSpan, SpanBase);
237 
238 public:
239     GestureSpan() = default;
240     explicit GestureSpan(GestureStyle gestureInfo);
241     ~GestureSpan() override = default;
242     GestureSpan(GestureStyle gestureInfo, int32_t start, int32_t end);
243     GestureStyle GetGestureStyle() const;
244     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
245     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
246     SpanType GetSpanType() const override;
247     std::string ToString() const override;
248     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
249 
GetGestureSpanId()250     int32_t GetGestureSpanId()
251     {
252         return gestureSpanId_;
253     }
254 
SetGestureSpanId(int32_t gestureSpanId)255     void SetGestureSpanId(int32_t gestureSpanId)
256     {
257         gestureSpanId_ = gestureSpanId;
258     }
259 
260 private:
261     void AddSpanStyle(const RefPtr<NG::SpanItem>& spanItem) const;
262     static void RemoveSpanStyle(const RefPtr<NG::SpanItem>& spanItem);
263 
264     GestureStyle gestureInfo_;
265     int32_t gestureSpanId_ = -1;
266 };
267 
268 class TextShadowSpan : public SpanBase {
269     DECLARE_ACE_TYPE(TextShadowSpan, SpanBase);
270 
271 public:
272     TextShadowSpan() = default;
273     explicit TextShadowSpan(std::vector<Shadow> font);
274     TextShadowSpan(std::vector<Shadow> font, int32_t start, int32_t end);
275     std::vector<Shadow> GetTextShadow() const;
276     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
277     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
278     SpanType GetSpanType() const override;
279     std::string ToString() const override;
280     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
281 
282 private:
283     void AddSpanStyle(const RefPtr<NG::SpanItem>& spanItem) const;
284     static void RemoveSpanStyle(const RefPtr<NG::SpanItem>& spanItem);
285 
286     std::optional<std::vector<Shadow>> textShadow_ = std::nullopt;
287 };
288 class BackgroundColorSpan : public SpanBase {
289     DECLARE_ACE_TYPE(BackgroundColorSpan, SpanBase);
290 
291 public:
292     BackgroundColorSpan() = default;
293     explicit BackgroundColorSpan(std::optional<TextBackgroundStyle> textBackgroundStyle_);
294     BackgroundColorSpan(std::optional<TextBackgroundStyle> textBackgroundStyle_, int32_t start, int32_t end);
295     TextBackgroundStyle GetBackgroundColor() const;
296     void SetBackgroundColorGroupId(int32_t groupId);
297     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
298     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
299     SpanType GetSpanType() const override;
300     std::string ToString() const override;
301     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
302 
303 private:
304     std::optional<TextBackgroundStyle> textBackgroundStyle_;
305     void AddSpanStyle(const RefPtr<NG::SpanItem>& spanItem) const;
306     static void RemoveSpanStyle(const RefPtr<NG::SpanItem>& spanItem);
307 };
308 
309 class ImageSpan : public SpanBase {
310     DECLARE_ACE_TYPE(ImageSpan, SpanBase);
311 
312 public:
313     explicit ImageSpan(const ImageSpanOptions& options);
314     ImageSpan(const ImageSpanOptions& options, int32_t position);
315     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
316     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
317     SpanType GetSpanType() const override;
318     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
319     std::string ToString() const override;
320 
321     const ImageSpanOptions& GetImageSpanOptions();
322     const std::optional<ImageSpanAttribute>& GetImageAttribute() const;
323 
324 private:
325     ImageSpanOptions imageOptions_;
326 };
327 
328 class CustomSpan : public SpanBase {
329     DECLARE_ACE_TYPE(CustomSpan, SpanBase);
330 
331 public:
332     CustomSpan();
333     explicit CustomSpan(std::optional<std::function<CustomSpanMetrics(CustomSpanMeasureInfo)>> onMeasure,
334         std::optional<std::function<void(NG::DrawingContext&, CustomSpanOptions)>> onDraw);
335 
336     explicit CustomSpan(std::optional<std::function<CustomSpanMetrics(CustomSpanMeasureInfo)>> onMeasure,
337         std::optional<std::function<void(NG::DrawingContext&, CustomSpanOptions)>> onDraw, int32_t start, int32_t end);
338     virtual ~CustomSpan() override = default;
339     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
340     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
341     SpanType GetSpanType() const override;
342     void SetOnMeasure(std::function<CustomSpanMetrics(CustomSpanMeasureInfo)> onMeasure);
343     void SetOnDraw(std::function<void(NG::DrawingContext&, CustomSpanOptions)> onDraw);
344     std::optional<std::function<CustomSpanMetrics(CustomSpanMeasureInfo)>> GetOnMeasure();
345     std::optional<std::function<void(NG::DrawingContext&, CustomSpanOptions)>> GetOnDraw();
346     std::string ToString() const override;
347     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
AddStyledString(const WeakPtr<SpanStringBase> & spanString)348     virtual void AddStyledString(const WeakPtr<SpanStringBase>& spanString) {}
RemoveStyledString(const WeakPtr<SpanStringBase> & spanString)349     virtual void RemoveStyledString(const WeakPtr<SpanStringBase>& spanString) {}
350 
351 private:
352     std::optional<std::function<CustomSpanMetrics(CustomSpanMeasureInfo)>> onMeasure_;
353     std::optional<std::function<void(NG::DrawingContext&, CustomSpanOptions)>> onDraw_;
354 };
355 
356 class ParagraphStyleSpan : public SpanBase {
357     DECLARE_ACE_TYPE(ParagraphStyleSpan, SpanBase);
358 
359 public:
360     ParagraphStyleSpan() = default;
361     explicit ParagraphStyleSpan(SpanParagraphStyle paragraphStyle);
362     ParagraphStyleSpan(SpanParagraphStyle paragraphStyle, int32_t start, int32_t end);
363     SpanParagraphStyle GetParagraphStyle() const;
364     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
365     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
366     SpanType GetSpanType() const override;
367     std::string ToString() const override;
368     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
369 
370 private:
371     void AddParagraphStyle(const RefPtr<NG::SpanItem>& spanItem) const;
372     void RemoveParagraphStyle(const RefPtr<NG::SpanItem>& spanItem) const;
373 
374     SpanParagraphStyle paragraphStyle_;
375 };
376 
377 class LineHeightSpan : public SpanBase {
378     DECLARE_ACE_TYPE(LineHeightSpan, SpanBase);
379 
380 public:
381     LineHeightSpan() = default;
382     explicit LineHeightSpan(Dimension lineHeight);
383     LineHeightSpan(Dimension lineHeight, int32_t start, int32_t end);
384     Dimension GetLineHeight() const;
385     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
386     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
387     SpanType GetSpanType() const override;
388     std::string ToString() const override;
389     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
390 
391 private:
392     void AddLineHeightStyle(const RefPtr<NG::SpanItem>& spanItem) const;
393     void RemoveLineHeightStyle(const RefPtr<NG::SpanItem>& spanItem) const;
394 
395     Dimension lineHeight_;
396 };
397 
398 class HalfLeadingSpan : public SpanBase {
399     DECLARE_ACE_TYPE(HalfLeadingSpan, SpanBase);
400 
401 public:
402     HalfLeadingSpan() = default;
403     explicit HalfLeadingSpan(bool halfLeading);
404     HalfLeadingSpan(bool halfLeading, int32_t start, int32_t end);
405     bool GetHalfLeading() const;
406     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
407     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
408     SpanType GetSpanType() const override;
409     std::string ToString() const override;
410     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
411 
412 private:
413     void AddHalfLeadingStyle(const RefPtr<NG::SpanItem>& spanItem) const;
414     void RemoveHalfLeadingStyle(const RefPtr<NG::SpanItem>& spanItem) const;
415 
416     bool halfLeading_;
417 };
418 
419 class ExtSpan : public SpanBase {
420     DECLARE_ACE_TYPE(ExtSpan, SpanBase);
421 
422 public:
423     ExtSpan() = default;
424     ExtSpan(int32_t start, int32_t end);
425     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
426     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
427     SpanType GetSpanType() const override;
428     std::string ToString() const override;
ApplyToSpanItem(const RefPtr<NG::SpanItem> & spanItem,SpanOperation operation)429     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override {}
430 };
431 
432 class UrlSpan : public SpanBase {
433     DECLARE_ACE_TYPE(UrlSpan, SpanBase);
434 
435 public:
436     UrlSpan() = default;
437     explicit UrlSpan(const std::string& urlAddress);
438     UrlSpan(const std::string& urlAddress, int32_t start, int32_t end);
439     std::string GetUrlSpanAddress() const;
440     RefPtr<SpanBase> GetSubSpan(int32_t start, int32_t end) override;
441     bool IsAttributesEqual(const RefPtr<SpanBase>& other) const override;
442     SpanType GetSpanType() const override;
443     std::string ToString() const override;
444     void ApplyToSpanItem(const RefPtr<NG::SpanItem>& spanItem, SpanOperation operation) const override;
445 private:
446     void AddUrlStyle(const RefPtr<NG::SpanItem>& spanItem) const;
447     static void RemoveUrlStyle(const RefPtr<NG::SpanItem>& spanItem);
448     std::string urlAddress_;
449 };
450 } // namespace OHOS::Ace
451 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_TEXT_SPAN_SPAN_OBJECT_H