1 /*
2 * Copyright (c) 2022 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 #include "core/components_ng/pattern/text/span_model_ng.h"
17
18 #include "core/text/text_emoji_processor.h"
19 #include "base/geometry/dimension.h"
20 #include "core/components/common/layout/constants.h"
21 #include "core/components/common/properties/alignment.h"
22 #include "core/components/common/properties/text_style.h"
23 #include "core/components_ng/base/frame_node.h"
24 #include "core/components_ng/base/view_stack_processor.h"
25 #include "core/components_ng/pattern/text/span_node.h"
26 #include "core/components_ng/pattern/text/text_pattern.h"
27 #include "core/components_v2/inspector/inspector_constants.h"
28
29 #define ACE_UPDATE_SPAN_PROPERTY(name, value, flag) \
30 do { \
31 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode()); \
32 CHECK_NULL_VOID(spanNode); \
33 spanNode->Update##name(value); \
34 spanNode->AddPropertyInfo(flag); \
35 } while (false)
36 #define ACE_UPDATE_NODE_SPAN_PROPERTY(name, value, flag, frameNode) \
37 do { \
38 auto spanNode = AceType::DynamicCast<SpanNode>(frameNode); \
39 CHECK_NULL_VOID(spanNode); \
40 spanNode->Update##name(value); \
41 spanNode->AddPropertyInfo(flag); \
42 } while (false)
43 #define ACE_RESET_NODE_SPAN_PROPERTY(name, flag, frameNode) \
44 do { \
45 auto spanNode = AceType::DynamicCast<SpanNode>(frameNode); \
46 CHECK_NULL_VOID(spanNode); \
47 if (spanNode->Has##name()) { \
48 spanNode->MarkTextDirty(); \
49 } \
50 spanNode->Reset##name(); \
51 spanNode->ResetPropertyInfo(flag); \
52 } while (false)
53 namespace OHOS::Ace::NG {
54
Create(const std::string & content)55 void SpanModelNG::Create(const std::string& content)
56 {
57 auto* stack = ViewStackProcessor::GetInstance();
58 auto nodeId = stack->ClaimNodeId();
59 auto spanNode = SpanNode::GetOrCreateSpanNode(nodeId);
60 stack->Push(spanNode);
61
62 if (StringUtils::ToWstring(content).length() == 0 && content.length() != 0) {
63 ACE_UPDATE_SPAN_PROPERTY(Content, TextEmojiProcessor::ConvertU8stringUnpairedSurrogates(content),
64 PropertyInfo::NONE);
65 } else {
66 ACE_UPDATE_SPAN_PROPERTY(Content, content, PropertyInfo::NONE);
67 }
68 }
69
CreateSpanNode(int32_t nodeId,const std::string & content)70 RefPtr<SpanNode> SpanModelNG::CreateSpanNode(int32_t nodeId, const std::string& content)
71 {
72 auto spanNode = SpanNode::CreateSpanNode(nodeId);
73 CHECK_NULL_RETURN(spanNode, nullptr);
74 spanNode->UpdateContent(content);
75 spanNode->AddPropertyInfo(PropertyInfo::NONE);
76 return spanNode;
77 }
78
SetFont(const Font & value)79 void SpanModelNG::SetFont(const Font& value)
80 {
81 if (value.fontSize.has_value()) {
82 SetFontSize(value.fontSize.value());
83 }
84 if (value.fontWeight.has_value()) {
85 SetFontWeight(value.fontWeight.value());
86 }
87 if (!value.fontFamilies.empty()) {
88 SetFontFamily(value.fontFamilies);
89 }
90 if (value.fontStyle.has_value()) {
91 SetItalicFontStyle(value.fontStyle.value());
92 }
93 }
94
SetFontSize(const Dimension & value)95 void SpanModelNG::SetFontSize(const Dimension& value)
96 {
97 ACE_UPDATE_SPAN_PROPERTY(FontSize, value, PropertyInfo::FONTSIZE);
98 }
99
SetTextColor(const Color & value)100 void SpanModelNG::SetTextColor(const Color& value)
101 {
102 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
103 CHECK_NULL_VOID(spanNode);
104 spanNode->UpdateSpanTextColor(value);
105 spanNode->AddPropertyInfo(PropertyInfo::FONTCOLOR);
106 }
107
SetItalicFontStyle(Ace::FontStyle value)108 void SpanModelNG::SetItalicFontStyle(Ace::FontStyle value)
109 {
110 ACE_UPDATE_SPAN_PROPERTY(ItalicFontStyle, value, PropertyInfo::FONTSTYLE);
111 }
112
SetFontWeight(Ace::FontWeight value)113 void SpanModelNG::SetFontWeight(Ace::FontWeight value)
114 {
115 ACE_UPDATE_SPAN_PROPERTY(FontWeight, value, PropertyInfo::FONTWEIGHT);
116 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
117 CHECK_NULL_VOID(spanNode);
118 spanNode->UpdateUserFontWeight(true);
119 }
120
SetFontFamily(const std::vector<std::string> & value)121 void SpanModelNG::SetFontFamily(const std::vector<std::string>& value)
122 {
123 ACE_UPDATE_SPAN_PROPERTY(FontFamily, value, PropertyInfo::FONTFAMILY);
124 }
125
SetTextDecoration(Ace::TextDecoration value)126 void SpanModelNG::SetTextDecoration(Ace::TextDecoration value)
127 {
128 ACE_UPDATE_SPAN_PROPERTY(TextDecoration, value, PropertyInfo::TEXTDECORATION);
129 }
130
SetTextDecorationStyle(Ace::TextDecorationStyle value)131 void SpanModelNG::SetTextDecorationStyle(Ace::TextDecorationStyle value)
132 {
133 ACE_UPDATE_SPAN_PROPERTY(TextDecorationStyle, value, PropertyInfo::NONE);
134 }
135
SetTextDecorationColor(const Color & value)136 void SpanModelNG::SetTextDecorationColor(const Color& value)
137 {
138 ACE_UPDATE_SPAN_PROPERTY(TextDecorationColor, value, PropertyInfo::NONE);
139 }
140
SetTextCase(Ace::TextCase value)141 void SpanModelNG::SetTextCase(Ace::TextCase value)
142 {
143 ACE_UPDATE_SPAN_PROPERTY(TextCase, value, PropertyInfo::TEXTCASE);
144 }
145
SetTextShadow(const std::vector<Shadow> & value)146 void SpanModelNG::SetTextShadow(const std::vector<Shadow>& value)
147 {
148 ACE_UPDATE_SPAN_PROPERTY(TextShadow, value, PropertyInfo::TEXTSHADOW);
149 }
150
SetTextShadow(UINode * uiNode,const std::vector<Shadow> & value)151 void SpanModelNG::SetTextShadow(UINode* uiNode, const std::vector<Shadow>& value)
152 {
153 ACE_UPDATE_NODE_SPAN_PROPERTY(TextShadow, value, PropertyInfo::TEXTSHADOW, uiNode);
154 }
155
ResetTextShadow(UINode * uiNode)156 void SpanModelNG::ResetTextShadow(UINode *uiNode)
157 {
158 ACE_RESET_NODE_SPAN_PROPERTY(TextShadow, PropertyInfo::TEXTSHADOW, uiNode);
159 }
160
SetLetterSpacing(const Dimension & value)161 void SpanModelNG::SetLetterSpacing(const Dimension& value)
162 {
163 ACE_UPDATE_SPAN_PROPERTY(LetterSpacing, value, PropertyInfo::LETTERSPACE);
164 }
165
SetBaselineOffset(const Dimension & value)166 void SpanModelNG::SetBaselineOffset(const Dimension& value)
167 {
168 ACE_UPDATE_SPAN_PROPERTY(BaselineOffset, value, PropertyInfo::BASELINE_OFFSET);
169 }
170
SetLineHeight(const Dimension & value)171 void SpanModelNG::SetLineHeight(const Dimension& value)
172 {
173 ACE_UPDATE_SPAN_PROPERTY(LineHeight, value, PropertyInfo::LINEHEIGHT);
174 }
175
SetOnClick(std::function<void (BaseEventInfo * info)> && click)176 void SpanModelNG::SetOnClick(std::function<void(BaseEventInfo* info)>&& click)
177 {
178 auto clickFunc = [func = std::move(click)](GestureEvent& info) { func(&info); };
179 ACE_UPDATE_SPAN_PROPERTY(OnClickEvent, std::move(clickFunc), PropertyInfo::NONE);
180 }
181
SetOnClick(UINode * uiNode,GestureEventFunc && click)182 void SpanModelNG::SetOnClick(UINode* uiNode, GestureEventFunc&& click)
183 {
184 ACE_UPDATE_NODE_SPAN_PROPERTY(OnClickEvent, std::move(click), PropertyInfo::NONE, uiNode);
185 }
186
ClearOnClick()187 void SpanModelNG::ClearOnClick()
188 {
189 ACE_UPDATE_SPAN_PROPERTY(OnClickEvent, nullptr, PropertyInfo::NONE);
190 }
191
ClearOnClick(UINode * uiNode)192 void SpanModelNG::ClearOnClick(UINode* uiNode)
193 {
194 ACE_UPDATE_NODE_SPAN_PROPERTY(OnClickEvent, nullptr, PropertyInfo::NONE, uiNode);
195 }
196
SetAccessibilityText(const std::string & text)197 void SpanModelNG::SetAccessibilityText(const std::string& text)
198 {
199 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
200 CHECK_NULL_VOID(spanNode);
201 auto spanItem = spanNode->GetSpanItem();
202 CHECK_NULL_VOID(spanItem);
203 CHECK_NULL_VOID(spanItem->accessibilityProperty);
204 spanItem->accessibilityProperty->SetAccessibilityText(text);
205 }
206
SetAccessibilityDescription(const std::string & description)207 void SpanModelNG::SetAccessibilityDescription(const std::string& description)
208 {
209 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
210 CHECK_NULL_VOID(spanNode);
211 auto spanItem = spanNode->GetSpanItem();
212 CHECK_NULL_VOID(spanItem);
213 CHECK_NULL_VOID(spanItem->accessibilityProperty);
214 spanItem->accessibilityProperty->SetAccessibilityDescription(description);
215 }
216
SetAccessibilityImportance(const std::string & importance)217 void SpanModelNG::SetAccessibilityImportance(const std::string& importance)
218 {
219 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
220 CHECK_NULL_VOID(spanNode);
221 auto spanItem = spanNode->GetSpanItem();
222 CHECK_NULL_VOID(spanItem);
223 CHECK_NULL_VOID(spanItem->accessibilityProperty);
224 spanItem->accessibilityProperty->SetAccessibilityLevel(importance);
225 }
226
InitSpan(UINode * uiNode,const std::string & content)227 void SpanModelNG::InitSpan(UINode* uiNode, const std::string& content)
228 {
229 ACE_UPDATE_NODE_SPAN_PROPERTY(Content, content, PropertyInfo::NONE, uiNode);
230 }
231
SetFontWeight(UINode * uiNode,FontWeight value)232 void SpanModelNG::SetFontWeight(UINode* uiNode, FontWeight value)
233 {
234 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
235 CHECK_NULL_VOID(spanNode);
236 spanNode->UpdateFontWeight(value);
237 spanNode->AddPropertyInfo(PropertyInfo::FONTWEIGHT);
238 spanNode->UpdateUserFontWeight(true);
239 }
240
ResetFontWeight(UINode * uiNode)241 void SpanModelNG::ResetFontWeight(UINode *uiNode)
242 {
243 ACE_RESET_NODE_SPAN_PROPERTY(FontWeight, PropertyInfo::FONTWEIGHT, uiNode);
244 }
245
SetTextCase(UINode * uiNode,TextCase value)246 void SpanModelNG::SetTextCase(UINode* uiNode, TextCase value)
247 {
248 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
249 CHECK_NULL_VOID(spanNode);
250 spanNode->UpdateTextCase(value);
251 spanNode->AddPropertyInfo(PropertyInfo::TEXTCASE);
252 }
253
ResetTextCase(UINode * uiNode)254 void SpanModelNG::ResetTextCase(UINode *uiNode)
255 {
256 ACE_RESET_NODE_SPAN_PROPERTY(TextCase, PropertyInfo::TEXTCASE, uiNode);
257 }
258
SetItalicFontStyle(UINode * uiNode,Ace::FontStyle value)259 void SpanModelNG::SetItalicFontStyle(UINode* uiNode, Ace::FontStyle value)
260 {
261 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
262 CHECK_NULL_VOID(spanNode);
263 spanNode->UpdateItalicFontStyle(value);
264 spanNode->AddPropertyInfo(PropertyInfo::FONTSTYLE);
265 }
266
ResetItalicFontStyle(UINode * uiNode)267 void SpanModelNG::ResetItalicFontStyle(UINode *uiNode)
268 {
269 ACE_RESET_NODE_SPAN_PROPERTY(ItalicFontStyle, PropertyInfo::FONTSTYLE, uiNode);
270 }
271
SetLineHeight(UINode * uiNode,const Dimension & value)272 void SpanModelNG::SetLineHeight(UINode* uiNode, const Dimension& value)
273 {
274 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
275 CHECK_NULL_VOID(spanNode);
276 spanNode->UpdateLineHeight(value);
277 spanNode->AddPropertyInfo(PropertyInfo::LINEHEIGHT);
278 }
279
ResetLineHeight(UINode * uiNode)280 void SpanModelNG::ResetLineHeight(UINode* uiNode)
281 {
282 ACE_RESET_NODE_SPAN_PROPERTY(LineHeight, PropertyInfo::LINEHEIGHT, uiNode);
283 }
284
SetFontSize(UINode * uiNode,const Dimension & value)285 void SpanModelNG::SetFontSize(UINode* uiNode, const Dimension& value)
286 {
287 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
288 CHECK_NULL_VOID(spanNode);
289 spanNode->UpdateFontSize(value);
290 spanNode->AddPropertyInfo(PropertyInfo::FONTSIZE);
291 }
292
ResetFontSize(UINode * uiNode)293 void SpanModelNG::ResetFontSize(UINode *uiNode)
294 {
295 ACE_RESET_NODE_SPAN_PROPERTY(FontSize, PropertyInfo::FONTSIZE, uiNode);
296 }
297
SetFontFamily(UINode * uiNode,const std::vector<std::string> & value)298 void SpanModelNG::SetFontFamily(UINode* uiNode, const std::vector<std::string>& value)
299 {
300 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
301 CHECK_NULL_VOID(spanNode);
302 spanNode->UpdateFontFamily(value);
303 spanNode->AddPropertyInfo(PropertyInfo::FONTFAMILY);
304 }
305
ResetFontFamily(UINode * uiNode)306 void SpanModelNG::ResetFontFamily(UINode *uiNode)
307 {
308 ACE_RESET_NODE_SPAN_PROPERTY(FontFamily, PropertyInfo::FONTFAMILY, uiNode);
309 }
310
SetTextDecoration(UINode * uiNode,TextDecoration value)311 void SpanModelNG::SetTextDecoration(UINode* uiNode, TextDecoration value)
312 {
313 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
314 CHECK_NULL_VOID(spanNode);
315 spanNode->UpdateTextDecoration(value);
316 spanNode->AddPropertyInfo(PropertyInfo::TEXTDECORATION);
317 }
318
ResetTextDecoration(UINode * uiNode)319 void SpanModelNG::ResetTextDecoration(UINode *uiNode)
320 {
321 ACE_RESET_NODE_SPAN_PROPERTY(TextDecoration, PropertyInfo::TEXTDECORATION, uiNode);
322 }
323
SetTextDecorationStyle(UINode * uiNode,TextDecorationStyle value)324 void SpanModelNG::SetTextDecorationStyle(UINode* uiNode, TextDecorationStyle value)
325 {
326 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
327 CHECK_NULL_VOID(spanNode);
328 spanNode->UpdateTextDecorationStyle(value);
329 spanNode->AddPropertyInfo(PropertyInfo::NONE);
330 }
331
ResetTextDecorationStyle(UINode * uiNode)332 void SpanModelNG::ResetTextDecorationStyle(UINode *uiNode)
333 {
334 ACE_RESET_NODE_SPAN_PROPERTY(TextDecorationStyle, PropertyInfo::NONE, uiNode);
335 }
336
SetTextDecorationColor(UINode * uiNode,const Color & value)337 void SpanModelNG::SetTextDecorationColor(UINode* uiNode, const Color& value)
338 {
339 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
340 CHECK_NULL_VOID(spanNode);
341 spanNode->UpdateTextDecorationColor(value);
342 spanNode->AddPropertyInfo(PropertyInfo::NONE);
343 }
344
ResetTextDecorationColor(UINode * uiNode)345 void SpanModelNG::ResetTextDecorationColor(UINode *uiNode)
346 {
347 ACE_RESET_NODE_SPAN_PROPERTY(TextDecorationColor, PropertyInfo::NONE, uiNode);
348 }
349
SetTextColor(UINode * uiNode,const Color & value)350 void SpanModelNG::SetTextColor(UINode* uiNode, const Color& value)
351 {
352 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
353 CHECK_NULL_VOID(spanNode);
354 spanNode->UpdateSpanTextColor(value);
355 spanNode->AddPropertyInfo(PropertyInfo::FONTCOLOR);
356 }
357
ResetTextColor(UINode * uiNode)358 void SpanModelNG::ResetTextColor(UINode *uiNode)
359 {
360 ACE_RESET_NODE_SPAN_PROPERTY(TextColor, PropertyInfo::FONTCOLOR, uiNode);
361 }
362
SetLetterSpacing(UINode * uiNode,const Dimension & value)363 void SpanModelNG::SetLetterSpacing(UINode* uiNode, const Dimension& value)
364 {
365 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
366 CHECK_NULL_VOID(spanNode);
367 spanNode->UpdateLetterSpacing(value);
368 spanNode->AddPropertyInfo(PropertyInfo::LETTERSPACE);
369 }
370
ResetLetterSpacing(UINode * uiNode)371 void SpanModelNG::ResetLetterSpacing(UINode *uiNode)
372 {
373 ACE_RESET_NODE_SPAN_PROPERTY(LetterSpacing, PropertyInfo::LETTERSPACE, uiNode);
374 }
375
SetBaselineOffset(UINode * uiNode,const Dimension & value)376 void SpanModelNG::SetBaselineOffset(UINode* uiNode, const Dimension& value)
377 {
378 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
379 CHECK_NULL_VOID(spanNode);
380 spanNode->UpdateBaselineOffset(value);
381 spanNode->AddPropertyInfo(PropertyInfo::BASELINE_OFFSET);
382 }
383
SetFont(UINode * uiNode,const Font & value)384 void SpanModelNG::SetFont(UINode* uiNode, const Font& value)
385 {
386 if (value.fontSize.has_value()) {
387 SetFontSize(uiNode, value.fontSize.value());
388 }
389 if (value.fontWeight.has_value()) {
390 SetFontWeight(uiNode, value.fontWeight.value());
391 }
392 if (!value.fontFamilies.empty()) {
393 SetFontFamily(uiNode, value.fontFamilies);
394 }
395 if (value.fontStyle.has_value()) {
396 SetItalicFontStyle(uiNode, value.fontStyle.value());
397 }
398 }
399
ResetFont(UINode * uiNode)400 void SpanModelNG::ResetFont(UINode *uiNode)
401 {
402 ResetFontSize(uiNode);
403 ResetFontWeight(uiNode);
404 ResetFontFamily(uiNode);
405 ResetItalicFontStyle(uiNode);
406 }
407
CreateContainSpan()408 void SpanModelNG::CreateContainSpan()
409 {
410 auto* stack = ViewStackProcessor::GetInstance();
411 auto nodeId = stack->ClaimNodeId();
412 auto spanNode = ContainerSpanNode::GetOrCreateSpanNode(nodeId);
413 stack->Push(spanNode);
414 }
415
SetTextBackgroundStyle(const TextBackgroundStyle & style)416 void SpanModelNG::SetTextBackgroundStyle(const TextBackgroundStyle& style)
417 {
418 auto baseSpan = AceType::DynamicCast<BaseSpan>(ViewStackProcessor::GetInstance()->GetMainElementNode());
419 CHECK_NULL_VOID(baseSpan);
420 baseSpan->SetTextBackgroundStyle(style);
421 }
422
SetTextBackgroundStyle(UINode * uiNode,const TextBackgroundStyle & style)423 void SpanModelNG::SetTextBackgroundStyle(UINode* uiNode, const TextBackgroundStyle& style)
424 {
425 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
426 CHECK_NULL_VOID(spanNode);
427 spanNode->SetTextBackgroundStyle(style);
428 }
429
SetTextBackgroundStyleByBaseSpan(UINode * uiNode,const TextBackgroundStyle & style)430 void SpanModelNG::SetTextBackgroundStyleByBaseSpan(UINode* uiNode, const TextBackgroundStyle& style)
431 {
432 auto spanNode = AceType::DynamicCast<BaseSpan>(uiNode);
433 CHECK_NULL_VOID(spanNode);
434 spanNode->SetTextBackgroundStyle(style);
435 }
436
GetContent(UINode * uiNode)437 std::string SpanModelNG::GetContent(UINode* uiNode)
438 {
439 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
440 CHECK_NULL_RETURN(spanNode, "");
441 auto spanItem = spanNode->GetSpanItem();
442 CHECK_NULL_RETURN(spanItem, "");
443 return spanItem->GetSpanContent();
444 }
445
GetTextDecoration(UINode * uiNode)446 Ace::TextDecoration SpanModelNG::GetTextDecoration(UINode* uiNode)
447 {
448 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
449 CHECK_NULL_RETURN(spanNode, TextDecoration::NONE);
450 return spanNode->GetTextDecoration().value_or(TextDecoration::NONE);
451 }
452
GetTextDecorationColor(UINode * uiNode)453 Color SpanModelNG::GetTextDecorationColor(UINode* uiNode)
454 {
455 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
456 CHECK_NULL_RETURN(spanNode, Color::BLACK);
457 return spanNode->GetTextDecorationColor().value_or(Color::BLACK);
458 }
459
GetTextDecorationStyle(UINode * uiNode)460 Ace::TextDecorationStyle SpanModelNG::GetTextDecorationStyle(UINode* uiNode)
461 {
462 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
463 CHECK_NULL_RETURN(spanNode, TextDecorationStyle::SOLID);
464 return spanNode->GetTextDecorationStyle().value_or(TextDecorationStyle::SOLID);
465 }
466
GetDefaultTextStyle()467 TextStyle SpanModelNG::GetDefaultTextStyle()
468 {
469 TextStyle textStyle;
470 auto pipelineContext = PipelineBase::GetCurrentContextSafely();
471 CHECK_NULL_RETURN(pipelineContext, textStyle);
472 auto textTheme = pipelineContext->GetTheme<TextTheme>();
473 CHECK_NULL_RETURN(textTheme, textStyle);
474 return textTheme->GetTextStyle();
475 }
476
GetFontColor(UINode * uiNode)477 Color SpanModelNG::GetFontColor(UINode* uiNode)
478 {
479 auto defaultColor = GetDefaultTextStyle().GetTextColor();
480 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
481 CHECK_NULL_RETURN(spanNode, defaultColor);
482 return spanNode->GetTextColor().value_or(defaultColor);
483 }
484
GetFontSize(UINode * uiNode)485 Dimension SpanModelNG::GetFontSize(UINode* uiNode)
486 {
487 const Dimension& defaultFontSize = GetDefaultTextStyle().GetFontSize();
488 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
489 CHECK_NULL_RETURN(spanNode, defaultFontSize);
490 return spanNode->GetFontSize().value_or(defaultFontSize);
491 }
492
GetFontStyle(UINode * uiNode)493 Ace::FontStyle SpanModelNG::GetFontStyle(UINode* uiNode)
494 {
495 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
496 CHECK_NULL_RETURN(spanNode, Ace::FontStyle::NORMAL);
497 return spanNode->GetItalicFontStyle().value_or(Ace::FontStyle::NORMAL);
498 }
499
GetFontWeight(UINode * uiNode)500 FontWeight SpanModelNG::GetFontWeight(UINode* uiNode)
501 {
502 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
503 CHECK_NULL_RETURN(spanNode, FontWeight::NORMAL);
504 return spanNode->GetFontWeight().value_or(FontWeight::NORMAL);
505 }
506
GetTextLineHeight(UINode * uiNode)507 Dimension SpanModelNG::GetTextLineHeight(UINode* uiNode)
508 {
509 Dimension defaultLineHeight(0);
510 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
511 CHECK_NULL_RETURN(spanNode, Dimension(0));
512 return spanNode->GetLineHeight().value_or(defaultLineHeight);
513 }
514
GetTextCase(UINode * uiNode)515 Ace::TextCase SpanModelNG::GetTextCase(UINode* uiNode)
516 {
517 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
518 CHECK_NULL_RETURN(spanNode, TextCase::NORMAL);
519 return spanNode->GetTextCase().value_or(TextCase::NORMAL);
520 }
521
GetLetterSpacing(UINode * uiNode)522 Dimension SpanModelNG::GetLetterSpacing(UINode* uiNode)
523 {
524 Dimension defaultLetterSpacing(0);
525 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
526 CHECK_NULL_RETURN(spanNode, defaultLetterSpacing);
527 return spanNode->GetLetterSpacing().value_or(defaultLetterSpacing);
528 }
529
GetBaselineOffset(UINode * uiNode)530 Dimension SpanModelNG::GetBaselineOffset(UINode* uiNode)
531 {
532 Dimension defaultBaselineOffset(0);
533 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
534 CHECK_NULL_RETURN(spanNode, defaultBaselineOffset);
535 return spanNode->GetBaselineOffset().value_or(defaultBaselineOffset);
536 }
537
GetSpanTextBackgroundStyle(UINode * uiNode)538 TextBackgroundStyle SpanModelNG::GetSpanTextBackgroundStyle(UINode* uiNode)
539 {
540 TextBackgroundStyle backgroundStyle;
541 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
542 CHECK_NULL_RETURN(spanNode, backgroundStyle);
543 return spanNode->GetTextBackgroundStyle().value_or(backgroundStyle);
544 }
545
GetTextShadow(UINode * uiNode)546 std::vector<Shadow> SpanModelNG::GetTextShadow(UINode* uiNode)
547 {
548 std::vector<Shadow> defaultShadow;
549 CHECK_NULL_RETURN(uiNode, defaultShadow);
550 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
551 CHECK_NULL_RETURN(spanNode, defaultShadow);
552 return spanNode->GetTextShadow().value_or(defaultShadow);
553 }
554
SetAccessibilityText(UINode * uiNode,const std::string & text)555 void SpanModelNG::SetAccessibilityText(UINode* uiNode, const std::string& text)
556 {
557 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
558 CHECK_NULL_VOID(spanNode);
559 auto spanItem = spanNode->GetSpanItem();
560 CHECK_NULL_VOID(spanItem);
561 CHECK_NULL_VOID(spanItem->accessibilityProperty);
562 spanItem->accessibilityProperty->SetAccessibilityText(text);
563 }
564
SetAccessibilityDescription(UINode * uiNode,const std::string & description)565 void SpanModelNG::SetAccessibilityDescription(UINode* uiNode, const std::string& description)
566 {
567 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
568 CHECK_NULL_VOID(spanNode);
569 auto spanItem = spanNode->GetSpanItem();
570 CHECK_NULL_VOID(spanItem);
571 CHECK_NULL_VOID(spanItem->accessibilityProperty);
572 spanItem->accessibilityProperty->SetAccessibilityDescription(description);
573 }
574
SetAccessibilityImportance(UINode * uiNode,const std::string & importance)575 void SpanModelNG::SetAccessibilityImportance(UINode* uiNode, const std::string& importance)
576 {
577 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
578 CHECK_NULL_VOID(spanNode);
579 auto spanItem = spanNode->GetSpanItem();
580 CHECK_NULL_VOID(spanItem);
581 CHECK_NULL_VOID(spanItem->accessibilityProperty);
582 spanItem->accessibilityProperty->SetAccessibilityLevel(importance);
583 }
584
GetSpanFontFamily(UINode * uiNode)585 std::vector<std::string> SpanModelNG::GetSpanFontFamily(UINode* uiNode)
586 {
587 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
588 std::vector<std::string> value;
589 CHECK_NULL_RETURN(spanNode, value);
590 return spanNode->GetFontFamily().value_or(value);
591 }
592 } // namespace OHOS::Ace::NG
593