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 #include "core/interfaces/native/node/node_text_modifier.h"
16
17 #include "base/utils/utf_helper.h"
18 #include "base/utils/utils.h"
19 #include "bridge/common/utils/utils.h"
20 #include "core/components/common/layout/constants.h"
21 #include "core/components/common/properties/text_style.h"
22 #include "core/components/common/properties/text_style_parser.h"
23 #include "core/components/font/constants_converter.h"
24 #include "core/components_ng/base/frame_node.h"
25 #include "core/components_ng/base/view_abstract.h"
26 #include "core/interfaces/arkoala/arkoala_api.h"
27 #include "core/pipeline/base/element_register.h"
28 #include "frameworks/core/components/common/layout/constants.h"
29 #include "frameworks/core/components/common/properties/text_style.h"
30 #include "frameworks/core/components_ng/pattern/text/text_model_ng.h"
31
32 namespace OHOS::Ace::NG {
33 constexpr int DEFAULT_SELECTION = -1;
34 constexpr Dimension DEFAULT_LINE_HEIGHT = Dimension(0.0, DimensionUnit::PX);
35 constexpr Dimension DEFAULT_LINE_SPACING = Dimension(0.0, DimensionUnit::PX);
36 constexpr bool DEFAULT_TRIM_SPACE = false;
37 constexpr TextDecoration DEFAULT_TEXT_DECORATION = TextDecoration::NONE;
38 constexpr Color DEFAULT_DECORATION_COLOR = Color(0xff000000);
39 constexpr TextDecorationStyle DEFAULT_DECORATION_STYLE = TextDecorationStyle::SOLID;
40 constexpr TextCase DEFAULT_TEXT_CASE = TextCase::NORMAL;
41 constexpr uint32_t DEFAULT_MAX_LINE = Infinity<uint32_t>();
42 constexpr bool DEFAULT_TEXT_DRAGGABLE = false;
43 constexpr bool DEFAULT_TEXT_SENSITIVE = false;
44 constexpr Dimension DEFAULT_MAX_FONT_SIZE;
45 constexpr Dimension DEFAULT_MIN_FONT_SIZE;
46 constexpr float DEFAULT_MIN_FONT_SCALE = 0.0f;
47 constexpr float DEFAULT_MAX_FONT_SCALE = static_cast<float>(INT32_MAX);
48 constexpr CopyOptions DEFAULT_COPY_OPTION = CopyOptions::None;
49 constexpr Dimension DEFAULT_BASELINE_OFFSET = 0.0_fp;
50 constexpr Dimension DEFAULT_FONT_SIZE = 16.0_fp;
51 constexpr FontWeight DEFAULT_FONT_WEIGHT = FontWeight::NORMAL;
52 constexpr int32_t DEFAULT_VARIABLE_FONT_WEIGHT = 400;
53 constexpr Ace::FontStyle DEFAULT_FONT_STYLE = Ace::FontStyle::NORMAL;
54 const std::string DEFAULT_FAMILY = "HarmonyOS Sans";
55 const std::string EMPTY_STRING = "";
56 const std::vector<OHOS::Ace::FontStyle> FONT_STYLES = { OHOS::Ace::FontStyle::NORMAL, OHOS::Ace::FontStyle::ITALIC };
57 const std::vector<OHOS::Ace::TextAlign> TEXT_ALIGNS = { OHOS::Ace::TextAlign::START, OHOS::Ace::TextAlign::CENTER,
58 OHOS::Ace::TextAlign::END, OHOS::Ace::TextAlign::JUSTIFY, OHOS::Ace::TextAlign::LEFT, OHOS::Ace::TextAlign::RIGHT };
59 const std::vector<TextHeightAdaptivePolicy> HEIGHT_ADAPTIVE_POLICY = { TextHeightAdaptivePolicy::MAX_LINES_FIRST,
60 TextHeightAdaptivePolicy::MIN_FONT_SIZE_FIRST, TextHeightAdaptivePolicy::LAYOUT_CONSTRAINT_FIRST };
61 const std::vector<EllipsisMode> ELLIPSIS_MODALS = { EllipsisMode::HEAD, EllipsisMode::MIDDLE, EllipsisMode::TAIL };
62 const std::vector<TextSelectableMode> TEXT_SELECTABLE_MODE = { TextSelectableMode::SELECTABLE_UNFOCUSABLE,
63 TextSelectableMode::SELECTABLE_FOCUSABLE, TextSelectableMode::UNSELECTABLE };
64 constexpr bool DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE = true;
65 constexpr bool DEFAULT_ENABLE_TEXT_DETECTOR = false;
66 const std::vector<std::string> TEXT_DETECT_TYPES = { "phoneNum", "url", "email", "location", "datetime" };
67 constexpr int NUM_0 = 0;
68 constexpr int NUM_1 = 1;
69 constexpr int NUM_2 = 2;
70 constexpr int NUM_3 = 3;
71 constexpr int NUM_4 = 4;
72 constexpr int NUM_5 = 5;
73 constexpr int NUM_6 = 6;
74 constexpr int NUM_7 = 7;
75 constexpr int NUM_8 = 8;
76 constexpr int NUM_9 = 9;
77 constexpr int NUM_10 = 10;
78 constexpr float DEFAULT_ANGLE = 180.0f;
79 constexpr double PERCENT_100 = 100.0;
80
81 std::map<TextHeightAdaptivePolicy, int> TEXT_HEIGHT_ADAPTIVE_POLICY_MAP = {
82 { TextHeightAdaptivePolicy::MAX_LINES_FIRST, 0 },
83 { TextHeightAdaptivePolicy::MIN_FONT_SIZE_FIRST, 1 },
84 { TextHeightAdaptivePolicy::LAYOUT_CONSTRAINT_FIRST, 2 } };
85
86 const float ERROR_FLOAT_CODE = -1.0f;
87 const int32_t ERROR_INT_CODE = -1;
88
ConvertStrToFontWeight(const char * weight,FontWeight defaultFontWeight=FontWeight::NORMAL)89 FontWeight ConvertStrToFontWeight(const char* weight, FontWeight defaultFontWeight = FontWeight::NORMAL)
90 {
91 std::string weightStr(weight);
92 return StringUtils::StringToFontWeight(weightStr, defaultFontWeight);
93 }
94 namespace {
95
96 thread_local std::string g_strValue;
SetTextContent(ArkUINodeHandle node,ArkUI_CharPtr value,void * contentRawPtr)97 void SetTextContent(ArkUINodeHandle node, ArkUI_CharPtr value, void* contentRawPtr)
98 {
99 auto* frameNode = reinterpret_cast<FrameNode*>(node);
100 CHECK_NULL_VOID(frameNode);
101 std::u16string content = UtfUtils::Str8DebugToStr16(std::string(value));
102 TextModelNG::InitText(frameNode, content);
103 NodeModifier::ProcessResourceObj<std::u16string>(frameNode, "Content", content, contentRawPtr);
104 }
105
GetTextContent(ArkUINodeHandle node)106 const char* GetTextContent(ArkUINodeHandle node)
107 {
108 auto* frameNode = reinterpret_cast<FrameNode*>(node);
109 CHECK_NULL_RETURN(frameNode, nullptr);
110 g_strValue = UtfUtils::Str16DebugToStr8(TextModelNG::GetContent(frameNode));
111 return g_strValue.c_str();
112 }
113
SetFontWeightStr(ArkUINodeHandle node,ArkUI_CharPtr weight)114 void SetFontWeightStr(ArkUINodeHandle node, ArkUI_CharPtr weight)
115 {
116 auto* frameNode = reinterpret_cast<FrameNode*>(node);
117 CHECK_NULL_VOID(frameNode);
118 TextModelNG::SetFontWeight(frameNode, ConvertStrToFontWeight(weight));
119 }
120
SetFontWeightWithOption(ArkUINodeHandle node,const struct ArkUIFontWeightWithOptionsStruct * weightInfo)121 void SetFontWeightWithOption(ArkUINodeHandle node, const struct ArkUIFontWeightWithOptionsStruct* weightInfo)
122 {
123 auto* frameNode = reinterpret_cast<FrameNode*>(node);
124 CHECK_NULL_VOID(frameNode);
125 TextModelNG::SetFontWeight(frameNode, ConvertStrToFontWeight(weightInfo->weight));
126 TextModelNG::SetVariableFontWeight(frameNode, weightInfo->variableFontWeight);
127 TextModelNG::SetEnableVariableFontWeight(frameNode, weightInfo->enableVariableFontWeight);
128 }
129
SetFontWeight(ArkUINodeHandle node,ArkUI_Int32 weight)130 void SetFontWeight(ArkUINodeHandle node, ArkUI_Int32 weight)
131 {
132 auto* frameNode = reinterpret_cast<FrameNode*>(node);
133 CHECK_NULL_VOID(frameNode);
134 TextModelNG::SetFontWeight(frameNode, static_cast<FontWeight>(weight));
135 TextModelNG::SetVariableFontWeight(frameNode, DEFAULT_VARIABLE_FONT_WEIGHT);
136 TextModelNG::SetEnableVariableFontWeight(frameNode, false);
137 }
138
SetImmutableFontWeight(ArkUINodeHandle node,ArkUI_Int32 weight)139 void SetImmutableFontWeight(ArkUINodeHandle node, ArkUI_Int32 weight)
140 {
141 auto* frameNode = reinterpret_cast<FrameNode*>(node);
142 CHECK_NULL_VOID(frameNode);
143 TextModelNG::SetFontWeight(frameNode, static_cast<FontWeight>(weight));
144 TextModelNG::SetVariableFontWeight(frameNode, Constants::GetVariableFontWeight(static_cast<FontWeight>(weight)));
145 TextModelNG::SetEnableVariableFontWeight(frameNode, true);
146 }
147
SetOnClick(ArkUINodeHandle node,void * callback)148 void SetOnClick(ArkUINodeHandle node, void* callback)
149 {
150 auto* frameNode = reinterpret_cast<FrameNode*>(node);
151 CHECK_NULL_VOID(frameNode);
152 GestureEventFunc* click = nullptr;
153 if (callback) {
154 click = reinterpret_cast<GestureEventFunc*>(callback);
155 TextModelNG::SetOnClick(frameNode, std::move(*click));
156 } else {
157 TextModelNG::SetOnClick(frameNode, nullptr);
158 }
159 }
160
ResetOnClick(ArkUINodeHandle node)161 void ResetOnClick(ArkUINodeHandle node)
162 {
163 auto* frameNode = reinterpret_cast<FrameNode*>(node);
164 CHECK_NULL_VOID(frameNode);
165 TextModelNG::ClearOnClick(frameNode);
166 }
167
SetResponseRegion(ArkUINodeHandle node,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length)168 void SetResponseRegion(ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length)
169 {
170 auto* frameNode = reinterpret_cast<FrameNode*>(node);
171 CHECK_NULL_VOID(frameNode);
172 std::vector<DimensionRect> region;
173 for (int32_t i = 0; i < length / NUM_4; i++) {
174 CalcDimension xDimen =
175 CalcDimension(values[i * NUM_4 + NUM_0], static_cast<DimensionUnit>(units[i * NUM_4 + NUM_0]));
176 CalcDimension yDimen =
177 CalcDimension(values[i * NUM_4 + NUM_1], static_cast<DimensionUnit>(units[i * NUM_4 + NUM_1]));
178 CalcDimension widthDimen =
179 CalcDimension(values[i * NUM_4 + NUM_2], static_cast<DimensionUnit>(units[i * NUM_4 + NUM_2]));
180 CalcDimension heightDimen =
181 CalcDimension(values[i * NUM_4 + NUM_3], static_cast<DimensionUnit>(units[i * NUM_4 + NUM_3]));
182 DimensionOffset offsetDimen(xDimen, yDimen);
183 DimensionRect dimenRect(widthDimen, heightDimen, offsetDimen);
184 region.emplace_back(dimenRect);
185 }
186 TextModelNG::SetResponseRegion(frameNode, region);
187 }
188
ResetResponseRegion(ArkUINodeHandle node)189 void ResetResponseRegion(ArkUINodeHandle node)
190 {
191 auto* frameNode = reinterpret_cast<FrameNode*>(node);
192 CHECK_NULL_VOID(frameNode);
193 TextModelNG::ClearResponseRegion(frameNode);
194 }
ResetFontWeight(ArkUINodeHandle node)195 void ResetFontWeight(ArkUINodeHandle node)
196 {
197 auto* frameNode = reinterpret_cast<FrameNode*>(node);
198 CHECK_NULL_VOID(frameNode);
199 TextModelNG::SetFontWeight(frameNode, Ace::FontWeight::NORMAL);
200 TextModelNG::SetVariableFontWeight(frameNode, DEFAULT_VARIABLE_FONT_WEIGHT);
201 TextModelNG::SetEnableVariableFontWeight(frameNode, false);
202 }
203
SetFontStyle(ArkUINodeHandle node,ArkUI_Uint32 fontStyle)204 void SetFontStyle(ArkUINodeHandle node, ArkUI_Uint32 fontStyle)
205 {
206 auto* frameNode = reinterpret_cast<FrameNode*>(node);
207 CHECK_NULL_VOID(frameNode);
208 if (fontStyle < 0 || fontStyle >= FONT_STYLES.size()) {
209 return;
210 }
211 TextModelNG::SetItalicFontStyle(frameNode, FONT_STYLES[fontStyle]);
212 }
213
ResetFontStyle(ArkUINodeHandle node)214 void ResetFontStyle(ArkUINodeHandle node)
215 {
216 auto* frameNode = reinterpret_cast<FrameNode*>(node);
217 CHECK_NULL_VOID(frameNode);
218 TextModelNG::SetItalicFontStyle(frameNode, OHOS::Ace::FontStyle::NORMAL);
219 }
220
SetTextAlign(ArkUINodeHandle node,ArkUI_Uint32 testAlign)221 void SetTextAlign(ArkUINodeHandle node, ArkUI_Uint32 testAlign)
222 {
223 auto* frameNode = reinterpret_cast<FrameNode*>(node);
224 CHECK_NULL_VOID(frameNode);
225 if (testAlign < 0 || testAlign >= TEXT_ALIGNS.size()) {
226 return;
227 }
228 TextModelNG::SetTextAlign(frameNode, TEXT_ALIGNS[testAlign]);
229 }
230
GetTextAlign(ArkUINodeHandle node)231 int32_t GetTextAlign(ArkUINodeHandle node)
232 {
233 auto defaultTextAlign = static_cast<int32_t>(OHOS::Ace::TextAlign::START);
234 auto* frameNode = reinterpret_cast<FrameNode*>(node);
235 CHECK_NULL_RETURN(frameNode, defaultTextAlign);
236 return static_cast<int32_t>(TextModelNG::GetTextAlign(frameNode));
237 }
238
ResetTextAlign(ArkUINodeHandle node)239 void ResetTextAlign(ArkUINodeHandle node)
240 {
241 auto* frameNode = reinterpret_cast<FrameNode*>(node);
242 CHECK_NULL_VOID(frameNode);
243 TextModelNG::SetTextAlign(frameNode, OHOS::Ace::TextAlign::START);
244 }
245
SetFontColor(ArkUINodeHandle node,ArkUI_Uint32 color,void * fontColorRawPtr)246 void SetFontColor(ArkUINodeHandle node, ArkUI_Uint32 color, void* fontColorRawPtr)
247 {
248 auto* frameNode = reinterpret_cast<FrameNode*>(node);
249 CHECK_NULL_VOID(frameNode);
250 TextModelNG::SetTextColor(frameNode, Color(color));
251 NodeModifier::ProcessResourceObj<Color>(frameNode, "TextColor", Color(color), fontColorRawPtr);
252 }
253
ResetFontColor(ArkUINodeHandle node)254 void ResetFontColor(ArkUINodeHandle node)
255 {
256 auto* frameNode = reinterpret_cast<FrameNode*>(node);
257 CHECK_NULL_VOID(frameNode);
258 TextModelNG::ResetTextColor(frameNode);
259 if (SystemProperties::ConfigChangePerform()) {
260 auto pattern = frameNode->GetPattern();
261 CHECK_NULL_VOID(pattern);
262 pattern->UnRegisterResource("TextColor");
263 }
264 }
265
GetFontColor(ArkUINodeHandle node)266 uint32_t GetFontColor(ArkUINodeHandle node)
267 {
268 auto* frameNode = reinterpret_cast<FrameNode*>(node);
269 CHECK_NULL_RETURN(frameNode, Color::BLACK.GetValue());
270 return TextModelNG::GetFontColor(frameNode).GetValue();
271 }
272
SetTextForegroundColor(ArkUINodeHandle node,ArkUI_Bool isColor,uint32_t color,void * colorRawPtr)273 void SetTextForegroundColor(ArkUINodeHandle node, ArkUI_Bool isColor, uint32_t color, void* colorRawPtr)
274 {
275 auto* frameNode = reinterpret_cast<FrameNode*>(node);
276 CHECK_NULL_VOID(frameNode);
277 if (isColor) {
278 TextModelNG::SetTextColor(frameNode, Color(color));
279 NodeModifier::ProcessResourceObj<Color>(frameNode, "TextColor", Color(color), colorRawPtr);
280 } else {
281 TextModelNG::SetTextColor(frameNode, Color::FOREGROUND);
282 auto strategy = static_cast<ForegroundColorStrategy>(color);
283 ViewAbstract::SetForegroundColorStrategy(frameNode, strategy);
284 }
285 }
286
ResetTextForegroundColor(ArkUINodeHandle node)287 void ResetTextForegroundColor(ArkUINodeHandle node)
288 {
289 ResetFontColor(node);
290 }
291
SetFontSize(ArkUINodeHandle node,ArkUI_Float32 fontSize,ArkUI_Int32 unit,void * fontSizeRawPtr)292 void SetFontSize(ArkUINodeHandle node, ArkUI_Float32 fontSize, ArkUI_Int32 unit, void* fontSizeRawPtr)
293 {
294 auto* frameNode = reinterpret_cast<FrameNode*>(node);
295 CHECK_NULL_VOID(frameNode);
296 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(unit);
297 if (fontSize < 0 || unitEnum < OHOS::Ace::DimensionUnit::PX || unitEnum > OHOS::Ace::DimensionUnit::CALC ||
298 unitEnum == OHOS::Ace::DimensionUnit::PERCENT) {
299 auto theme = GetTheme<TextTheme>();
300 CHECK_NULL_VOID(theme);
301 CalcDimension fontSize = theme->GetTextStyle().GetFontSize();
302 TextModelNG::SetFontSize(frameNode, fontSize);
303 } else {
304 auto fontSizeValue = Dimension(fontSize, static_cast<OHOS::Ace::DimensionUnit>(unit));
305 TextModelNG::SetFontSize(frameNode, fontSizeValue);
306 NodeModifier::ProcessResourceObj<CalcDimension>(frameNode, "FontSize", fontSizeValue, fontSizeRawPtr);
307 }
308 }
309
ResetFontSize(ArkUINodeHandle node)310 void ResetFontSize(ArkUINodeHandle node)
311 {
312 auto* frameNode = reinterpret_cast<FrameNode*>(node);
313 CHECK_NULL_VOID(frameNode);
314 auto theme = GetTheme<TextTheme>();
315 CHECK_NULL_VOID(theme);
316 CalcDimension fontSize = theme->GetTextStyle().GetFontSize();
317 TextModelNG::SetFontSize(frameNode, fontSize);
318 if (SystemProperties::ConfigChangePerform()) {
319 auto pattern = frameNode->GetPattern();
320 CHECK_NULL_VOID(pattern);
321 pattern->UnRegisterResource("FontSize");
322 }
323 }
324
SetTextLineHeight(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit,void * lineHeightRawPtr)325 void SetTextLineHeight(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit, void* lineHeightRawPtr)
326 {
327 auto* frameNode = reinterpret_cast<FrameNode*>(node);
328 CHECK_NULL_VOID(frameNode);
329 TextModelNG::SetLineHeight(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
330 NodeModifier::ProcessResourceObj<CalcDimension>(
331 frameNode, "LineHeight", Dimension(number, static_cast<DimensionUnit>(unit)), lineHeightRawPtr);
332 }
333
GetTextLineHeight(ArkUINodeHandle node)334 float GetTextLineHeight(ArkUINodeHandle node)
335 {
336 auto* frameNode = reinterpret_cast<FrameNode*>(node);
337 CHECK_NULL_RETURN(frameNode, 0.0f);
338 return TextModelNG::GetLineHeight(frameNode);
339 }
340
ResetTextLineHeight(ArkUINodeHandle node)341 void ResetTextLineHeight(ArkUINodeHandle node)
342 {
343 auto* frameNode = reinterpret_cast<FrameNode*>(node);
344 CHECK_NULL_VOID(frameNode);
345 TextModelNG::SetLineHeight(frameNode, DEFAULT_LINE_HEIGHT);
346 if (SystemProperties::ConfigChangePerform()) {
347 auto pattern = frameNode->GetPattern();
348 CHECK_NULL_VOID(pattern);
349 pattern->UnRegisterResource("LineHeight");
350 }
351 }
352
SetTextTextOverflow(ArkUINodeHandle node,ArkUI_Int32 value)353 void SetTextTextOverflow(ArkUINodeHandle node, ArkUI_Int32 value)
354 {
355 auto* frameNode = reinterpret_cast<FrameNode*>(node);
356 CHECK_NULL_VOID(frameNode);
357 TextOverflow valueTextOverflow = static_cast<TextOverflow>(value);
358 TextModelNG::SetTextOverflow(frameNode, valueTextOverflow);
359 }
360
GetTextTextOverflow(ArkUINodeHandle node)361 int32_t GetTextTextOverflow(ArkUINodeHandle node)
362 {
363 int defaultTextOverflow = static_cast<int32_t>(TextOverflow::NONE);
364 auto* frameNode = reinterpret_cast<FrameNode*>(node);
365 CHECK_NULL_RETURN(frameNode, defaultTextOverflow);
366 return static_cast<int32_t>(TextModelNG::GetTextOverflow(frameNode));
367 }
368
ResetTextTextOverflow(ArkUINodeHandle node)369 void ResetTextTextOverflow(ArkUINodeHandle node)
370 {
371 auto* frameNode = reinterpret_cast<FrameNode*>(node);
372 CHECK_NULL_VOID(frameNode);
373 TextModelNG::SetTextOverflow(frameNode, TextOverflow::NONE);
374 }
375
SetTextDecoration(ArkUINodeHandle node,ArkUI_Int32 decoration,ArkUI_Uint32 color,void * colorRawPtr,ArkUI_Int32 style,ArkUI_Float32 lineThicknessScale=1.0f)376 void SetTextDecoration(
377 ArkUINodeHandle node, ArkUI_Int32 decoration,
378 ArkUI_Uint32 color, void* colorRawPtr, ArkUI_Int32 style, ArkUI_Float32 lineThicknessScale = 1.0f)
379 {
380 auto* frameNode = reinterpret_cast<FrameNode*>(node);
381 CHECK_NULL_VOID(frameNode);
382 TextModelNG::SetTextDecoration(frameNode, static_cast<TextDecoration>(decoration));
383 TextModelNG::SetTextDecorationColor(frameNode, Color(color));
384 NodeModifier::ProcessResourceObj<Color>(frameNode, "TextDecorationColor", Color(color), colorRawPtr);
385 TextModelNG::SetTextDecorationStyle(frameNode, static_cast<TextDecorationStyle>(style));
386 TextModelNG::SetLineThicknessScale(frameNode, lineThicknessScale);
387 }
388
SetTextDecoration(ArkUINodeHandle node,ArkUI_Int32 decoration,ArkUI_Uint32 color,ArkUI_Int32 style)389 void SetTextDecoration(ArkUINodeHandle node, ArkUI_Int32 decoration, ArkUI_Uint32 color, ArkUI_Int32 style)
390 {
391 SetTextDecoration(node, decoration, color, nullptr, style, 1.0f); // make cj happy
392 }
393
GetTextDecoration(ArkUINodeHandle node,ArkUITextDecorationType * decoration)394 void GetTextDecoration(ArkUINodeHandle node, ArkUITextDecorationType* decoration)
395 {
396 CHECK_NULL_VOID(decoration);
397 auto* frameNode = reinterpret_cast<FrameNode*>(node);
398 CHECK_NULL_VOID(frameNode);
399 decoration->decorationType = static_cast<int32_t>(TextModelNG::GetDecoration(frameNode));
400 decoration->color = TextModelNG::GetTextDecorationColor(frameNode).GetValue();
401 decoration->style = static_cast<int32_t>(TextModelNG::GetTextDecorationStyle(frameNode));
402 }
403
ResetTextDecoration(ArkUINodeHandle node)404 void ResetTextDecoration(ArkUINodeHandle node)
405 {
406 auto* frameNode = reinterpret_cast<FrameNode*>(node);
407 CHECK_NULL_VOID(frameNode);
408 TextModelNG::SetTextDecoration(frameNode, DEFAULT_TEXT_DECORATION);
409 TextModelNG::SetTextDecorationColor(frameNode, DEFAULT_DECORATION_COLOR);
410 TextModelNG::SetTextDecorationStyle(frameNode, DEFAULT_DECORATION_STYLE);
411 if (SystemProperties::ConfigChangePerform()) {
412 auto pattern = frameNode->GetPattern();
413 CHECK_NULL_VOID(pattern);
414 pattern->UnRegisterResource("TextDecorationColor");
415 }
416 }
417
SetTextTextCase(ArkUINodeHandle node,ArkUI_Int32 value)418 void SetTextTextCase(ArkUINodeHandle node, ArkUI_Int32 value)
419 {
420 auto* frameNode = reinterpret_cast<FrameNode*>(node);
421 CHECK_NULL_VOID(frameNode);
422 TextModelNG::SetTextCase(frameNode, static_cast<TextCase>(value));
423 }
424
GetTextTextCase(ArkUINodeHandle node)425 int32_t GetTextTextCase(ArkUINodeHandle node)
426 {
427 int32_t defaultTextCase = static_cast<int32_t>(DEFAULT_TEXT_CASE);
428 auto* frameNode = reinterpret_cast<FrameNode*>(node);
429 CHECK_NULL_RETURN(frameNode, defaultTextCase);
430 return static_cast<int32_t>(TextModelNG::GetTextCase(frameNode));
431 }
432
ResetTextTextCase(ArkUINodeHandle node)433 void ResetTextTextCase(ArkUINodeHandle node)
434 {
435 auto* frameNode = reinterpret_cast<FrameNode*>(node);
436 CHECK_NULL_VOID(frameNode);
437 TextModelNG::SetTextCase(frameNode, DEFAULT_TEXT_CASE);
438 }
439
SetTextMaxLines(ArkUINodeHandle node,ArkUI_Uint32 maxLine)440 void SetTextMaxLines(ArkUINodeHandle node, ArkUI_Uint32 maxLine)
441 {
442 auto* frameNode = reinterpret_cast<FrameNode*>(node);
443 CHECK_NULL_VOID(frameNode);
444 TextModelNG::SetMaxLines(frameNode, maxLine);
445 }
446
GetTextMaxLines(ArkUINodeHandle node)447 int32_t GetTextMaxLines(ArkUINodeHandle node)
448 {
449 auto* frameNode = reinterpret_cast<FrameNode*>(node);
450 CHECK_NULL_RETURN(frameNode, DEFAULT_MAX_LINE);
451 return TextModelNG::GetMaxLines(frameNode);
452 }
453
ResetTextMaxLines(ArkUINodeHandle node)454 void ResetTextMaxLines(ArkUINodeHandle node)
455 {
456 auto* frameNode = reinterpret_cast<FrameNode*>(node);
457 CHECK_NULL_VOID(frameNode);
458 TextModelNG::SetMaxLines(frameNode, DEFAULT_MAX_LINE);
459 }
460
SetTextMinFontSize(ArkUINodeHandle node,ArkUI_Float32 number,const ArkUI_Int32 unit,void * minFontSizeRawPtr)461 void SetTextMinFontSize(ArkUINodeHandle node, ArkUI_Float32 number, const ArkUI_Int32 unit, void* minFontSizeRawPtr)
462 {
463 auto* frameNode = reinterpret_cast<FrameNode*>(node);
464 CHECK_NULL_VOID(frameNode);
465 TextModelNG::SetAdaptMinFontSize(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
466 NodeModifier::ProcessResourceObj<CalcDimension>(
467 frameNode, "AdaptMinFontSize", Dimension(number, static_cast<DimensionUnit>(unit)), minFontSizeRawPtr);
468 }
469
ResetTextMinFontSize(ArkUINodeHandle node)470 void ResetTextMinFontSize(ArkUINodeHandle node)
471 {
472 auto* frameNode = reinterpret_cast<FrameNode*>(node);
473 CHECK_NULL_VOID(frameNode);
474 TextModelNG::SetAdaptMinFontSize(frameNode, DEFAULT_MIN_FONT_SIZE);
475 if (SystemProperties::ConfigChangePerform()) {
476 auto pattern = frameNode->GetPattern();
477 CHECK_NULL_VOID(pattern);
478 pattern->UnRegisterResource("AdaptMinFontSize");
479 }
480 }
481
SetTextDraggable(ArkUINodeHandle node,ArkUI_Uint32 draggable)482 void SetTextDraggable(ArkUINodeHandle node, ArkUI_Uint32 draggable)
483 {
484 auto* frameNode = reinterpret_cast<FrameNode*>(node);
485 CHECK_NULL_VOID(frameNode);
486 ViewAbstract::SetDraggable(frameNode, static_cast<bool>(draggable));
487 }
488
ResetTextDraggable(ArkUINodeHandle node)489 void ResetTextDraggable(ArkUINodeHandle node)
490 {
491 auto* frameNode = reinterpret_cast<FrameNode*>(node);
492 CHECK_NULL_VOID(frameNode);
493 ViewAbstract::SetDraggable(frameNode, DEFAULT_TEXT_DRAGGABLE);
494 }
495
SetTextPrivacySensitve(ArkUINodeHandle node,ArkUI_Uint32 sensitive)496 void SetTextPrivacySensitve(ArkUINodeHandle node, ArkUI_Uint32 sensitive)
497 {
498 auto* frameNode = reinterpret_cast<FrameNode*>(node);
499 CHECK_NULL_VOID(frameNode);
500 frameNode->SetPrivacySensitive(static_cast<bool>(sensitive));
501 frameNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
502 }
503
ResetTextPrivacySensitve(ArkUINodeHandle node)504 void ResetTextPrivacySensitve(ArkUINodeHandle node)
505 {
506 auto* frameNode = reinterpret_cast<FrameNode*>(node);
507 CHECK_NULL_VOID(frameNode);
508 frameNode->SetPrivacySensitive(DEFAULT_TEXT_SENSITIVE);
509 frameNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
510 }
511
SetTextMaxFontSize(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit,void * maxFontSizeRawPtr)512 void SetTextMaxFontSize(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit, void* maxFontSizeRawPtr)
513 {
514 auto* frameNode = reinterpret_cast<FrameNode*>(node);
515 CHECK_NULL_VOID(frameNode);
516 TextModelNG::SetAdaptMaxFontSize(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
517 NodeModifier::ProcessResourceObj<CalcDimension>(
518 frameNode, "AdaptMaxFontSize", Dimension(number, static_cast<DimensionUnit>(unit)), maxFontSizeRawPtr);
519 }
520
ResetTextMaxFontSize(ArkUINodeHandle node)521 void ResetTextMaxFontSize(ArkUINodeHandle node)
522 {
523 auto* frameNode = reinterpret_cast<FrameNode*>(node);
524 CHECK_NULL_VOID(frameNode);
525 TextModelNG::SetAdaptMaxFontSize(frameNode, DEFAULT_MAX_FONT_SIZE);
526 if (SystemProperties::ConfigChangePerform()) {
527 auto pattern = frameNode->GetPattern();
528 CHECK_NULL_VOID(pattern);
529 pattern->UnRegisterResource("AdaptMaxFontSize");
530 }
531 }
532
SetTextMinFontScale(ArkUINodeHandle node,ArkUI_Float32 number,void * minFontScaleRawPtr)533 void SetTextMinFontScale(ArkUINodeHandle node, ArkUI_Float32 number, void* minFontScaleRawPtr)
534 {
535 auto* frameNode = reinterpret_cast<FrameNode*>(node);
536 CHECK_NULL_VOID(frameNode);
537 TextModelNG::SetMinFontScale(frameNode, number);
538 NodeModifier::ProcessResourceObj<float>(frameNode, "MinFontScale", number, minFontScaleRawPtr);
539 }
540
ResetTextMinFontScale(ArkUINodeHandle node)541 void ResetTextMinFontScale(ArkUINodeHandle node)
542 {
543 auto* frameNode = reinterpret_cast<FrameNode*>(node);
544 CHECK_NULL_VOID(frameNode);
545 TextModelNG::SetMinFontScale(frameNode, DEFAULT_MIN_FONT_SCALE);
546 if (SystemProperties::ConfigChangePerform()) {
547 auto pattern = frameNode->GetPattern();
548 CHECK_NULL_VOID(pattern);
549 pattern->UnRegisterResource("MinFontScale");
550 }
551 }
552
SetTextMaxFontScale(ArkUINodeHandle node,ArkUI_Float32 number,void * maxFontScaleRawPtr)553 void SetTextMaxFontScale(ArkUINodeHandle node, ArkUI_Float32 number, void* maxFontScaleRawPtr)
554 {
555 auto* frameNode = reinterpret_cast<FrameNode*>(node);
556 CHECK_NULL_VOID(frameNode);
557 TextModelNG::SetMaxFontScale(frameNode, number);
558 NodeModifier::ProcessResourceObj<float>(frameNode, "MinFontScale", number, maxFontScaleRawPtr);
559 }
560
ResetTextMaxFontScale(ArkUINodeHandle node)561 void ResetTextMaxFontScale(ArkUINodeHandle node)
562 {
563 auto* frameNode = reinterpret_cast<FrameNode*>(node);
564 CHECK_NULL_VOID(frameNode);
565 TextModelNG::SetMaxFontScale(frameNode, DEFAULT_MAX_FONT_SCALE);
566 if (SystemProperties::ConfigChangePerform()) {
567 auto pattern = frameNode->GetPattern();
568 CHECK_NULL_VOID(pattern);
569 pattern->UnRegisterResource("MaxFontScale");
570 }
571 }
572
SetTextFontFamily(ArkUINodeHandle node,const char ** fontFamilies,ArkUI_Uint32 length,void * fontFamilyRawPtr)573 void SetTextFontFamily(ArkUINodeHandle node, const char** fontFamilies, ArkUI_Uint32 length, void* fontFamilyRawPtr)
574 {
575 CHECK_NULL_VOID(fontFamilies);
576 if (length <= 0) {
577 return;
578 }
579 auto* frameNode = reinterpret_cast<FrameNode*>(node);
580 CHECK_NULL_VOID(frameNode);
581 std::vector<std::string> families;
582 for (uint32_t i = 0; i < length; i++) {
583 const char* family = *(fontFamilies + i);
584 if (family != nullptr) {
585 families.emplace_back(std::string(family));
586 }
587 }
588 TextModelNG::SetFontFamily(frameNode, families);
589 NodeModifier::ProcessResourceObj<std::vector<std::string>>(frameNode, "FontFamily", families, fontFamilyRawPtr);
590 }
591
ResetTextFontFamily(ArkUINodeHandle node)592 void ResetTextFontFamily(ArkUINodeHandle node)
593 {
594 auto* frameNode = reinterpret_cast<FrameNode*>(node);
595 CHECK_NULL_VOID(frameNode);
596 std::vector<std::string> families;
597 families.emplace_back(DEFAULT_FAMILY);
598 TextModelNG::SetFontFamily(frameNode, families);
599 if (SystemProperties::ConfigChangePerform()) {
600 auto pattern = frameNode->GetPattern();
601 CHECK_NULL_VOID(pattern);
602 pattern->UnRegisterResource("FontFamily");
603 }
604 }
605
SetTextCopyOption(ArkUINodeHandle node,ArkUI_Int32 copyOption)606 void SetTextCopyOption(ArkUINodeHandle node, ArkUI_Int32 copyOption)
607 {
608 auto* frameNode = reinterpret_cast<FrameNode*>(node);
609 CHECK_NULL_VOID(frameNode);
610 TextModelNG::SetCopyOption(frameNode, static_cast<CopyOptions>(copyOption));
611 }
612
ResetTextCopyOption(ArkUINodeHandle node)613 void ResetTextCopyOption(ArkUINodeHandle node)
614 {
615 auto* frameNode = reinterpret_cast<FrameNode*>(node);
616 CHECK_NULL_VOID(frameNode);
617 TextModelNG::SetCopyOption(frameNode, DEFAULT_COPY_OPTION);
618 }
619
SetTextTextShadow(ArkUINodeHandle node,struct ArkUITextShadowStruct * shadows,ArkUI_Uint32 length,const void * radiusResArrs,const void * colorResArrs,const void * offsetXResArrs,const void * offsetYResArrs)620 void SetTextTextShadow(ArkUINodeHandle node, struct ArkUITextShadowStruct* shadows, ArkUI_Uint32 length,
621 const void* radiusResArrs, const void* colorResArrs,
622 const void* offsetXResArrs, const void* offsetYResArrs)
623 {
624 CHECK_NULL_VOID(shadows);
625 auto* frameNode = reinterpret_cast<FrameNode*>(node);
626 CHECK_NULL_VOID(frameNode);
627 std::vector<Shadow> shadowList(length);
628 std::vector<RefPtr<ResourceObject>> radiusResArr;
629 std::vector<RefPtr<ResourceObject>> colorResArr;
630 std::vector<RefPtr<ResourceObject>> offsetXResArr;
631 std::vector<RefPtr<ResourceObject>> offsetYResArr;
632 if (SystemProperties::ConfigChangePerform()) {
633 if (radiusResArrs != nullptr) {
634 radiusResArr = *(static_cast<const std::vector<RefPtr<ResourceObject>>*>(radiusResArrs));
635 }
636 if (colorResArrs != nullptr) {
637 colorResArr =
638 *(static_cast<const std::vector<RefPtr<ResourceObject>>*>(colorResArrs));
639 }
640 if (offsetXResArrs != nullptr) {
641 offsetXResArr =
642 *(static_cast<const std::vector<RefPtr<ResourceObject>>*>(offsetXResArrs));
643 }
644 if (offsetYResArrs != nullptr) {
645 offsetYResArr =
646 *(static_cast<const std::vector<RefPtr<ResourceObject>>*>(offsetYResArrs));
647 }
648 }
649 for (uint32_t i = 0; i < length; i++) {
650 Shadow shadow;
651 ArkUITextShadowStruct* shadowStruct = shadows + i;
652 shadow.SetBlurRadius(shadowStruct->radius);
653 shadow.SetShadowType(static_cast<ShadowType>(shadowStruct->type));
654 shadow.SetColor(Color(shadowStruct->color));
655 shadow.SetOffsetX(shadowStruct->offsetX);
656 shadow.SetOffsetY(shadowStruct->offsetY);
657 shadow.SetIsFilled(static_cast<bool>(shadowStruct->fill));
658 if (SystemProperties::ConfigChangePerform()) {
659 RefPtr<ResourceObject> radiusObject = (radiusResArr.size() > i) ? radiusResArr[i] : nullptr;
660 RefPtr<ResourceObject> colorObject = (colorResArr.size() > i) ? colorResArr[i] : nullptr;
661 RefPtr<ResourceObject> offsetXObject = (offsetXResArr.size() > i) ? offsetXResArr[i] : nullptr;
662 RefPtr<ResourceObject> offsetYObject = (offsetYResArr.size() > i) ? offsetYResArr[i] : nullptr;
663 Shadow::RegisterShadowResourceObj(shadow, radiusObject, colorObject, offsetXObject, offsetYObject);
664 }
665 shadowList.at(i) = shadow;
666 }
667 TextModelNG::SetTextShadow(frameNode, shadowList);
668 }
669
GetTextShadowCount(ArkUINodeHandle node)670 ArkUI_Uint32 GetTextShadowCount(ArkUINodeHandle node)
671 {
672 auto* frameNode = reinterpret_cast<FrameNode*>(node);
673 CHECK_NULL_RETURN(frameNode, 0);
674 return TextModelNG::GetTextShadow(frameNode).size();
675 }
676
GetTextShadow(ArkUINodeHandle node,ArkUITextShadowStruct * shadow,uint32_t size)677 void GetTextShadow(ArkUINodeHandle node, ArkUITextShadowStruct* shadow, uint32_t size)
678 {
679 auto* frameNode = reinterpret_cast<FrameNode*>(node);
680 CHECK_NULL_VOID(frameNode);
681 std::vector<ArkUITextShadowStruct> shadowArray;
682 auto textShadowVector = TextModelNG::GetTextShadow(frameNode);
683 for (uint32_t i = 0; i < size; i++) {
684 if (i < textShadowVector.size()) {
685 *(shadow + i) = { static_cast<float>(textShadowVector[i].GetBlurRadius()),
686 static_cast<int32_t>(textShadowVector[i].GetShadowType()), textShadowVector[i].GetColor().GetValue(),
687 textShadowVector[i].GetOffset().GetX(), textShadowVector[i].GetOffset().GetY(),
688 textShadowVector[i].GetIsFilled() };
689 } else {
690 *(shadow + i) = { 0.0f, static_cast<int32_t>(ShadowType::COLOR), Color::TRANSPARENT.GetValue(), 0.0f, 0.0f,
691 0 };
692 }
693 }
694 }
695
ResetTextTextShadow(ArkUINodeHandle node)696 void ResetTextTextShadow(ArkUINodeHandle node)
697 {
698 auto* frameNode = reinterpret_cast<FrameNode*>(node);
699 CHECK_NULL_VOID(frameNode);
700 Shadow shadow;
701 shadow.SetOffsetX(0.0);
702 shadow.SetOffsetY(0.0);
703 TextModelNG::SetTextShadow(frameNode, std::vector<Shadow> { shadow });
704 }
705
SetTextHeightAdaptivePolicy(ArkUINodeHandle node,ArkUI_Int32 value)706 void SetTextHeightAdaptivePolicy(ArkUINodeHandle node, ArkUI_Int32 value)
707 {
708 auto* frameNode = reinterpret_cast<FrameNode*>(node);
709 CHECK_NULL_VOID(frameNode);
710 value = std::clamp(value, 0, static_cast<int32_t>(HEIGHT_ADAPTIVE_POLICY.size()));
711 TextModelNG::SetHeightAdaptivePolicy(frameNode, HEIGHT_ADAPTIVE_POLICY[value]);
712 }
713
ResetTextHeightAdaptivePolicy(ArkUINodeHandle node)714 void ResetTextHeightAdaptivePolicy(ArkUINodeHandle node)
715 {
716 auto* frameNode = reinterpret_cast<FrameNode*>(node);
717 CHECK_NULL_VOID(frameNode);
718 TextModelNG::SetHeightAdaptivePolicy(frameNode, TextHeightAdaptivePolicy::MAX_LINES_FIRST);
719 }
720
SetTextTextIndent(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit,void * textIndentRawPtr)721 void SetTextTextIndent(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit, void* textIndentRawPtr)
722 {
723 auto* frameNode = reinterpret_cast<FrameNode*>(node);
724 CHECK_NULL_VOID(frameNode);
725 TextModelNG::SetTextIndent(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
726 NodeModifier::ProcessResourceObj<CalcDimension>(
727 frameNode, "TextIndent", Dimension(number, static_cast<DimensionUnit>(unit)), textIndentRawPtr);
728 }
729
GetTextTextIndent(ArkUINodeHandle node)730 float GetTextTextIndent(ArkUINodeHandle node)
731 {
732 auto* frameNode = reinterpret_cast<FrameNode*>(node);
733 CHECK_NULL_RETURN(frameNode, 0.0f);
734 return TextModelNG::GetTextIndent(frameNode).ConvertToVp();
735 }
736
ResetTextTextIndent(ArkUINodeHandle node)737 void ResetTextTextIndent(ArkUINodeHandle node)
738 {
739 auto* frameNode = reinterpret_cast<FrameNode*>(node);
740 CHECK_NULL_VOID(frameNode);
741 TextModelNG::SetTextIndent(frameNode, CalcDimension(0, DimensionUnit::FP));
742 if (SystemProperties::ConfigChangePerform()) {
743 auto pattern = frameNode->GetPattern();
744 CHECK_NULL_VOID(pattern);
745 pattern->UnRegisterResource("TextIndent");
746 }
747 }
748
SetTextBaselineOffset(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit,void * baselineOffsetRawPtr)749 void SetTextBaselineOffset(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit, void* baselineOffsetRawPtr)
750 {
751 auto* frameNode = reinterpret_cast<FrameNode*>(node);
752 CHECK_NULL_VOID(frameNode);
753 TextModelNG::SetBaselineOffset(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
754 NodeModifier::ProcessResourceObj<CalcDimension>(
755 frameNode, "BaselineOffset", Dimension(number, static_cast<DimensionUnit>(unit)), baselineOffsetRawPtr);
756 }
757
ResetTextBaselineOffset(ArkUINodeHandle node)758 void ResetTextBaselineOffset(ArkUINodeHandle node)
759 {
760 auto* frameNode = reinterpret_cast<FrameNode*>(node);
761 CHECK_NULL_VOID(frameNode);
762 TextModelNG::SetBaselineOffset(frameNode, DEFAULT_BASELINE_OFFSET);
763 if (SystemProperties::ConfigChangePerform()) {
764 auto pattern = frameNode->GetPattern();
765 CHECK_NULL_VOID(pattern);
766 pattern->UnRegisterResource("BaselineOffset");
767 }
768 }
769
GetTextBaselineOffset(ArkUINodeHandle node)770 ArkUI_Float32 GetTextBaselineOffset(ArkUINodeHandle node)
771 {
772 auto* frameNode = reinterpret_cast<FrameNode*>(node);
773 CHECK_NULL_RETURN(frameNode, 0.0f);
774 return TextModelNG::GetTextBaselineOffset(frameNode).ConvertToVp();
775 }
776
SetTextLetterSpacing(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit,void * resObj)777 void SetTextLetterSpacing(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit, void* resObj)
778 {
779 auto* frameNode = reinterpret_cast<FrameNode*>(node);
780 CHECK_NULL_VOID(frameNode);
781 TextModelNG::SetLetterSpacing(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
782 NodeModifier::ProcessResourceObj<CalcDimension>(
783 frameNode, "LetterSpacing", Dimension(number, static_cast<DimensionUnit>(unit)), resObj);
784 }
785
GetTextLetterSpacing(ArkUINodeHandle node)786 ArkUI_Float32 GetTextLetterSpacing(ArkUINodeHandle node)
787 {
788 auto* frameNode = reinterpret_cast<FrameNode*>(node);
789 CHECK_NULL_RETURN(frameNode, 0.0f);
790 return TextModelNG::GetLetterSpacing(frameNode).ConvertToVp();
791 }
792
ResetTextLetterSpacing(ArkUINodeHandle node)793 void ResetTextLetterSpacing(ArkUINodeHandle node)
794 {
795 auto* frameNode = reinterpret_cast<FrameNode*>(node);
796 CHECK_NULL_VOID(frameNode);
797 CalcDimension letterSpacing(0.0, DimensionUnit::FP);
798 TextModelNG::SetLetterSpacing(frameNode, letterSpacing);
799 if (SystemProperties::ConfigChangePerform()) {
800 auto pattern = frameNode->GetPattern();
801 CHECK_NULL_VOID(pattern);
802 pattern->UnRegisterResource("LetterSpacing");
803 }
804 }
805
SetTextFont(ArkUINodeHandle node,const struct ArkUIFontWithOptionsStruct * fontInfo,void * fontSizeRawPtr,void * fontFamilyRawPtr)806 void SetTextFont(ArkUINodeHandle node, const struct ArkUIFontWithOptionsStruct* fontInfo,
807 void* fontSizeRawPtr, void* fontFamilyRawPtr)
808 {
809 CHECK_NULL_VOID(fontInfo);
810 auto* frameNode = reinterpret_cast<FrameNode*>(node);
811 CHECK_NULL_VOID(frameNode);
812 Font font;
813 font.fontSize = Dimension(fontInfo->fontSizeNumber, static_cast<DimensionUnit>(fontInfo->fontSizeUnit));
814 font.fontStyle = static_cast<Ace::FontStyle>(fontInfo->fontStyle);
815 font.fontWeight = static_cast<FontWeight>(fontInfo->fontWeight);
816 std::vector<std::string> families;
817 if (fontInfo->fontFamilies && fontInfo->familyLength > 0) {
818 if (fontInfo->familyLength > DEFAULT_MAX_FONT_FAMILY_LENGTH) {
819 return;
820 }
821 families.resize(fontInfo->familyLength);
822 for (uint32_t i = 0; i < fontInfo->familyLength; i++) {
823 families.at(i) = std::string(*(fontInfo->fontFamilies + i));
824 }
825 }
826 font.fontFamilies = families;
827 TextModelNG::SetFont(frameNode, font);
828 TextModelNG::SetVariableFontWeight(frameNode, fontInfo->variableFontWeight);
829 TextModelNG::SetEnableVariableFontWeight(frameNode, fontInfo->enableVariableFontWeight);
830 auto fontSizeValue = Dimension(fontInfo->fontSizeNumber, static_cast<DimensionUnit>(fontInfo->fontSizeUnit));
831 NodeModifier::ProcessResourceObj<CalcDimension>(frameNode, "FontSize", fontSizeValue, fontSizeRawPtr);
832 NodeModifier::ProcessResourceObj<std::vector<std::string>>(frameNode, "FontFamily", families, fontFamilyRawPtr);
833 }
834
ResetTextFont(ArkUINodeHandle node)835 void ResetTextFont(ArkUINodeHandle node)
836 {
837 auto* frameNode = reinterpret_cast<FrameNode*>(node);
838 CHECK_NULL_VOID(frameNode);
839 Font font;
840 font.fontSize = DEFAULT_FONT_SIZE;
841 font.fontWeight = DEFAULT_FONT_WEIGHT;
842 font.fontStyle = DEFAULT_FONT_STYLE;
843 std::vector<std::string> families;
844 families.emplace_back(DEFAULT_FAMILY);
845 font.fontFamilies = families;
846 TextModelNG::SetFont(frameNode, font);
847 TextModelNG::SetVariableFontWeight(frameNode, DEFAULT_VARIABLE_FONT_WEIGHT);
848 TextModelNG::SetEnableVariableFontWeight(frameNode, false);
849 if (SystemProperties::ConfigChangePerform()) {
850 auto pattern = frameNode->GetPattern();
851 CHECK_NULL_VOID(pattern);
852 pattern->UnRegisterResource("FontSize");
853 pattern->UnRegisterResource("FontFamily");
854 }
855 }
856
SetWordBreak(ArkUINodeHandle node,ArkUI_Uint32 wordBreak)857 void SetWordBreak(ArkUINodeHandle node, ArkUI_Uint32 wordBreak)
858 {
859 auto* frameNode = reinterpret_cast<FrameNode*>(node);
860 CHECK_NULL_VOID(frameNode);
861 if (wordBreak < 0 || wordBreak >= WORD_BREAK_TYPES.size()) {
862 wordBreak = 2; // 2 is the default value of WordBreak::BREAK_WORD
863 }
864 TextModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[wordBreak]);
865 }
866
ResetWordBreak(ArkUINodeHandle node)867 void ResetWordBreak(ArkUINodeHandle node)
868 {
869 auto* frameNode = reinterpret_cast<FrameNode*>(node);
870 CHECK_NULL_VOID(frameNode);
871 TextModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[2]); // 2 is the default value of WordBreak::BREAK_WORD
872 }
873
SetEllipsisMode(ArkUINodeHandle node,ArkUI_Uint32 ellipsisMode)874 void SetEllipsisMode(ArkUINodeHandle node, ArkUI_Uint32 ellipsisMode)
875 {
876 auto* frameNode = reinterpret_cast<FrameNode*>(node);
877 CHECK_NULL_VOID(frameNode);
878 if (ellipsisMode < 0 || ellipsisMode >= ELLIPSIS_MODALS.size()) {
879 ellipsisMode = 2; // 2 is the default value of EllipsisMode::TAIL
880 }
881 TextModelNG::SetEllipsisMode(frameNode, ELLIPSIS_MODALS[ellipsisMode]);
882 }
883
ResetEllipsisMode(ArkUINodeHandle node)884 void ResetEllipsisMode(ArkUINodeHandle node)
885 {
886 auto* frameNode = reinterpret_cast<FrameNode*>(node);
887 CHECK_NULL_VOID(frameNode);
888 TextModelNG::SetEllipsisMode(frameNode, ELLIPSIS_MODALS[2]); // 2 is the default value of EllipsisMode::TAIL
889 }
890
SetTextDetectEnable(ArkUINodeHandle node,ArkUI_Uint32 value)891 void SetTextDetectEnable(ArkUINodeHandle node, ArkUI_Uint32 value)
892 {
893 auto* frameNode = reinterpret_cast<FrameNode*>(node);
894 CHECK_NULL_VOID(frameNode);
895 TextModelNG::SetTextDetectEnable(frameNode, static_cast<bool>(value));
896 }
897
GetTextDetectEnable(ArkUINodeHandle node)898 ArkUI_Int32 GetTextDetectEnable(ArkUINodeHandle node)
899 {
900 auto* frameNode = reinterpret_cast<FrameNode*>(node);
901 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
902 return static_cast<ArkUI_Int32>(TextModelNG::GetTextDetectEnable(frameNode));
903 }
904
ResetTextDetectEnable(ArkUINodeHandle node)905 void ResetTextDetectEnable(ArkUINodeHandle node)
906 {
907 auto* frameNode = reinterpret_cast<FrameNode*>(node);
908 CHECK_NULL_VOID(frameNode);
909 TextModelNG::SetTextDetectEnable(frameNode, DEFAULT_ENABLE_TEXT_DETECTOR);
910 }
911
GetFontFamily(ArkUINodeHandle node)912 ArkUI_CharPtr GetFontFamily(ArkUINodeHandle node)
913 {
914 auto* frameNode = reinterpret_cast<FrameNode*>(node);
915 CHECK_NULL_RETURN(frameNode, nullptr);
916 std::vector<std::string> fontFamilies = TextModelNG::GetFontFamily(frameNode);
917 std::string families;
918 // set index start
919 uint32_t index = 0;
920 for (auto& family : fontFamilies) {
921 families += family;
922 if (index != fontFamilies.size() - 1) {
923 families += ",";
924 }
925 index++;
926 }
927 g_strValue = families;
928 return g_strValue.c_str();
929 }
930
GetCopyOption(ArkUINodeHandle node)931 ArkUI_Int32 GetCopyOption(ArkUINodeHandle node)
932 {
933 auto* frameNode = reinterpret_cast<FrameNode*>(node);
934 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
935 return static_cast<ArkUI_Int32>(TextModelNG::GetCopyOption(frameNode));
936 }
937
GetHeightAdaptivePolicy(ArkUINodeHandle node)938 ArkUI_Int32 GetHeightAdaptivePolicy(ArkUINodeHandle node)
939 {
940 auto* frameNode = reinterpret_cast<FrameNode*>(node);
941 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
942 return TEXT_HEIGHT_ADAPTIVE_POLICY_MAP[TextModelNG::GetHeightAdaptivePolicy(frameNode)];
943 }
944
GetTextMinFontSize(ArkUINodeHandle node)945 ArkUI_Float32 GetTextMinFontSize(ArkUINodeHandle node)
946 {
947 auto* frameNode = reinterpret_cast<FrameNode*>(node);
948 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
949 return static_cast<ArkUI_Float32>(TextModelNG::GetAdaptMinFontSize(frameNode).Value());
950 }
951
GetTextMaxFontSize(ArkUINodeHandle node)952 ArkUI_Float32 GetTextMaxFontSize(ArkUINodeHandle node)
953 {
954 auto* frameNode = reinterpret_cast<FrameNode*>(node);
955 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
956 return static_cast<ArkUI_Float32>(TextModelNG::GetAdaptMaxFontSize(frameNode).Value());
957 }
958
GetFont(ArkUINodeHandle node,ArkUITextFont * font)959 void GetFont(ArkUINodeHandle node, ArkUITextFont* font)
960 {
961 auto* frameNode = reinterpret_cast<FrameNode*>(node);
962 CHECK_NULL_VOID(frameNode);
963 Font value = TextModelNG::GetFont(frameNode);
964 if (value.fontSize.has_value()) {
965 font->fontSize = value.fontSize.value().GetNativeValue(static_cast<DimensionUnit>(font->fontSizeUnit));
966 }
967 if (value.fontWeight.has_value()) {
968 font->fontWeight = static_cast<ArkUI_Int32>(value.fontWeight.value());
969 }
970 if (!value.fontFamilies.empty()) {
971 std::string families;
972 // set index start
973 std::size_t index = 0;
974 for (auto& family : value.fontFamilies) {
975 families += family;
976 if (index != value.fontFamilies.size() - 1) {
977 families += ",";
978 }
979 index++;
980 }
981 g_strValue = families;
982 font->fontFamilies = g_strValue.c_str();
983 } else {
984 font->fontFamilies = "HarmonyOS Sans";
985 }
986 if (value.fontStyle.has_value()) {
987 font->fontStyle = static_cast<ArkUI_Int32>(value.fontStyle.value());
988 }
989 }
990
GetFontSize(ArkUINodeHandle node,ArkUI_Int32 unit)991 ArkUI_Float32 GetFontSize(ArkUINodeHandle node, ArkUI_Int32 unit)
992 {
993 auto* frameNode = reinterpret_cast<FrameNode*>(node);
994 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
995 return static_cast<ArkUI_Float32>(
996 TextModelNG::GetFontSize(frameNode).GetNativeValue(static_cast<DimensionUnit>(unit)));
997 }
998
GetFontWeight(ArkUINodeHandle node)999 ArkUI_Int32 GetFontWeight(ArkUINodeHandle node)
1000 {
1001 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1002 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1003 return static_cast<ArkUI_Int32>(TextModelNG::GetFontWeight(frameNode));
1004 }
1005
GetLineCount(ArkUINodeHandle node)1006 ArkUI_Int32 GetLineCount(ArkUINodeHandle node)
1007 {
1008 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1009 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1010 return static_cast<ArkUI_Int32>(TextModelNG::GetLineCount(frameNode));
1011 }
1012
GetItalicFontStyle(ArkUINodeHandle node)1013 ArkUI_Int32 GetItalicFontStyle(ArkUINodeHandle node)
1014 {
1015 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1016 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1017 return static_cast<ArkUI_Int32>(TextModelNG::GetItalicFontStyle(frameNode));
1018 }
1019
GetTextWordBreak(ArkUINodeHandle node)1020 ArkUI_Int32 GetTextWordBreak(ArkUINodeHandle node)
1021 {
1022 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1023 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1024 return static_cast<ArkUI_Int32>(TextModelNG::GetWordBreak(frameNode));
1025 }
1026
GetTextEllipsisMode(ArkUINodeHandle node)1027 ArkUI_Int32 GetTextEllipsisMode(ArkUINodeHandle node)
1028 {
1029 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1030 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1031 return static_cast<ArkUI_Int32>(TextModelNG::GetEllipsisMode(frameNode));
1032 }
1033
SetTextFontFeature(ArkUINodeHandle node,ArkUI_CharPtr value)1034 void SetTextFontFeature(ArkUINodeHandle node, ArkUI_CharPtr value)
1035 {
1036 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1037 CHECK_NULL_VOID(frameNode);
1038 std::string strValue = value;
1039 TextModelNG::SetFontFeature(frameNode, ParseFontFeatureSettings(strValue));
1040 }
1041
ResetTextFontFeature(ArkUINodeHandle node)1042 void ResetTextFontFeature(ArkUINodeHandle node)
1043 {
1044 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1045 CHECK_NULL_VOID(frameNode);
1046 std::string strValue = "";
1047 TextModelNG::SetFontFeature(frameNode, ParseFontFeatureSettings(strValue));
1048 }
1049
SetTextDataDetectorConfig(ArkUINodeHandle node,ArkUI_Uint32 * values,ArkUI_Int32 size)1050 void SetTextDataDetectorConfig(ArkUINodeHandle node, ArkUI_Uint32* values, ArkUI_Int32 size)
1051 {
1052 std::string textTypes;
1053 for (int i = 0; i < size; i++) {
1054 auto index = values[i];
1055 if (index < 0 || index >= TEXT_DETECT_TYPES.size()) {
1056 continue;
1057 }
1058 if (i != 0) {
1059 textTypes.append(",");
1060 }
1061 textTypes.append(TEXT_DETECT_TYPES[index]);
1062 }
1063 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1064 CHECK_NULL_VOID(frameNode);
1065 TextModelNG::SetTextDetectConfig(frameNode, textTypes);
1066 }
1067
GetTextDataDetectorConfig(ArkUINodeHandle node,ArkUI_Int32 (* values)[32])1068 ArkUI_Int32 GetTextDataDetectorConfig(ArkUINodeHandle node, ArkUI_Int32 (*values)[32])
1069 {
1070 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1071 CHECK_NULL_RETURN(frameNode, 0);
1072 auto typeString = TextModelNG::GetTextDetectConfig(frameNode);
1073 std::vector<std::string> types;
1074 StringUtils::StringSplitter(typeString, ',', types);
1075 for (uint32_t i = 0; i < types.size(); i++) {
1076 auto ret = std::find(TEXT_DETECT_TYPES.begin(), TEXT_DETECT_TYPES.end(), types[i]);
1077 (*values)[i] = ret != TEXT_DETECT_TYPES.end() ? ret - TEXT_DETECT_TYPES.begin() : -1;
1078 }
1079 return types.size();
1080 }
1081
ResetTextDataDetectorConfig(ArkUINodeHandle node)1082 void ResetTextDataDetectorConfig(ArkUINodeHandle node)
1083 {
1084 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1085 CHECK_NULL_VOID(frameNode);
1086 TextModelNG::SetTextDetectConfig(frameNode, "");
1087 }
1088
GetTextFontFeature(ArkUINodeHandle node)1089 ArkUI_CharPtr GetTextFontFeature(ArkUINodeHandle node)
1090 {
1091 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1092 CHECK_NULL_RETURN(frameNode, nullptr);
1093 g_strValue = UnParseFontFeatureSetting(TextModelNG::GetFontFeature(frameNode));
1094 return g_strValue.c_str();
1095 }
1096
SetTextLineSpacing(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit,ArkUI_Bool isOnlyBetweenLines,void * resObj)1097 void SetTextLineSpacing(
1098 ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit, ArkUI_Bool isOnlyBetweenLines, void* resObj)
1099 {
1100 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1101 CHECK_NULL_VOID(frameNode);
1102 TextModelNG::SetLineSpacing(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)), isOnlyBetweenLines);
1103 NodeModifier::ProcessResourceObj<CalcDimension>(
1104 frameNode, "LineSpacing", Dimension(number, static_cast<DimensionUnit>(unit)), resObj);
1105 }
1106
GetTextLineSpacing(ArkUINodeHandle node)1107 float GetTextLineSpacing(ArkUINodeHandle node)
1108 {
1109 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1110 CHECK_NULL_RETURN(frameNode, 0.0f);
1111 return TextModelNG::GetLineSpacing(frameNode);
1112 }
1113
ResetTextLineSpacing(ArkUINodeHandle node)1114 void ResetTextLineSpacing(ArkUINodeHandle node)
1115 {
1116 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1117 CHECK_NULL_VOID(frameNode);
1118 TextModelNG::SetLineSpacing(frameNode, DEFAULT_LINE_SPACING, false);
1119 if (SystemProperties::ConfigChangePerform()) {
1120 auto pattern = frameNode->GetPattern();
1121 CHECK_NULL_VOID(pattern);
1122 pattern->UnRegisterResource("LineSpacing");
1123 }
1124 }
1125
SetTextCaretColor(ArkUINodeHandle node,ArkUI_Uint32 color,void * caretColorRawPtr)1126 void SetTextCaretColor(ArkUINodeHandle node, ArkUI_Uint32 color, void* caretColorRawPtr)
1127 {
1128 auto* frameNode = reinterpret_cast<FrameNode *>(node);
1129 CHECK_NULL_VOID(frameNode);
1130 TextModelNG::SetCaretColor(frameNode, Color(color));
1131 NodeModifier::ProcessResourceObj<Color>(frameNode, "TextCaretColor", Color(color), caretColorRawPtr);
1132 }
1133
GetTextCaretColor(ArkUINodeHandle node)1134 ArkUI_Uint32 GetTextCaretColor(ArkUINodeHandle node)
1135 {
1136 auto* frameNode = reinterpret_cast<FrameNode *>(node);
1137 CHECK_NULL_RETURN(frameNode, Color::BLACK.GetValue());
1138 return TextModelNG::GetCaretColor(frameNode).GetValue();
1139 }
1140
ResetTextCaretColor(ArkUINodeHandle node)1141 void ResetTextCaretColor(ArkUINodeHandle node)
1142 {
1143 auto* frameNode = reinterpret_cast<FrameNode *>(node);
1144 CHECK_NULL_VOID(frameNode);
1145 auto pipeline = frameNode->GetContext();
1146 CHECK_NULL_VOID(pipeline);
1147 auto theme = pipeline->GetThemeManager()->GetTheme<TextTheme>();
1148 CHECK_NULL_VOID(theme);
1149 auto caretColor = static_cast<int32_t>(theme->GetCaretColor().GetValue());
1150 TextModelNG::SetCaretColor(frameNode, Color(caretColor));
1151 if (SystemProperties::ConfigChangePerform()) {
1152 auto pattern = frameNode->GetPattern();
1153 CHECK_NULL_VOID(pattern);
1154 pattern->UnRegisterResource("TextCaretColor");
1155 }
1156 }
1157
SetTextSelectedBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color,void * selectedBackgroundColorRawPtr)1158 void SetTextSelectedBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color, void* selectedBackgroundColorRawPtr)
1159 {
1160 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1161 CHECK_NULL_VOID(frameNode);
1162 TextModelNG::SetSelectedBackgroundColor(frameNode, Color(color));
1163 NodeModifier::ProcessResourceObj<Color>(
1164 frameNode, "SelectedBackgroundColor", Color(color), selectedBackgroundColorRawPtr);
1165 }
1166
GetTextSelectedBackgroundColor(ArkUINodeHandle node)1167 ArkUI_Uint32 GetTextSelectedBackgroundColor(ArkUINodeHandle node)
1168 {
1169 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1170 CHECK_NULL_RETURN(frameNode, Color::BLACK.GetValue());
1171 return TextModelNG::GetSelectedBackgroundColor(frameNode).GetValue();
1172 }
1173
ResetTextSelectedBackgroundColor(ArkUINodeHandle node)1174 void ResetTextSelectedBackgroundColor(ArkUINodeHandle node)
1175 {
1176 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1177 CHECK_NULL_VOID(frameNode);
1178 TextModelNG::ResetSelectedBackgroundColor(frameNode);
1179 if (SystemProperties::ConfigChangePerform()) {
1180 auto pattern = frameNode->GetPattern();
1181 CHECK_NULL_VOID(pattern);
1182 pattern->UnRegisterResource("SelectedBackgroundColor");
1183 }
1184 }
1185
SetLineBreakStrategy(ArkUINodeHandle node,ArkUI_Uint32 lineBreakStrategy)1186 void SetLineBreakStrategy(ArkUINodeHandle node, ArkUI_Uint32 lineBreakStrategy)
1187 {
1188 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1189 CHECK_NULL_VOID(frameNode);
1190 if (lineBreakStrategy < 0 || lineBreakStrategy >= LINE_BREAK_STRATEGY_TYPES.size()) {
1191 lineBreakStrategy = 0; // 0 is the default value of LineBreakStrategy::GREEDY
1192 }
1193 TextModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[lineBreakStrategy]);
1194 }
1195
ResetLineBreakStrategy(ArkUINodeHandle node)1196 void ResetLineBreakStrategy(ArkUINodeHandle node)
1197 {
1198 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1199 CHECK_NULL_VOID(frameNode);
1200 // 0 is the default value of LineBreakStrategy::GREEDY
1201 TextModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[0]);
1202 }
1203
GetTextLineBreakStrategy(ArkUINodeHandle node)1204 ArkUI_Int32 GetTextLineBreakStrategy(ArkUINodeHandle node)
1205 {
1206 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1207 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1208 return static_cast<ArkUI_Int32>(TextModelNG::GetLineBreakStrategy(frameNode));
1209 }
1210
SetTextContentWithStyledString(ArkUINodeHandle node,ArkUI_StyledString * styledString)1211 void SetTextContentWithStyledString(ArkUINodeHandle node, ArkUI_StyledString* styledString)
1212 {
1213 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1214 CHECK_NULL_VOID(frameNode);
1215 CHECK_NULL_VOID(styledString);
1216 TextModelNG::SetTextContentWithStyledString(frameNode, styledString);
1217 }
1218
ResetTextContentWithStyledString(ArkUINodeHandle node)1219 void ResetTextContentWithStyledString(ArkUINodeHandle node)
1220 {
1221 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1222 CHECK_NULL_VOID(frameNode);
1223 TextModelNG::SetTextContentWithStyledString(frameNode, nullptr);
1224 }
1225
SetTextSelection(ArkUINodeHandle node,int32_t startIndex,int32_t endIndex)1226 void SetTextSelection(ArkUINodeHandle node, int32_t startIndex, int32_t endIndex)
1227 {
1228 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1229 CHECK_NULL_VOID(frameNode);
1230 TextModelNG::SetTextSelection(frameNode, startIndex, endIndex);
1231 }
1232
ResetTextSelection(ArkUINodeHandle node)1233 void ResetTextSelection(ArkUINodeHandle node)
1234 {
1235 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1236 CHECK_NULL_VOID(frameNode);
1237 TextModelNG::SetTextSelection(frameNode, DEFAULT_SELECTION, DEFAULT_SELECTION);
1238 }
1239
SetTextSelectableMode(ArkUINodeHandle node,ArkUI_Uint32 textSelectableMode)1240 void SetTextSelectableMode(ArkUINodeHandle node, ArkUI_Uint32 textSelectableMode)
1241 {
1242 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1243 CHECK_NULL_VOID(frameNode);
1244 if (textSelectableMode < 0 || textSelectableMode >= TEXT_SELECTABLE_MODE.size()) {
1245 textSelectableMode = 0;
1246 }
1247 TextModelNG::SetTextSelectableMode(frameNode, TEXT_SELECTABLE_MODE[textSelectableMode]);
1248 }
1249
ResetTextSelectableMode(ArkUINodeHandle node)1250 void ResetTextSelectableMode(ArkUINodeHandle node)
1251 {
1252 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1253 CHECK_NULL_VOID(frameNode);
1254 TextModelNG::SetTextSelectableMode(frameNode, TEXT_SELECTABLE_MODE[0]);
1255 }
1256
SetTextDataDetectorConfigWithEvent(ArkUINodeHandle node,const struct ArkUITextDetectConfigStruct * arkUITextDetectConfig,void * entityColorRawPtr,void * entityDecorationColorRawPtr)1257 void SetTextDataDetectorConfigWithEvent(
1258 ArkUINodeHandle node, const struct ArkUITextDetectConfigStruct* arkUITextDetectConfig, void* entityColorRawPtr,
1259 void* entityDecorationColorRawPtr)
1260 {
1261 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1262 CHECK_NULL_VOID(frameNode);
1263 TextDetectConfig textDetectConfig;
1264 textDetectConfig.types = arkUITextDetectConfig->types;
1265 if (arkUITextDetectConfig->onResult) {
1266 textDetectConfig.onResult =
1267 std::move(*(reinterpret_cast<std::function<void(const std::string&)>*>(arkUITextDetectConfig->onResult)));
1268 }
1269 textDetectConfig.entityColor = Color(arkUITextDetectConfig->entityColor);
1270 textDetectConfig.entityDecorationType = TextDecoration(arkUITextDetectConfig->entityDecorationType);
1271 textDetectConfig.entityDecorationColor = Color(arkUITextDetectConfig->entityDecorationColor);
1272 textDetectConfig.entityDecorationStyle = TextDecorationStyle(arkUITextDetectConfig->entityDecorationStyle);
1273 textDetectConfig.enablePreviewMenu = arkUITextDetectConfig->entityEnablePreviewMenu;
1274 if (SystemProperties::ConfigChangePerform()) {
1275 if (entityColorRawPtr) {
1276 auto resObj = AceType::Claim(reinterpret_cast<ResourceObject*>(entityColorRawPtr));
1277 TextDetectConfig::RegisterColorResource(textDetectConfig, resObj);
1278 }
1279 if (entityDecorationColorRawPtr) {
1280 auto resObj = AceType::Claim(reinterpret_cast<ResourceObject*>(entityDecorationColorRawPtr));
1281 TextDetectConfig::RegisterDecoColorResource(textDetectConfig, resObj);
1282 }
1283 }
1284 TextModelNG::SetTextDetectConfig(frameNode, textDetectConfig);
1285 }
1286
ResetTextDataDetectorConfigWithEvent(ArkUINodeHandle node)1287 void ResetTextDataDetectorConfigWithEvent(ArkUINodeHandle node)
1288 {
1289 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1290 CHECK_NULL_VOID(frameNode);
1291 TextDetectConfig textDetectConfig;
1292 TextModelNG::SetTextDetectConfig(frameNode, textDetectConfig);
1293 if (SystemProperties::ConfigChangePerform()) {
1294 auto pattern = frameNode->GetPattern();
1295 CHECK_NULL_VOID(pattern);
1296 pattern->UnRegisterResource("dataDetectorConfig");
1297 }
1298 }
1299
SetTextOnCopy(ArkUINodeHandle node,void * callback)1300 void SetTextOnCopy(ArkUINodeHandle node, void* callback)
1301 {
1302 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1303 CHECK_NULL_VOID(frameNode);
1304 if (callback) {
1305 auto onCopy = reinterpret_cast<std::function<void(const std::u16string&)>*>(callback);
1306 TextModelNG::SetOnCopy(frameNode, std::move(*onCopy));
1307 } else {
1308 TextModelNG::SetOnCopy(frameNode, nullptr);
1309 }
1310 }
1311
ResetTextOnCopy(ArkUINodeHandle node)1312 void ResetTextOnCopy(ArkUINodeHandle node)
1313 {
1314 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1315 CHECK_NULL_VOID(frameNode);
1316 TextModelNG::SetOnCopy(frameNode, nullptr);
1317 }
1318
SetTextOnTextSelectionChange(ArkUINodeHandle node,void * callback)1319 void SetTextOnTextSelectionChange(ArkUINodeHandle node, void* callback)
1320 {
1321 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1322 CHECK_NULL_VOID(frameNode);
1323 if (callback) {
1324 auto onChange = reinterpret_cast<std::function<void(int32_t, int32_t)>*>(callback);
1325 TextModelNG::SetOnTextSelectionChange(frameNode, std::move(*onChange));
1326 } else {
1327 TextModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1328 }
1329 }
1330
ResetTextOnTextSelectionChange(ArkUINodeHandle node)1331 void ResetTextOnTextSelectionChange(ArkUINodeHandle node)
1332 {
1333 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1334 CHECK_NULL_VOID(frameNode);
1335 TextModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1336 }
1337
SetTextSelectionMenuOptions(ArkUINodeHandle node,void * onCreateMenuCallback,void * onMenuItemClickCallback,void * onPrepareMenuCallback)1338 void SetTextSelectionMenuOptions(
1339 ArkUINodeHandle node, void* onCreateMenuCallback, void* onMenuItemClickCallback, void* onPrepareMenuCallback)
1340 {
1341 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1342 CHECK_NULL_VOID(frameNode);
1343 if (onCreateMenuCallback) {
1344 NG::OnCreateMenuCallback onCreateMenu = *(reinterpret_cast<NG::OnCreateMenuCallback*>(onCreateMenuCallback));
1345 TextModelNG::OnCreateMenuCallbackUpdate(frameNode, std::move(onCreateMenu));
1346 } else {
1347 TextModelNG::OnCreateMenuCallbackUpdate(frameNode, nullptr);
1348 }
1349 if (onMenuItemClickCallback) {
1350 NG::OnMenuItemClickCallback onMenuItemClick =
1351 *(reinterpret_cast<NG::OnMenuItemClickCallback*>(onMenuItemClickCallback));
1352 TextModelNG::OnMenuItemClickCallbackUpdate(frameNode, std::move(onMenuItemClick));
1353 } else {
1354 TextModelNG::OnMenuItemClickCallbackUpdate(frameNode, nullptr);
1355 }
1356 if (onPrepareMenuCallback) {
1357 NG::OnPrepareMenuCallback onPrepareMenu =
1358 *(reinterpret_cast<NG::OnPrepareMenuCallback*>(onPrepareMenuCallback));
1359 TextModelNG::OnPrepareMenuCallbackUpdate(frameNode, std::move(onPrepareMenu));
1360 } else {
1361 TextModelNG::OnPrepareMenuCallbackUpdate(frameNode, nullptr);
1362 }
1363 }
1364
SetTextSelectionMenuOptionsForCJ(ArkUINodeHandle node,void * onCreateMenuCallback,void * onMenuItemClickCallback)1365 void SetTextSelectionMenuOptionsForCJ(ArkUINodeHandle node, void* onCreateMenuCallback, void* onMenuItemClickCallback)
1366 {
1367 SetTextSelectionMenuOptions(node, onCreateMenuCallback, onMenuItemClickCallback, nullptr);
1368 }
1369
ResetTextSelectionMenuOptions(ArkUINodeHandle node)1370 void ResetTextSelectionMenuOptions(ArkUINodeHandle node)
1371 {
1372 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1373 CHECK_NULL_VOID(frameNode);
1374 NG::OnCreateMenuCallback onCreateMenuCallback;
1375 NG::OnMenuItemClickCallback onMenuItemClick;
1376 NG::OnPrepareMenuCallback onPrepareMenuCallback;
1377 TextModelNG::OnCreateMenuCallbackUpdate(frameNode, std::move(onCreateMenuCallback));
1378 TextModelNG::OnMenuItemClickCallbackUpdate(frameNode, std::move(onMenuItemClick));
1379 TextModelNG::OnPrepareMenuCallbackUpdate(frameNode, std::move(onPrepareMenuCallback));
1380 }
1381
SetTextHalfLeading(ArkUINodeHandle node,ArkUI_Bool value)1382 void SetTextHalfLeading(ArkUINodeHandle node, ArkUI_Bool value)
1383 {
1384 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1385 CHECK_NULL_VOID(frameNode);
1386 TextModelNG::SetHalfLeading(frameNode, value);
1387 }
1388
ResetTextHalfLeading(ArkUINodeHandle node)1389 void ResetTextHalfLeading(ArkUINodeHandle node)
1390 {
1391 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1392 CHECK_NULL_VOID(frameNode);
1393 TextModelNG::SetHalfLeading(frameNode, false);
1394 }
1395
GetTextHalfLeading(ArkUINodeHandle node)1396 ArkUI_Int32 GetTextHalfLeading(ArkUINodeHandle node)
1397 {
1398 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1399 CHECK_NULL_RETURN(frameNode, false);
1400 return static_cast<ArkUI_Int32>(TextModelNG::GetHalfLeading(frameNode));
1401 }
1402
SetTextEnableHapticFeedback(ArkUINodeHandle node,ArkUI_Uint32 value)1403 void SetTextEnableHapticFeedback(ArkUINodeHandle node, ArkUI_Uint32 value)
1404 {
1405 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1406 CHECK_NULL_VOID(frameNode);
1407 TextModelNG::SetEnableHapticFeedback(frameNode, static_cast<bool>(value));
1408 }
1409
ResetTextEnableHapticFeedback(ArkUINodeHandle node)1410 void ResetTextEnableHapticFeedback(ArkUINodeHandle node)
1411 {
1412 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1413 CHECK_NULL_VOID(frameNode);
1414 TextModelNG::SetEnableHapticFeedback(frameNode, DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE);
1415 }
1416
SetMarqueeOptions(ArkUINodeHandle node,struct ArkUITextMarqueeOptions * value)1417 void SetMarqueeOptions(ArkUINodeHandle node, struct ArkUITextMarqueeOptions* value)
1418 {
1419 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1420 CHECK_NULL_VOID(frameNode);
1421
1422 TextMarqueeOptions marqueeOptions;
1423 marqueeOptions.UpdateTextMarqueeStart(value->start);
1424 marqueeOptions.UpdateTextMarqueeStep(value->step);
1425 marqueeOptions.UpdateTextMarqueeLoop(value->loop);
1426 marqueeOptions.UpdateTextMarqueeDirection(value->fromStart ? MarqueeDirection::LEFT : MarqueeDirection::RIGHT);
1427 marqueeOptions.UpdateTextMarqueeDelay(value->delay);
1428 marqueeOptions.UpdateTextMarqueeFadeout(value->fadeout);
1429 marqueeOptions.UpdateTextMarqueeStartPolicy(static_cast<MarqueeStartPolicy>(value->marqueeStartPolicy));
1430
1431 TextModelNG::SetMarqueeOptions(frameNode, marqueeOptions);
1432 }
1433
ResetMarqueeOptions(ArkUINodeHandle node)1434 void ResetMarqueeOptions(ArkUINodeHandle node)
1435 {
1436 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1437 CHECK_NULL_VOID(frameNode);
1438 TextMarqueeOptions marqueeOptions;
1439 TextModelNG::SetMarqueeOptions(frameNode, marqueeOptions);
1440 }
1441
SetOnMarqueeStateChange(ArkUINodeHandle node,void * callback)1442 void SetOnMarqueeStateChange(ArkUINodeHandle node, void* callback)
1443 {
1444 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1445 CHECK_NULL_VOID(frameNode);
1446 if (callback) {
1447 auto onChange = reinterpret_cast<std::function<void(int32_t)>*>(callback);
1448 TextModelNG::SetOnMarqueeStateChange(frameNode, std::move(*onChange));
1449 } else {
1450 TextModelNG::SetOnMarqueeStateChange(frameNode, nullptr);
1451 }
1452 }
1453
ResetOnMarqueeStateChange(ArkUINodeHandle node)1454 void ResetOnMarqueeStateChange(ArkUINodeHandle node)
1455 {
1456 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1457 CHECK_NULL_VOID(frameNode);
1458 TextModelNG::SetOnMarqueeStateChange(frameNode, nullptr);
1459 }
1460
SetTextOptimizeTrailingSpace(ArkUINodeHandle node,ArkUI_Bool trim)1461 void SetTextOptimizeTrailingSpace(ArkUINodeHandle node, ArkUI_Bool trim)
1462 {
1463 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1464 CHECK_NULL_VOID(frameNode);
1465 TextModelNG::SetOptimizeTrailingSpace(frameNode, trim);
1466 }
1467
GetTextOptimizeTrailingSpace(ArkUINodeHandle node)1468 ArkUI_Int32 GetTextOptimizeTrailingSpace(ArkUINodeHandle node)
1469 {
1470 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1471 CHECK_NULL_RETURN(frameNode, false);
1472 return static_cast<ArkUI_Int32>(TextModelNG::GetOptimizeTrailingSpace(frameNode));
1473 }
1474
ResetTextOptimizeTrailingSpace(ArkUINodeHandle node)1475 void ResetTextOptimizeTrailingSpace(ArkUINodeHandle node)
1476 {
1477 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1478 CHECK_NULL_VOID(frameNode);
1479 TextModelNG::SetOptimizeTrailingSpace(frameNode, DEFAULT_TRIM_SPACE);
1480 }
1481
SetEnableAutoSpacing(ArkUINodeHandle node,ArkUI_Bool enableAutoSpacing)1482 void SetEnableAutoSpacing(ArkUINodeHandle node, ArkUI_Bool enableAutoSpacing)
1483 {
1484 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1485 CHECK_NULL_VOID(frameNode);
1486 TextModelNG::SetEnableAutoSpacing(frameNode, static_cast<bool>(enableAutoSpacing));
1487 }
1488
ResetEnableAutoSpacing(ArkUINodeHandle node)1489 void ResetEnableAutoSpacing(ArkUINodeHandle node)
1490 {
1491 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1492 CHECK_NULL_VOID(frameNode);
1493 TextModelNG::SetEnableAutoSpacing(frameNode, false);
1494 }
1495
SetLinearGradientDirectionTo(std::shared_ptr<LinearGradient> & linearGradient,const GradientDirection direction)1496 void SetLinearGradientDirectionTo(std::shared_ptr<LinearGradient>& linearGradient, const GradientDirection direction)
1497 {
1498 switch (direction) {
1499 case GradientDirection::LEFT:
1500 linearGradient->linearX = NG::GradientDirection::LEFT;
1501 break;
1502 case GradientDirection::RIGHT:
1503 linearGradient->linearX = NG::GradientDirection::RIGHT;
1504 break;
1505 case GradientDirection::TOP:
1506 linearGradient->linearY = NG::GradientDirection::TOP;
1507 break;
1508 case GradientDirection::BOTTOM:
1509 linearGradient->linearY = NG::GradientDirection::BOTTOM;
1510 break;
1511 case GradientDirection::LEFT_TOP:
1512 linearGradient->linearX = NG::GradientDirection::LEFT;
1513 linearGradient->linearY = NG::GradientDirection::TOP;
1514 break;
1515 case GradientDirection::LEFT_BOTTOM:
1516 linearGradient->linearX = NG::GradientDirection::LEFT;
1517 linearGradient->linearY = NG::GradientDirection::BOTTOM;
1518 break;
1519 case GradientDirection::RIGHT_TOP:
1520 linearGradient->linearX = NG::GradientDirection::RIGHT;
1521 linearGradient->linearY = NG::GradientDirection::TOP;
1522 break;
1523 case GradientDirection::RIGHT_BOTTOM:
1524 linearGradient->linearX = NG::GradientDirection::RIGHT;
1525 linearGradient->linearY = NG::GradientDirection::BOTTOM;
1526 break;
1527 case GradientDirection::NONE:
1528 case GradientDirection::START_TO_END:
1529 case GradientDirection::END_TO_START:
1530 default:
1531 break;
1532 }
1533 }
1534
ConvertToLinearGradientDirection(std::shared_ptr<LinearGradient> linearGradient)1535 GradientDirection ConvertToLinearGradientDirection(std::shared_ptr<LinearGradient> linearGradient)
1536 {
1537 auto linearX = linearGradient->linearX;
1538 auto linearY = linearGradient->linearY;
1539 if (!linearX.has_value() && !linearY.has_value()) {
1540 return GradientDirection::BOTTOM;
1541 }
1542 if (linearX.has_value() && !linearY.has_value()) {
1543 return linearX.value();
1544 }
1545 if (!linearX.has_value() && linearY.has_value()) {
1546 return linearY.value();
1547 }
1548
1549 if (linearX.value() == NG::GradientDirection::LEFT && linearY.value() == NG::GradientDirection::TOP) {
1550 return GradientDirection::LEFT_TOP;
1551 }
1552 if (linearX.value() == NG::GradientDirection::LEFT && linearY.value() == NG::GradientDirection::BOTTOM) {
1553 return GradientDirection::LEFT_BOTTOM;
1554 }
1555 if (linearX.value() == NG::GradientDirection::RIGHT && linearY.value() == NG::GradientDirection::TOP) {
1556 return GradientDirection::RIGHT_TOP;
1557 }
1558 if (linearX.value() == NG::GradientDirection::RIGHT && linearY.value() == NG::GradientDirection::BOTTOM) {
1559 return GradientDirection::RIGHT_BOTTOM;
1560 }
1561 return GradientDirection::BOTTOM;
1562 }
1563
1564 /**
1565 * @param values value value
1566 * values[0], values[1] : angle: hasValue, angle value
1567 * values[2] : direction
1568 * values[3] : repeating
1569 * @param valuesLength values length
1570 */
SetLinearGradientValues(NG::Gradient & gradient,const ArkUIInt32orFloat32 * values,ArkUI_Int32 valuesLength)1571 void SetLinearGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength)
1572 {
1573 if ((values == nullptr) || (valuesLength != NUM_4)) {
1574 return;
1575 }
1576 auto angleHasValue = values[NUM_0].i32;
1577 auto angleValue = values[NUM_1].f32;
1578 auto directionValue = values[NUM_2].i32;
1579 auto repeating = values[NUM_3].i32;
1580 auto linearGradient = gradient.GetLinearGradient();
1581 if (linearGradient == nullptr) {
1582 return;
1583 }
1584 if (static_cast<bool>(angleHasValue)) {
1585 linearGradient->angle = CalcDimension(angleValue, DimensionUnit::PX);
1586 }
1587 SetLinearGradientDirectionTo(linearGradient, static_cast<GradientDirection>(directionValue));
1588 gradient.SetRepeat(static_cast<bool>(repeating));
1589 }
1590
1591 /**
1592 * @param values value value
1593 * values[0], values[1], values[2] : centerX Dimension: hasValue, value, unit
1594 * values[3], values[4], values[5] : centerY Dimension: hasValue, value, unit
1595 * values[6], values[7], values[8] : radius: Dimension: hasValue, value, unit
1596 * values[9] : repeating
1597 * @param valuesLength values length
1598 */
SetRadialGradientValues(NG::Gradient & gradient,const ArkUIInt32orFloat32 * values,ArkUI_Int32 valuesLength)1599 void SetRadialGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength)
1600 {
1601 if ((values == nullptr) || (valuesLength != NUM_10)) {
1602 return;
1603 }
1604
1605 auto centerXHasValue = values[NUM_0].i32;
1606 auto centerXValue = values[NUM_1].f32;
1607 auto centerXUnit = values[NUM_2].i32;
1608 auto centerYHasValue = values[NUM_3].i32;
1609 auto centerYValue = values[NUM_4].f32;
1610 auto centerYUnit = values[NUM_5].i32;
1611 auto radiusHasValue = values[NUM_6].i32;
1612 auto radiusValue = values[NUM_7].f32;
1613 auto radiusUnit = values[NUM_8].i32;
1614 auto repeating = values[NUM_9].i32;
1615
1616 if (static_cast<bool>(centerXHasValue)) {
1617 auto unit = static_cast<DimensionUnit>(centerXUnit);
1618 auto value = (unit == DimensionUnit::PERCENT) ? (centerXValue * PERCENT_100) : centerXValue;
1619 gradient.GetRadialGradient()->radialCenterX = CalcDimension(value, unit);
1620 }
1621 if (static_cast<bool>(centerYHasValue)) {
1622 auto unit = static_cast<DimensionUnit>(centerYUnit);
1623 auto value = (unit == DimensionUnit::PERCENT) ? (centerYValue * PERCENT_100) : centerYValue;
1624 gradient.GetRadialGradient()->radialCenterY = CalcDimension(value, unit);
1625 }
1626 if (static_cast<bool>(radiusHasValue)) {
1627 auto unit = static_cast<DimensionUnit>(radiusUnit);
1628 auto value = static_cast<float>(radiusValue);
1629 gradient.GetRadialGradient()->radialVerticalSize = CalcDimension(value, unit);
1630 gradient.GetRadialGradient()->radialHorizontalSize = CalcDimension(value, unit);
1631 }
1632 gradient.SetRepeat(static_cast<bool>(repeating));
1633 }
1634
1635 /**
1636 * @param colors color value
1637 * colors[0], colors[1], colors[2] : color[0](color, hasDimension, dimension)
1638 * colors[3], colors[4], colors[5] : color[1](color, hasDimension, dimension)
1639 * ...
1640 * @param colorsLength colors length
1641 */
SetGradientColors(NG::Gradient & gradient,const ArkUIInt32orFloat32 * colors,ArkUI_Int32 colorsLength)1642 void SetGradientColors(NG::Gradient& gradient, const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength)
1643 {
1644 if ((colors == nullptr) || (colorsLength % NUM_3) != 0) {
1645 return;
1646 }
1647 for (int32_t index = 0; index < colorsLength; index += NUM_3) {
1648 auto colorValue = colors[index].u32;
1649 auto colorHasDimension = colors[index + NUM_1].i32;
1650 auto colorDimension = colors[index + NUM_2].f32;
1651 auto color = static_cast<uint32_t>(colorValue);
1652 auto hasDimension = static_cast<bool>(colorHasDimension);
1653 auto dimension = colorDimension;
1654 NG::GradientColor gradientColor;
1655 gradientColor.SetColor(Color(color));
1656 gradientColor.SetHasValue(hasDimension);
1657 if (hasDimension) {
1658 gradientColor.SetDimension(CalcDimension(dimension * PERCENT_100, DimensionUnit::PERCENT));
1659 }
1660 gradient.AddColor(gradientColor);
1661 }
1662 }
1663
1664 /**
1665 * @param values value value
1666 * values[0], values[1] : angle: hasValue, angle value
1667 * values[2] : direction
1668 * values[3] : repeating
1669 * @param valuesLength values length
1670 * @param colors color value
1671 * colors[0], colors[1], colors[2] : color[0](color, hasDimension, dimension)
1672 * colors[3], colors[4], colors[5] : color[1](color, hasDimension, dimension)
1673 * ...
1674 * @param colorsLength colors length
1675 */
SetTextLinearGradient(ArkUINodeHandle node,const ArkUIInt32orFloat32 * values,ArkUI_Int32 valuesLength,const ArkUIInt32orFloat32 * colors,ArkUI_Int32 colorsLength)1676 void SetTextLinearGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength,
1677 const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength)
1678 {
1679 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1680 CHECK_NULL_VOID(frameNode);
1681 if ((values == nullptr) || (valuesLength != NUM_4) || ((colorsLength % NUM_3) != 0)) {
1682 return;
1683 }
1684 NG::Gradient gradient;
1685 gradient.CreateGradientWithType(NG::GradientType::LINEAR);
1686 SetLinearGradientValues(gradient, values, valuesLength);
1687 SetGradientColors(gradient, colors, colorsLength);
1688 TextModelNG::SetGradientStyle(frameNode, gradient);
1689 }
1690
GetTextLinearGradient(ArkUINodeHandle node,ArkUI_Float32 (* values)[3],ArkUI_Uint32 (* colors)[10],ArkUI_Float32 (* stop)[10])1691 ArkUI_Int32 GetTextLinearGradient(
1692 ArkUINodeHandle node, ArkUI_Float32 (*values)[3], ArkUI_Uint32 (*colors)[10], ArkUI_Float32 (*stop)[10])
1693 {
1694 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1695 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1696 auto gradient = TextModelNG::GetGradientStyle(frameNode);
1697 auto angle = gradient.GetLinearGradient()->angle;
1698 //0 angle
1699 (*values)[0] = angle.has_value() ? angle.value().Value() : DEFAULT_ANGLE;
1700 //1 Direction
1701 (*values)[1] = static_cast<int32_t>(ConvertToLinearGradientDirection(gradient.GetLinearGradient()));
1702 //2 Repeat
1703 (*values)[2] = gradient.GetRepeat();
1704
1705 std::vector<GradientColor> gradientColors = gradient.GetColors();
1706 //0 start index
1707 int index = 0;
1708 for (auto& gradientColor : gradientColors) {
1709 if (index >= NUM_10) {
1710 break;
1711 }
1712 (*colors)[index] = gradientColor.GetColor().GetValue();
1713 (*stop)[index] = gradientColor.GetDimension().Value();
1714 index++;
1715 }
1716 return index;
1717 }
1718
1719 /**
1720 * @param values value value
1721 * values[0], values[1], values[2] : centerX Dimension: hasValue, value, unit
1722 * values[3], values[4], values[5] : centerY Dimension: hasValue, value, unit
1723 * values[6], values[7], values[8] : radius: Dimension: hasValue, value, unit
1724 * values[9] : repeating
1725 * @param valuesLength values length
1726 * @param colors color value
1727 * colors[0], colors[1], colors[2] : color[0](color, hasDimension, dimension)
1728 * colors[3], colors[4], colors[5] : color[1](color, hasDimension, dimension)
1729 * ...
1730 * @param colorsLength colors length
1731 */
SetTextRadialGradient(ArkUINodeHandle node,const ArkUIInt32orFloat32 * values,ArkUI_Int32 valuesLength,const ArkUIInt32orFloat32 * colors,ArkUI_Int32 colorsLength)1732 void SetTextRadialGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength,
1733 const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength)
1734 {
1735 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1736 CHECK_NULL_VOID(frameNode);
1737 if ((values == nullptr) || (valuesLength != NUM_10) || ((colorsLength % NUM_3) != 0)) {
1738 return;
1739 }
1740 NG::Gradient gradient;
1741 gradient.CreateGradientWithType(NG::GradientType::RADIAL);
1742 SetRadialGradientValues(gradient, values, valuesLength);
1743 SetGradientColors(gradient, colors, colorsLength);
1744 TextModelNG::SetGradientStyle(frameNode, gradient);
1745 }
1746
ResetTextGradient(ArkUINodeHandle node)1747 void ResetTextGradient(ArkUINodeHandle node)
1748 {
1749 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1750 CHECK_NULL_VOID(frameNode);
1751 TextModelNG::ResetTextGradient(frameNode);
1752 }
1753
GetTextRadialGradient(ArkUINodeHandle node,ArkUI_Float32 (* values)[4],ArkUI_Uint32 (* colors)[10],ArkUI_Float32 (* stops)[10],ArkUI_Int32 unit)1754 ArkUI_Int32 GetTextRadialGradient(ArkUINodeHandle node, ArkUI_Float32 (*values)[4], ArkUI_Uint32 (*colors)[10],
1755 ArkUI_Float32 (*stops)[10], ArkUI_Int32 unit)
1756 {
1757 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1758 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1759 auto gradient = TextModelNG::GetGradientStyle(frameNode);
1760 auto radialGradient = gradient.GetRadialGradient();
1761
1762 CHECK_NULL_RETURN(radialGradient, ERROR_INT_CODE);
1763 (*values)[NUM_0] = radialGradient->radialCenterX->GetNativeValue(static_cast<DimensionUnit>(unit));
1764 (*values)[NUM_1] = radialGradient->radialCenterY->GetNativeValue(static_cast<DimensionUnit>(unit));
1765 (*values)[NUM_2] = radialGradient->radialHorizontalSize->GetNativeValue(static_cast<DimensionUnit>(unit));
1766 (*values)[NUM_3] = gradient.GetRepeat();
1767
1768 std::vector<GradientColor> gradientColors = gradient.GetColors();
1769 //0 start index
1770 int index = 0;
1771 for (auto& gradientColor : gradientColors) {
1772 if (index >= NUM_10) {
1773 break;
1774 }
1775 (*colors)[index] = gradientColor.GetColor().GetValue();
1776 (*stops)[index] = gradientColor.GetDimension().Value();
1777 index++;
1778 }
1779 return index;
1780 }
1781
SetColorShaderColor(ArkUINodeHandle node,ArkUI_Uint32 color)1782 void SetColorShaderColor(ArkUINodeHandle node, ArkUI_Uint32 color)
1783 {
1784 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1785 CHECK_NULL_VOID(frameNode);
1786 TextModelNG::SetColorShaderStyle(frameNode, Color(color));
1787 }
1788
SetTextVerticalAlign(ArkUINodeHandle node,ArkUI_Uint32 textVerticalAlign)1789 void SetTextVerticalAlign(ArkUINodeHandle node, ArkUI_Uint32 textVerticalAlign)
1790 {
1791 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1792 CHECK_NULL_VOID(frameNode);
1793 TextModelNG::SetTextVerticalAlign(frameNode, static_cast<TextVerticalAlign>(textVerticalAlign));
1794 }
1795
ResetTextVerticalAlign(ArkUINodeHandle node)1796 void ResetTextVerticalAlign(ArkUINodeHandle node)
1797 {
1798 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1799 CHECK_NULL_VOID(frameNode);
1800 TextModelNG::SetTextVerticalAlign(frameNode, TextVerticalAlign::BASELINE);
1801 }
1802
GetTextVerticalAlign(ArkUINodeHandle node)1803 ArkUI_Uint32 GetTextVerticalAlign(ArkUINodeHandle node)
1804 {
1805 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1806 CHECK_NULL_RETURN(frameNode, static_cast<uint32_t>(TextVerticalAlign::BASELINE));
1807 return static_cast<ArkUI_Uint32>(TextModelNG::GetTextVerticalAlign(frameNode));
1808 }
1809
SetTextContentTransition(ArkUINodeHandle node,ArkUI_Int32 flipDirection,ArkUI_Bool enableBlur)1810 void SetTextContentTransition(ArkUINodeHandle node, ArkUI_Int32 flipDirection, ArkUI_Bool enableBlur)
1811 {
1812 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1813 CHECK_NULL_VOID(frameNode);
1814 TextModelNG::SetContentTransition(frameNode, TextEffectStrategy::FLIP,
1815 static_cast<TextFlipDirection>(flipDirection), static_cast<bool>(enableBlur));
1816 }
1817
ResetTextContentTransition(ArkUINodeHandle node)1818 void ResetTextContentTransition(ArkUINodeHandle node)
1819 {
1820 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1821 CHECK_NULL_VOID(frameNode);
1822 TextModelNG::ResetContentTransition(frameNode);
1823 }
1824 } // namespace
1825
1826 namespace NodeModifier {
GetTextModifier()1827 const ArkUITextModifier* GetTextModifier()
1828 {
1829 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1830 static const ArkUITextModifier modifier = {
1831 .setContent = SetTextContent,
1832 .setFontWeight = SetFontWeight,
1833 .resetFontWeight = ResetFontWeight,
1834 .setFontStyle = SetFontStyle,
1835 .resetFontStyle = ResetFontStyle,
1836 .setTextAlign = SetTextAlign,
1837 .resetTextAlign = ResetTextAlign,
1838 .setFontColor = SetFontColor,
1839 .resetFontColor = ResetFontColor,
1840 .setTextForegroundColor = SetTextForegroundColor,
1841 .resetTextForegroundColor = ResetTextForegroundColor,
1842 .setFontSize = SetFontSize,
1843 .resetFontSize = ResetFontSize,
1844 .setTextLineHeight = SetTextLineHeight,
1845 .resetTextLineHeight = ResetTextLineHeight,
1846 .setTextOverflow = SetTextTextOverflow,
1847 .resetTextOverflow = ResetTextTextOverflow,
1848 .setTextDecoration = SetTextDecoration,
1849 .resetTextDecoration = ResetTextDecoration,
1850 .setTextCase = SetTextTextCase,
1851 .resetTextCase = ResetTextTextCase,
1852 .setTextMaxLines = SetTextMaxLines,
1853 .resetTextMaxLines = ResetTextMaxLines,
1854 .setTextMinFontSize = SetTextMinFontSize,
1855 .resetTextMinFontSize = ResetTextMinFontSize,
1856 .setTextDraggable = SetTextDraggable,
1857 .resetTextDraggable = ResetTextDraggable,
1858 .setTextPrivacySensitive = SetTextPrivacySensitve,
1859 .resetTextPrivacySensitive = ResetTextPrivacySensitve,
1860 .setTextMaxFontSize = SetTextMaxFontSize,
1861 .resetTextMaxFontSize = ResetTextMaxFontSize,
1862 .setTextFontFamily = SetTextFontFamily,
1863 .resetTextFontFamily = ResetTextFontFamily,
1864 .setTextCopyOption = SetTextCopyOption,
1865 .resetTextCopyOption = ResetTextCopyOption,
1866 .setTextShadow = SetTextTextShadow,
1867 .resetTextShadow = ResetTextTextShadow,
1868 .setTextHeightAdaptivePolicy = SetTextHeightAdaptivePolicy,
1869 .resetTextHeightAdaptivePolicy = ResetTextHeightAdaptivePolicy,
1870 .setTextIndent = SetTextTextIndent,
1871 .resetTextIndent = ResetTextTextIndent,
1872 .setTextBaselineOffset = SetTextBaselineOffset,
1873 .resetTextBaselineOffset = ResetTextBaselineOffset,
1874 .setTextLetterSpacing = SetTextLetterSpacing,
1875 .resetTextLetterSpacing = ResetTextLetterSpacing,
1876 .setTextFont = SetTextFont,
1877 .resetTextFont = ResetTextFont,
1878 .setFontWeightStr = SetFontWeightStr,
1879 .setFontWeightWithOption = SetFontWeightWithOption,
1880 .setWordBreak = SetWordBreak,
1881 .resetWordBreak = ResetWordBreak,
1882 .getFontFamily = GetFontFamily,
1883 .getCopyOption = GetCopyOption,
1884 .getHeightAdaptivePolicy = GetHeightAdaptivePolicy,
1885 .getTextMinFontSize = GetTextMinFontSize,
1886 .getTextMaxFontSize = GetTextMaxFontSize,
1887 .getFont = GetFont,
1888 .getFontSize = GetFontSize,
1889 .getFontWeight = GetFontWeight,
1890 .getItalicFontStyle = GetItalicFontStyle,
1891 .setEllipsisMode = SetEllipsisMode,
1892 .resetEllipsisMode = ResetEllipsisMode,
1893 .setEnableDataDetector = SetTextDetectEnable,
1894 .resetEnableDataDetector = ResetTextDetectEnable,
1895 .getTextContent = GetTextContent,
1896 .getTextLineHeight = GetTextLineHeight,
1897 .getTextDecoration = GetTextDecoration,
1898 .getTextTextCase = GetTextTextCase,
1899 .getTextLetterSpacing = GetTextLetterSpacing,
1900 .getTextMaxLines = GetTextMaxLines,
1901 .getTextAlign = GetTextAlign,
1902 .getTextTextOverflow = GetTextTextOverflow,
1903 .getTextTextIndent = GetTextTextIndent,
1904 .getFontColor = GetFontColor,
1905 .getTextBaselineOffset = GetTextBaselineOffset,
1906 .getTextShadowsCount = GetTextShadowCount,
1907 .getTextShadows = GetTextShadow,
1908 .getTextWordBreak = GetTextWordBreak,
1909 .getTextEllipsisMode = GetTextEllipsisMode,
1910 .setTextFontFeature = SetTextFontFeature,
1911 .resetTextFontFeature = ResetTextFontFeature,
1912 .setTextLineSpacing = SetTextLineSpacing,
1913 .getTextLineSpacing = GetTextLineSpacing,
1914 .resetTextLineSpacing = ResetTextLineSpacing,
1915 .getTextFontFeature = GetTextFontFeature,
1916 .getEnableDataDetector = GetTextDetectEnable,
1917 .setTextDataDetectorConfig = SetTextDataDetectorConfig,
1918 .getTextDataDetectorConfig = GetTextDataDetectorConfig,
1919 .resetTextDataDetectorConfig = ResetTextDataDetectorConfig,
1920 .setLineBreakStrategy = SetLineBreakStrategy,
1921 .resetLineBreakStrategy = ResetLineBreakStrategy,
1922 .getTextLineBreakStrategy = GetTextLineBreakStrategy,
1923 .setTextCaretColor = SetTextCaretColor,
1924 .getTextCaretColor = GetTextCaretColor,
1925 .resetTextCaretColor = ResetTextCaretColor,
1926 .setTextSelectedBackgroundColor = SetTextSelectedBackgroundColor,
1927 .getTextSelectedBackgroundColor = GetTextSelectedBackgroundColor,
1928 .resetTextSelectedBackgroundColor = ResetTextSelectedBackgroundColor,
1929 .setTextContentWithStyledString = SetTextContentWithStyledString,
1930 .resetTextContentWithStyledString = ResetTextContentWithStyledString,
1931 .setTextSelection = SetTextSelection,
1932 .resetTextSelection = ResetTextSelection,
1933 .setTextSelectableMode = SetTextSelectableMode,
1934 .resetTextSelectableMode = ResetTextSelectableMode,
1935 .setTextDataDetectorConfigWithEvent = SetTextDataDetectorConfigWithEvent,
1936 .resetTextDataDetectorConfigWithEvent = ResetTextDataDetectorConfigWithEvent,
1937 .setTextOnCopy = SetTextOnCopy,
1938 .resetTextOnCopy = ResetTextOnCopy,
1939 .setTextOnTextSelectionChange = SetTextOnTextSelectionChange,
1940 .resetTextOnTextSelectionChange = ResetTextOnTextSelectionChange,
1941 .setTextMinFontScale = SetTextMinFontScale,
1942 .resetTextMinFontScale = ResetTextMinFontScale,
1943 .setTextMaxFontScale = SetTextMaxFontScale,
1944 .resetTextMaxFontScale = ResetTextMaxFontScale,
1945 .setTextSelectionMenuOptions = SetTextSelectionMenuOptions,
1946 .resetTextSelectionMenuOptions = ResetTextSelectionMenuOptions,
1947 .setTextHalfLeading = SetTextHalfLeading,
1948 .resetTextHalfLeading = ResetTextHalfLeading,
1949 .getTextHalfLeading = GetTextHalfLeading,
1950 .setTextOnClick = SetOnClick,
1951 .resetTextOnClick = ResetOnClick,
1952 .setTextResponseRegion = SetResponseRegion,
1953 .resetTextResponseRegion = ResetResponseRegion,
1954 .setTextEnableHapticFeedback = SetTextEnableHapticFeedback,
1955 .resetTextEnableHapticFeedback = ResetTextEnableHapticFeedback,
1956 .setTextMarqueeOptions = SetMarqueeOptions,
1957 .resetTextMarqueeOptions = ResetMarqueeOptions,
1958 .setOnMarqueeStateChange = SetOnMarqueeStateChange,
1959 .resetOnMarqueeStateChange = ResetOnMarqueeStateChange,
1960 .setImmutableFontWeight = SetImmutableFontWeight,
1961 .setTextOptimizeTrailingSpace = SetTextOptimizeTrailingSpace,
1962 .resetTextOptimizeTrailingSpace = ResetTextOptimizeTrailingSpace,
1963 .getTextOptimizeTrailingSpace = GetTextOptimizeTrailingSpace,
1964 .getLineCount = GetLineCount,
1965 .setEnableAutoSpacing = SetEnableAutoSpacing,
1966 .resetEnableAutoSpacing = ResetEnableAutoSpacing,
1967 .setLinearGradient = SetTextLinearGradient,
1968 .getLinearGradient = GetTextLinearGradient,
1969 .setRadialGradient = SetTextRadialGradient,
1970 .getRadialGradient = GetTextRadialGradient,
1971 .resetTextGradient = ResetTextGradient,
1972 .setTextVerticalAlign = SetTextVerticalAlign,
1973 .resetTextVerticalAlign = ResetTextVerticalAlign,
1974 .getTextVerticalAlign = GetTextVerticalAlign,
1975 .setTextContentTransition = SetTextContentTransition,
1976 .resetTextContentTransition = ResetTextContentTransition,
1977 .setColorShaderColor = SetColorShaderColor,
1978 };
1979 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1980
1981 return &modifier;
1982 }
1983
GetCJUITextModifier()1984 const CJUITextModifier* GetCJUITextModifier()
1985 {
1986 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1987 static const CJUITextModifier modifier = {
1988 .setContent = SetTextContent,
1989 .setFontWeight = SetFontWeight,
1990 .resetFontWeight = ResetFontWeight,
1991 .setFontStyle = SetFontStyle,
1992 .resetFontStyle = ResetFontStyle,
1993 .setTextAlign = SetTextAlign,
1994 .resetTextAlign = ResetTextAlign,
1995 .setFontColor = SetFontColor,
1996 .resetFontColor = ResetFontColor,
1997 .setTextForegroundColor = SetTextForegroundColor,
1998 .resetTextForegroundColor = ResetTextForegroundColor,
1999 .setFontSize = SetFontSize,
2000 .resetFontSize = ResetFontSize,
2001 .setTextLineHeight = SetTextLineHeight,
2002 .resetTextLineHeight = ResetTextLineHeight,
2003 .setTextOverflow = SetTextTextOverflow,
2004 .resetTextOverflow = ResetTextTextOverflow,
2005 .setTextDecoration = SetTextDecoration,
2006 .resetTextDecoration = ResetTextDecoration,
2007 .setTextCase = SetTextTextCase,
2008 .resetTextCase = ResetTextTextCase,
2009 .setTextMaxLines = SetTextMaxLines,
2010 .resetTextMaxLines = ResetTextMaxLines,
2011 .setTextMinFontSize = SetTextMinFontSize,
2012 .resetTextMinFontSize = ResetTextMinFontSize,
2013 .setTextDraggable = SetTextDraggable,
2014 .resetTextDraggable = ResetTextDraggable,
2015 .setTextPrivacySensitive = SetTextPrivacySensitve,
2016 .resetTextPrivacySensitive = ResetTextPrivacySensitve,
2017 .setTextMaxFontSize = SetTextMaxFontSize,
2018 .resetTextMaxFontSize = ResetTextMaxFontSize,
2019 .setTextFontFamily = SetTextFontFamily,
2020 .resetTextFontFamily = ResetTextFontFamily,
2021 .setTextCopyOption = SetTextCopyOption,
2022 .resetTextCopyOption = ResetTextCopyOption,
2023 .setTextShadow = SetTextTextShadow,
2024 .resetTextShadow = ResetTextTextShadow,
2025 .setTextHeightAdaptivePolicy = SetTextHeightAdaptivePolicy,
2026 .resetTextHeightAdaptivePolicy = ResetTextHeightAdaptivePolicy,
2027 .setTextIndent = SetTextTextIndent,
2028 .resetTextIndent = ResetTextTextIndent,
2029 .setTextBaselineOffset = SetTextBaselineOffset,
2030 .resetTextBaselineOffset = ResetTextBaselineOffset,
2031 .setTextLetterSpacing = SetTextLetterSpacing,
2032 .resetTextLetterSpacing = ResetTextLetterSpacing,
2033 .setTextFont = SetTextFont,
2034 .resetTextFont = ResetTextFont,
2035 .setFontWeightStr = SetFontWeightStr,
2036 .setWordBreak = SetWordBreak,
2037 .resetWordBreak = ResetWordBreak,
2038 .getFontFamily = GetFontFamily,
2039 .getCopyOption = GetCopyOption,
2040 .getHeightAdaptivePolicy = GetHeightAdaptivePolicy,
2041 .getTextMinFontSize = GetTextMinFontSize,
2042 .getTextMaxFontSize = GetTextMaxFontSize,
2043 .getFont = GetFont,
2044 .getFontSize = GetFontSize,
2045 .getFontWeight = GetFontWeight,
2046 .getItalicFontStyle = GetItalicFontStyle,
2047 .setEllipsisMode = SetEllipsisMode,
2048 .resetEllipsisMode = ResetEllipsisMode,
2049 .setEnableDataDetector = SetTextDetectEnable,
2050 .resetEnableDataDetector = ResetTextDetectEnable,
2051 .getTextContent = GetTextContent,
2052 .getTextLineHeight = GetTextLineHeight,
2053 .getTextDecoration = GetTextDecoration,
2054 .getTextTextCase = GetTextTextCase,
2055 .getTextLetterSpacing = GetTextLetterSpacing,
2056 .getTextMaxLines = GetTextMaxLines,
2057 .getTextAlign = GetTextAlign,
2058 .getTextTextOverflow = GetTextTextOverflow,
2059 .getTextTextIndent = GetTextTextIndent,
2060 .getFontColor = GetFontColor,
2061 .getTextBaselineOffset = GetTextBaselineOffset,
2062 .getTextShadowsCount = GetTextShadowCount,
2063 .getTextShadows = GetTextShadow,
2064 .getTextWordBreak = GetTextWordBreak,
2065 .getTextEllipsisMode = GetTextEllipsisMode,
2066 .setTextFontFeature = SetTextFontFeature,
2067 .resetTextFontFeature = ResetTextFontFeature,
2068 .getTextFontFeature = GetTextFontFeature,
2069 .getEnableDataDetector = GetTextDetectEnable,
2070 .setTextDataDetectorConfig = SetTextDataDetectorConfig,
2071 .getTextDataDetectorConfig = GetTextDataDetectorConfig,
2072 .resetTextDataDetectorConfig = ResetTextDataDetectorConfig,
2073 .setTextLineSpacing = SetTextLineSpacing,
2074 .getTextLineSpacing = GetTextLineSpacing,
2075 .resetTextLineSpacing = ResetTextLineSpacing,
2076 .setTextSelectedBackgroundColor = SetTextSelectedBackgroundColor,
2077 .getTextSelectedBackgroundColor = GetTextSelectedBackgroundColor,
2078 .resetTextSelectedBackgroundColor = ResetTextSelectedBackgroundColor,
2079 .setLineBreakStrategy = SetLineBreakStrategy,
2080 .resetLineBreakStrategy = ResetLineBreakStrategy,
2081 .getTextLineBreakStrategy = GetTextLineBreakStrategy,
2082 .setTextContentWithStyledString = SetTextContentWithStyledString,
2083 .resetTextContentWithStyledString = ResetTextContentWithStyledString,
2084 .setTextSelection = SetTextSelection,
2085 .resetTextSelection = ResetTextSelection,
2086 .setTextSelectableMode = SetTextSelectableMode,
2087 .resetTextSelectableMode = ResetTextSelectableMode,
2088 .setTextDataDetectorConfigWithEvent = SetTextDataDetectorConfigWithEvent,
2089 .resetTextDataDetectorConfigWithEvent = ResetTextDataDetectorConfigWithEvent,
2090 .setTextOnCopy = SetTextOnCopy,
2091 .resetTextOnCopy = ResetTextOnCopy,
2092 .setTextOnTextSelectionChange = SetTextOnTextSelectionChange,
2093 .resetTextOnTextSelectionChange = ResetTextOnTextSelectionChange,
2094 .setFontWeightWithOption = SetFontWeightWithOption,
2095 .setTextMinFontScale = SetTextMinFontScale,
2096 .resetTextMinFontScale = ResetTextMinFontScale,
2097 .setTextMaxFontScale = SetTextMaxFontScale,
2098 .resetTextMaxFontScale = ResetTextMaxFontScale,
2099 .setTextSelectionMenuOptions = SetTextSelectionMenuOptionsForCJ,
2100 .resetTextSelectionMenuOptions = ResetTextSelectionMenuOptions,
2101 .setTextHalfLeading = SetTextHalfLeading,
2102 .resetTextHalfLeading = ResetTextHalfLeading,
2103 .getTextHalfLeading = GetTextHalfLeading,
2104 .setTextOnClick = SetOnClick,
2105 .resetTextOnClick = ResetOnClick,
2106 .setTextResponseRegion = SetResponseRegion,
2107 .resetTextResponseRegion = ResetResponseRegion,
2108 };
2109 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
2110
2111 return &modifier;
2112 }
2113
SetOnDetectResultUpdate(ArkUINodeHandle node,void * extraParam)2114 void SetOnDetectResultUpdate(ArkUINodeHandle node, void* extraParam)
2115 {
2116 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2117 CHECK_NULL_VOID(frameNode);
2118 auto onDetectResultUpdate = [node, extraParam](const std::string& str) {
2119 ArkUINodeEvent event;
2120 event.kind = TEXT_INPUT;
2121 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2122 event.textInputEvent.subKind = ON_DETECT_RESULT_UPDATE;
2123 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
2124 SendArkUISyncEvent(&event);
2125 };
2126 TextModelNG::SetOnDetectResultUpdate(frameNode, std::move(onDetectResultUpdate));
2127 }
2128
ResetOnDetectResultUpdate(ArkUINodeHandle node)2129 void ResetOnDetectResultUpdate(ArkUINodeHandle node)
2130 {
2131 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2132 CHECK_NULL_VOID(frameNode);
2133 TextModelNG::SetOnDetectResultUpdate(frameNode, nullptr);
2134 }
2135
2136 template<typename T>
ProcessResourceObj(FrameNode * frameNode,std::string key,T value,void * objRawPtr)2137 void ProcessResourceObj(FrameNode* frameNode, std::string key, T value, void* objRawPtr)
2138 {
2139 CHECK_NULL_VOID(SystemProperties::ConfigChangePerform());
2140 CHECK_NULL_VOID(frameNode);
2141 auto pattern = frameNode->GetPattern();
2142 CHECK_NULL_VOID(pattern);
2143 if (objRawPtr) {
2144 auto resObj = AceType::Claim(reinterpret_cast<ResourceObject*>(objRawPtr));
2145 pattern->RegisterResource<T>(key, resObj, value);
2146 } else {
2147 pattern->UnRegisterResource(key);
2148 }
2149 }
2150 } // namespace NodeModifier
2151 } // namespace OHOS::Ace::NG
2152