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 #include "core/text/text_emoji_processor.h"
18
19 #define ACE_UPDATE_SPAN_PROPERTY(name, value) \
20 do { \
21 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode()); \
22 CHECK_NULL_VOID(spanNode); \
23 spanNode->Update##name(value); \
24 } while (false)
25 #define ACE_RESET_SPAN_PROPERTY(name) \
26 do { \
27 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode()); \
28 CHECK_NULL_VOID(spanNode); \
29 if (spanNode->Has##name()) { \
30 spanNode->MarkTextDirty(); \
31 } \
32 spanNode->Reset##name(); \
33 } while (false)
34 #define ACE_UPDATE_NODE_SPAN_PROPERTY(name, value, frameNode) \
35 do { \
36 auto spanNode = AceType::DynamicCast<SpanNode>(frameNode); \
37 CHECK_NULL_VOID(spanNode); \
38 spanNode->Update##name(value); \
39 } while (false)
40 #define ACE_RESET_NODE_SPAN_PROPERTY(name, frameNode) \
41 do { \
42 auto spanNode = AceType::DynamicCast<SpanNode>(frameNode); \
43 CHECK_NULL_VOID(spanNode); \
44 if (spanNode->Has##name()) { \
45 spanNode->MarkTextDirty(); \
46 } \
47 spanNode->Reset##name(); \
48 } while (false)
49 namespace OHOS::Ace::NG {
50
Create(const std::u16string & content)51 void SpanModelNG::Create(const std::u16string& content)
52 {
53 RefPtr<ResourceObject> resObj;
54 Create(content, resObj);
55 }
56
Create(const std::u16string & content,RefPtr<ResourceObject> & resObj)57 void SpanModelNG::Create(const std::u16string& content, RefPtr<ResourceObject>& resObj)
58 {
59 auto* stack = ViewStackProcessor::GetInstance();
60 auto nodeId = stack->ClaimNodeId();
61 auto spanNode = SpanNode::GetOrCreateSpanNode(nodeId);
62 stack->Push(spanNode);
63 auto contentModified = content;
64 UtfUtils::HandleInvalidUTF16(reinterpret_cast<uint16_t*>(contentModified.data()), contentModified.length(), 0);
65 ACE_UPDATE_SPAN_PROPERTY(Content, contentModified);
66 if (resObj) {
67 auto&& updateFunc = [weakptr = WeakPtr<NG::SpanNode>(spanNode)](const RefPtr<ResourceObject>& resObj) {
68 auto spanNode = weakptr.Upgrade();
69 CHECK_NULL_VOID(spanNode);
70 spanNode->UpdateSpanResource<std::u16string>("value", resObj);
71 };
72 spanNode->AddResObj("value", resObj, std::move(updateFunc));
73 }
74 }
75
CreateSpanNode(int32_t nodeId,const std::u16string & content)76 RefPtr<SpanNode> SpanModelNG::CreateSpanNode(int32_t nodeId, const std::u16string& content)
77 {
78 auto spanNode = SpanNode::CreateSpanNode(nodeId);
79 CHECK_NULL_RETURN(spanNode, nullptr);
80 spanNode->UpdateContent(content);
81 return spanNode;
82 }
83
SetFont(const Font & value)84 void SpanModelNG::SetFont(const Font& value)
85 {
86 if (value.fontSize.has_value()) {
87 SetFontSize(value.fontSize.value());
88 } else {
89 ResetFontSize();
90 }
91 if (value.fontWeight.has_value()) {
92 SetFontWeight(value.fontWeight.value());
93 } else {
94 ResetFontWeight();
95 }
96 if (!value.fontFamilies.empty()) {
97 SetFontFamily(value.fontFamilies);
98 } else {
99 ResetFontFamily();
100 }
101 if (value.fontStyle.has_value()) {
102 SetItalicFontStyle(value.fontStyle.value());
103 } else {
104 ResetItalicFontStyle();
105 }
106 }
107
ResetFont()108 void SpanModelNG::ResetFont()
109 {
110 ResetFontSize();
111 ResetFontWeight();
112 ResetFontFamily();
113 ResetItalicFontStyle();
114 }
115
SetFontSize(const Dimension & value)116 void SpanModelNG::SetFontSize(const Dimension& value)
117 {
118 ACE_UPDATE_SPAN_PROPERTY(FontSize, value);
119 }
120
ResetFontSize()121 void SpanModelNG::ResetFontSize()
122 {
123 ACE_RESET_SPAN_PROPERTY(FontSize);
124 }
125
SetTextColor(const Color & value)126 void SpanModelNG::SetTextColor(const Color& value)
127 {
128 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
129 CHECK_NULL_VOID(spanNode);
130 spanNode->UpdateSpanTextColor(value);
131 }
132
ResetTextColor()133 void SpanModelNG::ResetTextColor()
134 {
135 ACE_RESET_SPAN_PROPERTY(TextColor);
136 }
137
SetItalicFontStyle(Ace::FontStyle value)138 void SpanModelNG::SetItalicFontStyle(Ace::FontStyle value)
139 {
140 ACE_UPDATE_SPAN_PROPERTY(ItalicFontStyle, value);
141 }
142
ResetItalicFontStyle()143 void SpanModelNG::ResetItalicFontStyle()
144 {
145 ACE_RESET_SPAN_PROPERTY(ItalicFontStyle);
146 }
147
SetFontWeight(Ace::FontWeight value)148 void SpanModelNG::SetFontWeight(Ace::FontWeight value)
149 {
150 ACE_UPDATE_SPAN_PROPERTY(FontWeight, value);
151 }
152
ResetFontWeight()153 void SpanModelNG::ResetFontWeight()
154 {
155 ACE_RESET_SPAN_PROPERTY(FontWeight);
156 }
157
SetFontFamily(const std::vector<std::string> & value)158 void SpanModelNG::SetFontFamily(const std::vector<std::string>& value)
159 {
160 ACE_UPDATE_SPAN_PROPERTY(FontFamily, value);
161 }
162
ResetFontFamily()163 void SpanModelNG::ResetFontFamily()
164 {
165 ACE_RESET_SPAN_PROPERTY(FontFamily);
166 }
167
SetTextDecoration(Ace::TextDecoration value)168 void SpanModelNG::SetTextDecoration(Ace::TextDecoration value)
169 {
170 ACE_UPDATE_SPAN_PROPERTY(TextDecoration, {value});
171 }
172
SetTextDecorationStyle(Ace::TextDecorationStyle value)173 void SpanModelNG::SetTextDecorationStyle(Ace::TextDecorationStyle value)
174 {
175 ACE_UPDATE_SPAN_PROPERTY(TextDecorationStyle, value);
176 }
177
SetTextDecorationColor(const Color & value)178 void SpanModelNG::SetTextDecorationColor(const Color& value)
179 {
180 ACE_UPDATE_SPAN_PROPERTY(TextDecorationColor, value);
181 }
182
SetLineThicknessScale(float value)183 void SpanModelNG::SetLineThicknessScale(float value)
184 {
185 ACE_UPDATE_SPAN_PROPERTY(LineThicknessScale, value);
186 }
187
SetTextCase(Ace::TextCase value)188 void SpanModelNG::SetTextCase(Ace::TextCase value)
189 {
190 ACE_UPDATE_SPAN_PROPERTY(TextCase, value);
191 }
192
SetTextShadow(const std::vector<Shadow> & value)193 void SpanModelNG::SetTextShadow(const std::vector<Shadow>& value)
194 {
195 ACE_UPDATE_SPAN_PROPERTY(TextShadow, value);
196 CHECK_NULL_VOID(SystemProperties::ConfigChangePerform());
197 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
198 CHECK_NULL_VOID(spanNode);
199 auto index = 0;
200 for (auto& shadow : value) {
201 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
202 auto key = "shadow_" + std::to_string(index);
203 auto&& updateFunc = [shadow, weak = WeakPtr<SpanNode>(spanNode), index](const RefPtr<ResourceObject>& resObj) {
204 auto spanNode = weak.Upgrade();
205 CHECK_NULL_VOID(spanNode);
206 Shadow& shadowValue = const_cast<Shadow&>(shadow);
207 shadowValue.ReloadResources();
208 auto origArr = spanNode->GetTextShadow();
209 if (origArr.has_value() && GreatNotEqual(origArr.value().size(), index)) {
210 auto origArrVal = origArr.value();
211 origArrVal[index] = shadowValue;
212 spanNode->UpdateTextShadow(origArrVal);
213 }
214 };
215 spanNode->AddResObj(key, resObj, std::move(updateFunc));
216 index ++;
217 }
218 }
219
SetTextShadow(UINode * uiNode,const std::vector<Shadow> & value)220 void SpanModelNG::SetTextShadow(UINode* uiNode, const std::vector<Shadow>& value)
221 {
222 ACE_UPDATE_NODE_SPAN_PROPERTY(TextShadow, value, uiNode);
223 CHECK_NULL_VOID(SystemProperties::ConfigChangePerform());
224 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
225 CHECK_NULL_VOID(spanNode);
226 auto index = 0;
227 for (auto& shadow : value) {
228 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
229 auto key = "shadow_" + std::to_string(index);
230 auto&& updateFunc = [shadow, weak = AceType::WeakClaim(spanNode), index]
231 (const RefPtr<ResourceObject>& resObj) {
232 auto spanNode = weak.Upgrade();
233 CHECK_NULL_VOID(spanNode);
234 Shadow& shadowValue = const_cast<Shadow&>(shadow);
235 shadowValue.ReloadResources();
236 auto origArr = spanNode->GetTextShadow();
237 if (origArr.has_value() && GreatNotEqual(origArr.value().size(), index)) {
238 auto origArrVal = origArr.value();
239 origArrVal[index] = shadowValue;
240 spanNode->UpdateTextShadow(origArrVal);
241 }
242 };
243 spanNode->AddResObj(key, resObj, std::move(updateFunc));
244 index ++;
245 }
246 }
247
ResetTextShadow(UINode * uiNode)248 void SpanModelNG::ResetTextShadow(UINode *uiNode)
249 {
250 ACE_RESET_NODE_SPAN_PROPERTY(TextShadow, uiNode);
251 }
252
SetLetterSpacing(const Dimension & value)253 void SpanModelNG::SetLetterSpacing(const Dimension& value)
254 {
255 ACE_UPDATE_SPAN_PROPERTY(LetterSpacing, value);
256 }
257
SetBaselineOffset(const Dimension & value)258 void SpanModelNG::SetBaselineOffset(const Dimension& value)
259 {
260 ACE_UPDATE_SPAN_PROPERTY(BaselineOffset, value);
261 }
262
SetLineHeight(const Dimension & value)263 void SpanModelNG::SetLineHeight(const Dimension& value)
264 {
265 ACE_UPDATE_SPAN_PROPERTY(LineHeight, value);
266 }
267
SetOnClick(std::function<void (BaseEventInfo * info)> && click)268 void SpanModelNG::SetOnClick(std::function<void(BaseEventInfo* info)>&& click)
269 {
270 auto clickFunc = [func = std::move(click)](GestureEvent& info) { func(&info); };
271 ACE_UPDATE_SPAN_PROPERTY(OnClickEvent, std::move(clickFunc));
272 }
273
SetOnClick(UINode * uiNode,GestureEventFunc && click)274 void SpanModelNG::SetOnClick(UINode* uiNode, GestureEventFunc&& click)
275 {
276 ACE_UPDATE_NODE_SPAN_PROPERTY(OnClickEvent, std::move(click), uiNode);
277 }
278
ClearOnClick()279 void SpanModelNG::ClearOnClick()
280 {
281 ACE_UPDATE_SPAN_PROPERTY(OnClickEvent, nullptr);
282 }
283
ClearOnClick(UINode * uiNode)284 void SpanModelNG::ClearOnClick(UINode* uiNode)
285 {
286 ACE_UPDATE_NODE_SPAN_PROPERTY(OnClickEvent, nullptr, uiNode);
287 }
288
SetOnLongPress(UINode * uiNode,GestureEventFunc && onLongPress)289 void SpanModelNG::SetOnLongPress(UINode* uiNode, GestureEventFunc&& onLongPress)
290 {
291 if (uiNode->GetTag() == V2::SPAN_ETS_TAG) {
292 ACE_UPDATE_NODE_SPAN_PROPERTY(OnLongPressEvent, std::move(onLongPress), uiNode);
293 } else {
294 auto frameNode = AceType::DynamicCast<FrameNode>(uiNode);
295 CHECK_NULL_VOID(frameNode);
296 auto eventHub = frameNode->GetEventHub<EventHub>();
297 CHECK_NULL_VOID(eventHub);
298 auto focusHub = eventHub->GetOrCreateFocusHub();
299 CHECK_NULL_VOID(focusHub);
300 focusHub->SetOnLongPressCallback(std::move(onLongPress));
301 }
302 }
303
ClearOnLongPress(UINode * uiNode)304 void SpanModelNG::ClearOnLongPress(UINode* uiNode)
305 {
306 if (uiNode->GetTag() == V2::SPAN_ETS_TAG) {
307 ACE_UPDATE_NODE_SPAN_PROPERTY(OnLongPressEvent, nullptr, uiNode);
308 } else {
309 auto frameNode = AceType::DynamicCast<FrameNode>(uiNode);
310 CHECK_NULL_VOID (frameNode);
311 auto eventHub = frameNode->GetEventHub<EventHub>();
312 CHECK_NULL_VOID(eventHub);
313 auto focusHub = eventHub->GetOrCreateFocusHub();
314 CHECK_NULL_VOID(focusHub);
315 focusHub->SetOnLongPressCallback(std::move(nullptr));
316 }
317 }
318
SetAccessibilityText(const std::string & text)319 void SpanModelNG::SetAccessibilityText(const std::string& text)
320 {
321 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
322 CHECK_NULL_VOID(spanNode);
323 auto spanItem = spanNode->GetSpanItem();
324 CHECK_NULL_VOID(spanItem);
325 CHECK_NULL_VOID(spanItem->accessibilityProperty);
326 spanItem->accessibilityProperty->SetAccessibilityText(text);
327 }
328
SetAccessibilityDescription(const std::string & description)329 void SpanModelNG::SetAccessibilityDescription(const std::string& description)
330 {
331 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
332 CHECK_NULL_VOID(spanNode);
333 auto spanItem = spanNode->GetSpanItem();
334 CHECK_NULL_VOID(spanItem);
335 CHECK_NULL_VOID(spanItem->accessibilityProperty);
336 spanItem->accessibilityProperty->SetAccessibilityDescription(description);
337 }
338
SetAccessibilityImportance(const std::string & importance)339 void SpanModelNG::SetAccessibilityImportance(const std::string& importance)
340 {
341 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
342 CHECK_NULL_VOID(spanNode);
343 auto spanItem = spanNode->GetSpanItem();
344 CHECK_NULL_VOID(spanItem);
345 CHECK_NULL_VOID(spanItem->accessibilityProperty);
346 spanItem->accessibilityProperty->SetAccessibilityLevel(importance);
347 }
348
InitSpan(UINode * uiNode,const std::u16string & content)349 void SpanModelNG::InitSpan(UINode* uiNode, const std::u16string& content)
350 {
351 ACE_UPDATE_NODE_SPAN_PROPERTY(Content, content, uiNode);
352 }
353
SetFontWeight(UINode * uiNode,FontWeight value)354 void SpanModelNG::SetFontWeight(UINode* uiNode, FontWeight value)
355 {
356 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
357 CHECK_NULL_VOID(spanNode);
358 spanNode->UpdateFontWeight(value);
359 }
360
ResetFontWeight(UINode * uiNode)361 void SpanModelNG::ResetFontWeight(UINode *uiNode)
362 {
363 ACE_RESET_NODE_SPAN_PROPERTY(FontWeight, uiNode);
364 }
365
SetTextCase(UINode * uiNode,TextCase value)366 void SpanModelNG::SetTextCase(UINode* uiNode, TextCase value)
367 {
368 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
369 CHECK_NULL_VOID(spanNode);
370 spanNode->UpdateTextCase(value);
371 }
372
ResetTextCase(UINode * uiNode)373 void SpanModelNG::ResetTextCase(UINode *uiNode)
374 {
375 ACE_RESET_NODE_SPAN_PROPERTY(TextCase, uiNode);
376 }
377
SetItalicFontStyle(UINode * uiNode,Ace::FontStyle value)378 void SpanModelNG::SetItalicFontStyle(UINode* uiNode, Ace::FontStyle value)
379 {
380 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
381 CHECK_NULL_VOID(spanNode);
382 spanNode->UpdateItalicFontStyle(value);
383 }
384
ResetItalicFontStyle(UINode * uiNode)385 void SpanModelNG::ResetItalicFontStyle(UINode *uiNode)
386 {
387 ACE_RESET_NODE_SPAN_PROPERTY(ItalicFontStyle, uiNode);
388 }
389
SetLineHeight(UINode * uiNode,const Dimension & value)390 void SpanModelNG::SetLineHeight(UINode* uiNode, const Dimension& value)
391 {
392 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
393 CHECK_NULL_VOID(spanNode);
394 spanNode->UpdateLineHeight(value);
395 }
396
ResetLineHeight(UINode * uiNode)397 void SpanModelNG::ResetLineHeight(UINode* uiNode)
398 {
399 ACE_RESET_NODE_SPAN_PROPERTY(LineHeight, uiNode);
400 }
401
SetFontSize(UINode * uiNode,const Dimension & value)402 void SpanModelNG::SetFontSize(UINode* uiNode, const Dimension& value)
403 {
404 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
405 CHECK_NULL_VOID(spanNode);
406 spanNode->UpdateFontSize(value);
407 }
408
ResetFontSize(UINode * uiNode)409 void SpanModelNG::ResetFontSize(UINode *uiNode)
410 {
411 ACE_RESET_NODE_SPAN_PROPERTY(FontSize, uiNode);
412 }
413
SetFontFamily(UINode * uiNode,const std::vector<std::string> & value)414 void SpanModelNG::SetFontFamily(UINode* uiNode, const std::vector<std::string>& value)
415 {
416 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
417 CHECK_NULL_VOID(spanNode);
418 spanNode->UpdateFontFamily(value);
419 }
420
ResetFontFamily(UINode * uiNode)421 void SpanModelNG::ResetFontFamily(UINode *uiNode)
422 {
423 ACE_RESET_NODE_SPAN_PROPERTY(FontFamily, uiNode);
424 }
425
SetTextDecoration(UINode * uiNode,TextDecoration value)426 void SpanModelNG::SetTextDecoration(UINode* uiNode, TextDecoration value)
427 {
428 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
429 CHECK_NULL_VOID(spanNode);
430 spanNode->UpdateTextDecoration({value});
431 }
432
ResetTextDecoration(UINode * uiNode)433 void SpanModelNG::ResetTextDecoration(UINode *uiNode)
434 {
435 ACE_RESET_NODE_SPAN_PROPERTY(TextDecoration, uiNode);
436 }
437
SetTextDecorationStyle(UINode * uiNode,TextDecorationStyle value)438 void SpanModelNG::SetTextDecorationStyle(UINode* uiNode, TextDecorationStyle value)
439 {
440 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
441 CHECK_NULL_VOID(spanNode);
442 spanNode->UpdateTextDecorationStyle(value);
443 }
444
ResetTextDecorationStyle(UINode * uiNode)445 void SpanModelNG::ResetTextDecorationStyle(UINode *uiNode)
446 {
447 ACE_RESET_NODE_SPAN_PROPERTY(TextDecorationStyle, uiNode);
448 }
449
SetTextDecorationColor(UINode * uiNode,const Color & value)450 void SpanModelNG::SetTextDecorationColor(UINode* uiNode, const Color& value)
451 {
452 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
453 CHECK_NULL_VOID(spanNode);
454 spanNode->UpdateTextDecorationColor(value);
455 }
456
ResetTextDecorationColor(UINode * uiNode)457 void SpanModelNG::ResetTextDecorationColor(UINode *uiNode)
458 {
459 ACE_RESET_NODE_SPAN_PROPERTY(TextDecorationColor, uiNode);
460 }
461
SetLineThicknessScale(UINode * uiNode,float value)462 void SpanModelNG::SetLineThicknessScale(UINode *uiNode, float value)
463 {
464 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
465 CHECK_NULL_VOID(spanNode);
466 spanNode->UpdateLineThicknessScale(value);
467 }
468
ResetLineThicknessScale(UINode * uiNode)469 void SpanModelNG::ResetLineThicknessScale(UINode* uiNode)
470 {
471 ACE_RESET_NODE_SPAN_PROPERTY(LineThicknessScale, uiNode);
472 }
473
SetTextColor(UINode * uiNode,const Color & value)474 void SpanModelNG::SetTextColor(UINode* uiNode, const Color& value)
475 {
476 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
477 CHECK_NULL_VOID(spanNode);
478 spanNode->UpdateSpanTextColor(value);
479 }
480
ResetTextColor(UINode * uiNode)481 void SpanModelNG::ResetTextColor(UINode *uiNode)
482 {
483 ACE_RESET_NODE_SPAN_PROPERTY(TextColor, uiNode);
484 }
485
SetLetterSpacing(UINode * uiNode,const Dimension & value)486 void SpanModelNG::SetLetterSpacing(UINode* uiNode, const Dimension& value)
487 {
488 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
489 CHECK_NULL_VOID(spanNode);
490 spanNode->UpdateLetterSpacing(value);
491 }
492
ResetLetterSpacing(UINode * uiNode)493 void SpanModelNG::ResetLetterSpacing(UINode *uiNode)
494 {
495 ACE_RESET_NODE_SPAN_PROPERTY(LetterSpacing, uiNode);
496 }
497
SetBaselineOffset(UINode * uiNode,const Dimension & value)498 void SpanModelNG::SetBaselineOffset(UINode* uiNode, const Dimension& value)
499 {
500 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
501 CHECK_NULL_VOID(spanNode);
502 spanNode->UpdateBaselineOffset(value);
503 }
504
SetFont(UINode * uiNode,const Font & value)505 void SpanModelNG::SetFont(UINode* uiNode, const Font& value)
506 {
507 if (value.fontSize.has_value()) {
508 SetFontSize(uiNode, value.fontSize.value());
509 } else {
510 ResetFontSize(uiNode);
511 }
512 if (value.fontWeight.has_value()) {
513 SetFontWeight(uiNode, value.fontWeight.value());
514 } else {
515 ResetFontWeight(uiNode);
516 }
517 if (!value.fontFamilies.empty()) {
518 SetFontFamily(uiNode, value.fontFamilies);
519 } else {
520 ResetFontFamily(uiNode);
521 }
522 if (value.fontStyle.has_value()) {
523 SetItalicFontStyle(uiNode, value.fontStyle.value());
524 } else {
525 ResetItalicFontStyle(uiNode);
526 }
527 }
528
ResetFont(UINode * uiNode)529 void SpanModelNG::ResetFont(UINode *uiNode)
530 {
531 ResetFontSize(uiNode);
532 ResetFontWeight(uiNode);
533 ResetFontFamily(uiNode);
534 ResetItalicFontStyle(uiNode);
535 }
536
CreateContainSpan()537 void SpanModelNG::CreateContainSpan()
538 {
539 auto* stack = ViewStackProcessor::GetInstance();
540 auto nodeId = stack->ClaimNodeId();
541 auto spanNode = ContainerSpanNode::GetOrCreateSpanNode(nodeId);
542 stack->Push(spanNode);
543 }
544
SetTextBackgroundStyle(const TextBackgroundStyle & style)545 void SpanModelNG::SetTextBackgroundStyle(const TextBackgroundStyle& style)
546 {
547 auto baseSpan = AceType::DynamicCast<BaseSpan>(ViewStackProcessor::GetInstance()->GetMainElementNode());
548 CHECK_NULL_VOID(baseSpan);
549 baseSpan->SetTextBackgroundStyle(style);
550 CHECK_NULL_VOID(SystemProperties::ConfigChangePerform());
551 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
552 auto key = "textbackgroundStyle";
553 auto&& updateFunc = [style, weak = WeakPtr<BaseSpan>(baseSpan)](const RefPtr<ResourceObject>& resObj) {
554 auto baseSpan = weak.Upgrade();
555 CHECK_NULL_VOID(baseSpan);
556 TextBackgroundStyle& styleValue = const_cast<TextBackgroundStyle&>(style);
557 styleValue.ReloadResources();
558 baseSpan->SetTextBackgroundStyle(styleValue);
559 };
560 baseSpan->AddResObj(key, resObj, std::move(updateFunc));
561 }
562
SetTextBackgroundStyle(UINode * uiNode,const TextBackgroundStyle & style)563 void SpanModelNG::SetTextBackgroundStyle(UINode* uiNode, const TextBackgroundStyle& style)
564 {
565 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
566 CHECK_NULL_VOID(spanNode);
567 spanNode->SetTextBackgroundStyle(style);
568 CHECK_NULL_VOID(SystemProperties::ConfigChangePerform());
569 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
570 auto key = "textbackgroundStyle";
571 auto&& updateFunc = [style, weak = AceType::WeakClaim(spanNode)](const RefPtr<ResourceObject>& resObj) {
572 auto spanNode = weak.Upgrade();
573 CHECK_NULL_VOID(spanNode);
574 TextBackgroundStyle& styleValue = const_cast<TextBackgroundStyle&>(style);
575 styleValue.ReloadResources();
576 spanNode->SetTextBackgroundStyle(styleValue);
577 };
578 spanNode->AddResObj(key, resObj, std::move(updateFunc));
579 }
580
SetTextBackgroundStyleByBaseSpan(UINode * uiNode,const TextBackgroundStyle & style)581 void SpanModelNG::SetTextBackgroundStyleByBaseSpan(UINode* uiNode, const TextBackgroundStyle& style)
582 {
583 auto spanNode = AceType::DynamicCast<BaseSpan>(uiNode);
584 CHECK_NULL_VOID(spanNode);
585 spanNode->SetTextBackgroundStyle(style);
586 CHECK_NULL_VOID(SystemProperties::ConfigChangePerform());
587 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
588 auto key = "textbackgroundStyle";
589 auto&& updateFunc = [style, weak = AceType::WeakClaim(spanNode)](const RefPtr<ResourceObject>& resObj) {
590 auto spanNode = weak.Upgrade();
591 CHECK_NULL_VOID(spanNode);
592 TextBackgroundStyle& styleValue = const_cast<TextBackgroundStyle&>(style);
593 styleValue.ReloadResources();
594 spanNode->SetTextBackgroundStyle(styleValue);
595 };
596 spanNode->AddResObj(key, resObj, std::move(updateFunc));
597 }
598
GetContent(UINode * uiNode)599 std::u16string SpanModelNG::GetContent(UINode* uiNode)
600 {
601 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
602 CHECK_NULL_RETURN(spanNode, u"");
603 auto spanItem = spanNode->GetSpanItem();
604 CHECK_NULL_RETURN(spanItem, u"");
605 return spanItem->GetSpanContent();
606 }
607
GetTextDecoration(UINode * uiNode)608 Ace::TextDecoration SpanModelNG::GetTextDecoration(UINode* uiNode)
609 {
610 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
611 CHECK_NULL_RETURN(spanNode, TextDecoration::NONE);
612 return spanNode->GetTextDecorationFirst();
613 }
614
GetTextDecorationColor(UINode * uiNode)615 Color SpanModelNG::GetTextDecorationColor(UINode* uiNode)
616 {
617 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
618 CHECK_NULL_RETURN(spanNode, Color::BLACK);
619 return spanNode->GetTextDecorationColor().value_or(Color::BLACK);
620 }
621
GetTextDecorationStyle(UINode * uiNode)622 Ace::TextDecorationStyle SpanModelNG::GetTextDecorationStyle(UINode* uiNode)
623 {
624 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
625 CHECK_NULL_RETURN(spanNode, TextDecorationStyle::SOLID);
626 return spanNode->GetTextDecorationStyle().value_or(TextDecorationStyle::SOLID);
627 }
628
GetDefaultTextStyle(int32_t themeScopeId)629 TextStyle SpanModelNG::GetDefaultTextStyle(int32_t themeScopeId)
630 {
631 TextStyle textStyle;
632 auto pipelineContext = PipelineContext::GetCurrentContextSafelyWithCheck();
633 CHECK_NULL_RETURN(pipelineContext, textStyle);
634 auto textTheme = pipelineContext->GetTheme<TextTheme>(themeScopeId);
635 CHECK_NULL_RETURN(textTheme, textStyle);
636 return textTheme->GetTextStyle();
637 }
638
GetFontColor(UINode * uiNode)639 Color SpanModelNG::GetFontColor(UINode* uiNode)
640 {
641 auto themeScopeId = uiNode ? uiNode->GetThemeScopeId() : 0;
642 auto defaultColor = GetDefaultTextStyle(themeScopeId).GetTextColor();
643 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
644 CHECK_NULL_RETURN(spanNode, defaultColor);
645 return spanNode->GetTextColor().value_or(defaultColor);
646 }
647
GetFontSize(UINode * uiNode)648 Dimension SpanModelNG::GetFontSize(UINode* uiNode)
649 {
650 auto themeScopeId = uiNode ? uiNode->GetThemeScopeId() : 0;
651 const Dimension& defaultFontSize = GetDefaultTextStyle(themeScopeId).GetFontSize();
652 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
653 CHECK_NULL_RETURN(spanNode, defaultFontSize);
654 return spanNode->GetFontSize().value_or(defaultFontSize);
655 }
656
GetFontStyle(UINode * uiNode)657 Ace::FontStyle SpanModelNG::GetFontStyle(UINode* uiNode)
658 {
659 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
660 CHECK_NULL_RETURN(spanNode, Ace::FontStyle::NORMAL);
661 return spanNode->GetItalicFontStyle().value_or(Ace::FontStyle::NORMAL);
662 }
663
GetFontWeight(UINode * uiNode)664 FontWeight SpanModelNG::GetFontWeight(UINode* uiNode)
665 {
666 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
667 CHECK_NULL_RETURN(spanNode, FontWeight::NORMAL);
668 return spanNode->GetFontWeight().value_or(FontWeight::NORMAL);
669 }
670
GetTextLineHeight(UINode * uiNode)671 Dimension SpanModelNG::GetTextLineHeight(UINode* uiNode)
672 {
673 Dimension defaultLineHeight(0);
674 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
675 CHECK_NULL_RETURN(spanNode, Dimension(0));
676 return spanNode->GetLineHeight().value_or(defaultLineHeight);
677 }
678
GetTextCase(UINode * uiNode)679 Ace::TextCase SpanModelNG::GetTextCase(UINode* uiNode)
680 {
681 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
682 CHECK_NULL_RETURN(spanNode, TextCase::NORMAL);
683 return spanNode->GetTextCase().value_or(TextCase::NORMAL);
684 }
685
GetLetterSpacing(UINode * uiNode)686 Dimension SpanModelNG::GetLetterSpacing(UINode* uiNode)
687 {
688 Dimension defaultLetterSpacing(0);
689 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
690 CHECK_NULL_RETURN(spanNode, defaultLetterSpacing);
691 return spanNode->GetLetterSpacing().value_or(defaultLetterSpacing);
692 }
693
GetBaselineOffset(UINode * uiNode)694 Dimension SpanModelNG::GetBaselineOffset(UINode* uiNode)
695 {
696 Dimension defaultBaselineOffset(0);
697 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
698 CHECK_NULL_RETURN(spanNode, defaultBaselineOffset);
699 return spanNode->GetBaselineOffset().value_or(defaultBaselineOffset);
700 }
701
GetSpanTextBackgroundStyle(UINode * uiNode)702 TextBackgroundStyle SpanModelNG::GetSpanTextBackgroundStyle(UINode* uiNode)
703 {
704 TextBackgroundStyle backgroundStyle;
705 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
706 CHECK_NULL_RETURN(spanNode, backgroundStyle);
707 return spanNode->GetTextBackgroundStyle().value_or(backgroundStyle);
708 }
709
GetTextShadow(UINode * uiNode)710 std::vector<Shadow> SpanModelNG::GetTextShadow(UINode* uiNode)
711 {
712 std::vector<Shadow> defaultShadow;
713 CHECK_NULL_RETURN(uiNode, defaultShadow);
714 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
715 CHECK_NULL_RETURN(spanNode, defaultShadow);
716 return spanNode->GetTextShadow().value_or(defaultShadow);
717 }
718
SetAccessibilityText(UINode * uiNode,const std::string & text)719 void SpanModelNG::SetAccessibilityText(UINode* uiNode, const std::string& text)
720 {
721 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
722 CHECK_NULL_VOID(spanNode);
723 auto spanItem = spanNode->GetSpanItem();
724 CHECK_NULL_VOID(spanItem);
725 CHECK_NULL_VOID(spanItem->accessibilityProperty);
726 spanItem->accessibilityProperty->SetAccessibilityText(text);
727 }
728
SetAccessibilityDescription(UINode * uiNode,const std::string & description)729 void SpanModelNG::SetAccessibilityDescription(UINode* uiNode, const std::string& description)
730 {
731 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
732 CHECK_NULL_VOID(spanNode);
733 auto spanItem = spanNode->GetSpanItem();
734 CHECK_NULL_VOID(spanItem);
735 CHECK_NULL_VOID(spanItem->accessibilityProperty);
736 spanItem->accessibilityProperty->SetAccessibilityDescription(description);
737 }
738
SetAccessibilityImportance(UINode * uiNode,const std::string & importance)739 void SpanModelNG::SetAccessibilityImportance(UINode* uiNode, const std::string& importance)
740 {
741 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
742 CHECK_NULL_VOID(spanNode);
743 auto spanItem = spanNode->GetSpanItem();
744 CHECK_NULL_VOID(spanItem);
745 CHECK_NULL_VOID(spanItem->accessibilityProperty);
746 spanItem->accessibilityProperty->SetAccessibilityLevel(importance);
747 }
748
GetSpanFontFamily(UINode * uiNode)749 std::vector<std::string> SpanModelNG::GetSpanFontFamily(UINode* uiNode)
750 {
751 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
752 std::vector<std::string> value;
753 CHECK_NULL_RETURN(spanNode, value);
754 return spanNode->GetFontFamily().value_or(value);
755 }
756
SetOnHover(OnHoverFunc && onHoverEventFunc)757 void SpanModelNG::SetOnHover(OnHoverFunc&& onHoverEventFunc)
758 {
759 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
760 CHECK_NULL_VOID(spanNode);
761 auto spanItem = spanNode->GetSpanItem();
762 CHECK_NULL_VOID(spanItem);
763 spanItem->SetHoverEvent(std::move(onHoverEventFunc));
764 }
765
SetOnHover(UINode * uiNode,OnHoverFunc && onHoverEventFunc)766 void SpanModelNG::SetOnHover(UINode* uiNode, OnHoverFunc&& onHoverEventFunc)
767 {
768 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
769 CHECK_NULL_VOID(spanNode);
770 auto spanItem = spanNode->GetSpanItem();
771 CHECK_NULL_VOID(spanItem);
772 spanItem->SetHoverEvent(std::move(onHoverEventFunc));
773 }
774
ResetOnHover()775 void SpanModelNG::ResetOnHover()
776 {
777 auto spanNode = AceType::DynamicCast<SpanNode>(ViewStackProcessor::GetInstance()->GetMainElementNode());
778 CHECK_NULL_VOID(spanNode);
779 auto spanItem = spanNode->GetSpanItem();
780 CHECK_NULL_VOID(spanItem);
781 spanItem->ResetHoverEvent();
782 }
783
ResetOnHover(UINode * uiNode)784 void SpanModelNG::ResetOnHover(UINode* uiNode)
785 {
786 auto spanNode = AceType::DynamicCast<SpanNode>(uiNode);
787 CHECK_NULL_VOID(spanNode);
788 auto spanItem = spanNode->GetSpanItem();
789 CHECK_NULL_VOID(spanItem);
790 spanItem->ResetHoverEvent();
791 }
792 } // namespace OHOS::Ace::NG
793