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/utils.h"
18 #include "base/utils/utf_helper.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/font/constants_converter.h"
23 #include "core/components_ng/base/frame_node.h"
24 #include "core/components_ng/base/view_abstract.h"
25 #include "core/interfaces/arkoala/arkoala_api.h"
26 #include "core/pipeline/base/element_register.h"
27 #include "frameworks/core/components/common/layout/constants.h"
28 #include "frameworks/core/components/common/properties/text_style.h"
29 #include "frameworks/core/components_ng/pattern/text/text_model_ng.h"
30 #include "core/components/common/properties/text_style_parser.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 TextDecoration DEFAULT_TEXT_DECORATION = TextDecoration::NONE;
37 constexpr Color DEFAULT_DECORATION_COLOR = Color(0xff000000);
38 constexpr TextDecorationStyle DEFAULT_DECORATION_STYLE = TextDecorationStyle::SOLID;
39 constexpr TextCase DEFAULT_TEXT_CASE = TextCase::NORMAL;
40 constexpr uint32_t DEFAULT_MAX_LINE = Infinity<uint32_t>();
41 constexpr bool DEFAULT_TEXT_DRAGGABLE = false;
42 constexpr bool DEFAULT_TEXT_SENSITIVE = false;
43 constexpr Dimension DEFAULT_MAX_FONT_SIZE;
44 constexpr Dimension DEFAULT_MIN_FONT_SIZE;
45 constexpr float DEFAULT_MIN_FONT_SCALE = 0.0f;
46 constexpr float DEFAULT_MAX_FONT_SCALE = static_cast<float>(INT32_MAX);
47 constexpr CopyOptions DEFAULT_COPY_OPTION = CopyOptions::None;
48 constexpr Dimension DEFAULT_BASELINE_OFFSET = 0.0_fp;
49 constexpr Dimension DEFAULT_FONT_SIZE = 16.0_fp;
50 constexpr FontWeight DEFAULT_FONT_WEIGHT = FontWeight::NORMAL;
51 constexpr int32_t DEFAULT_VARIABLE_FONT_WEIGHT = 400;
52 constexpr Ace::FontStyle DEFAULT_FONT_STYLE = Ace::FontStyle::NORMAL;
53 const std::string DEFAULT_FAMILY = "HarmonyOS Sans";
54 const std::string EMPTY_STRING = "";
55 const std::vector<OHOS::Ace::FontStyle> FONT_STYLES = { OHOS::Ace::FontStyle::NORMAL, OHOS::Ace::FontStyle::ITALIC };
56 const std::vector<OHOS::Ace::TextAlign> TEXT_ALIGNS = { OHOS::Ace::TextAlign::START, OHOS::Ace::TextAlign::CENTER,
57 OHOS::Ace::TextAlign::END, OHOS::Ace::TextAlign::JUSTIFY, OHOS::Ace::TextAlign::LEFT, OHOS::Ace::TextAlign::RIGHT };
58 const std::vector<TextHeightAdaptivePolicy> HEIGHT_ADAPTIVE_POLICY = { TextHeightAdaptivePolicy::MAX_LINES_FIRST,
59 TextHeightAdaptivePolicy::MIN_FONT_SIZE_FIRST, TextHeightAdaptivePolicy::LAYOUT_CONSTRAINT_FIRST };
60 const std::vector<EllipsisMode> ELLIPSIS_MODALS = { EllipsisMode::HEAD, EllipsisMode::MIDDLE, EllipsisMode::TAIL };
61 const std::vector<TextSelectableMode> TEXT_SELECTABLE_MODE = { TextSelectableMode::SELECTABLE_UNFOCUSABLE,
62 TextSelectableMode::SELECTABLE_FOCUSABLE, TextSelectableMode::UNSELECTABLE };
63 constexpr bool DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE = true;
64 constexpr bool DEFAULT_ENABLE_TEXT_DETECTOR = false;
65 const std::vector<std::string> TEXT_DETECT_TYPES = { "phoneNum", "url", "email", "location", "datetime" };
66 constexpr int NUM_0 = 0;
67 constexpr int NUM_1 = 1;
68 constexpr int NUM_2 = 2;
69 constexpr int NUM_3 = 3;
70 constexpr int NUM_4 = 4;
71
72 std::map<TextHeightAdaptivePolicy, int> TEXT_HEIGHT_ADAPTIVE_POLICY_MAP = {
73 { TextHeightAdaptivePolicy::MAX_LINES_FIRST, 0 },
74 { TextHeightAdaptivePolicy::MIN_FONT_SIZE_FIRST, 1 },
75 { TextHeightAdaptivePolicy::LAYOUT_CONSTRAINT_FIRST, 2 } };
76
77 const float ERROR_FLOAT_CODE = -1.0f;
78 const int32_t ERROR_INT_CODE = -1;
79
ConvertStrToFontWeight(const char * weight,FontWeight defaultFontWeight=FontWeight::NORMAL)80 FontWeight ConvertStrToFontWeight(const char* weight, FontWeight defaultFontWeight = FontWeight::NORMAL)
81 {
82 std::string weightStr(weight);
83 return StringUtils::StringToFontWeight(weightStr, defaultFontWeight);
84 }
85 namespace {
86
87 std::string g_strValue;
SetTextContent(ArkUINodeHandle node,ArkUI_CharPtr value)88 void SetTextContent(ArkUINodeHandle node, ArkUI_CharPtr value)
89 {
90 auto* frameNode = reinterpret_cast<FrameNode*>(node);
91 CHECK_NULL_VOID(frameNode);
92 std::u16string content = UtfUtils::Str8DebugToStr16(std::string(value));
93 TextModelNG::InitText(frameNode, content);
94 }
95
GetTextContent(ArkUINodeHandle node)96 const char* GetTextContent(ArkUINodeHandle node)
97 {
98 auto* frameNode = reinterpret_cast<FrameNode*>(node);
99 CHECK_NULL_RETURN(frameNode, nullptr);
100 g_strValue = UtfUtils::Str16DebugToStr8(TextModelNG::GetContent(frameNode));
101 return g_strValue.c_str();
102 }
103
SetFontWeightStr(ArkUINodeHandle node,ArkUI_CharPtr weight)104 void SetFontWeightStr(ArkUINodeHandle node, ArkUI_CharPtr weight)
105 {
106 auto* frameNode = reinterpret_cast<FrameNode*>(node);
107 CHECK_NULL_VOID(frameNode);
108 TextModelNG::SetFontWeight(frameNode, ConvertStrToFontWeight(weight));
109 }
110
SetFontWeightWithOption(ArkUINodeHandle node,const struct ArkUIFontWeightWithOptionsStruct * weightInfo)111 void SetFontWeightWithOption(ArkUINodeHandle node, const struct ArkUIFontWeightWithOptionsStruct* weightInfo)
112 {
113 auto* frameNode = reinterpret_cast<FrameNode*>(node);
114 CHECK_NULL_VOID(frameNode);
115 TextModelNG::SetFontWeight(frameNode, ConvertStrToFontWeight(weightInfo->weight));
116 TextModelNG::SetVariableFontWeight(frameNode, weightInfo->variableFontWeight);
117 TextModelNG::SetEnableVariableFontWeight(frameNode, weightInfo->enableVariableFontWeight);
118 }
119
SetFontWeight(ArkUINodeHandle node,ArkUI_Int32 weight)120 void SetFontWeight(ArkUINodeHandle node, ArkUI_Int32 weight)
121 {
122 auto* frameNode = reinterpret_cast<FrameNode*>(node);
123 CHECK_NULL_VOID(frameNode);
124 TextModelNG::SetFontWeight(frameNode, static_cast<FontWeight>(weight));
125 TextModelNG::SetVariableFontWeight(frameNode, DEFAULT_VARIABLE_FONT_WEIGHT);
126 TextModelNG::SetEnableVariableFontWeight(frameNode, false);
127 }
128
SetImmutableFontWeight(ArkUINodeHandle node,ArkUI_Int32 weight)129 void SetImmutableFontWeight(ArkUINodeHandle node, ArkUI_Int32 weight)
130 {
131 auto* frameNode = reinterpret_cast<FrameNode*>(node);
132 CHECK_NULL_VOID(frameNode);
133 TextModelNG::SetFontWeight(frameNode, static_cast<FontWeight>(weight));
134 TextModelNG::SetVariableFontWeight(frameNode, Constants::GetVariableFontWeight(static_cast<FontWeight>(weight)));
135 TextModelNG::SetEnableVariableFontWeight(frameNode, true);
136 }
137
SetOnClick(ArkUINodeHandle node,void * callback)138 void SetOnClick(ArkUINodeHandle node, void* callback)
139 {
140 auto *frameNode = reinterpret_cast<FrameNode *>(node);
141 CHECK_NULL_VOID(frameNode);
142 GestureEventFunc* click = nullptr;
143 if (callback) {
144 click = reinterpret_cast<GestureEventFunc*>(callback);
145 TextModelNG::SetOnClick(frameNode, std::move(*click));
146 } else {
147 TextModelNG::SetOnClick(frameNode, nullptr);
148 }
149 }
150
ResetOnClick(ArkUINodeHandle node)151 void ResetOnClick(ArkUINodeHandle node)
152 {
153 auto *frameNode = reinterpret_cast<FrameNode *>(node);
154 CHECK_NULL_VOID(frameNode);
155 TextModelNG::ClearOnClick(frameNode);
156 }
157
SetResponseRegion(ArkUINodeHandle node,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length)158 void SetResponseRegion(ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length)
159 {
160 auto* frameNode = reinterpret_cast<FrameNode*>(node);
161 CHECK_NULL_VOID(frameNode);
162 std::vector<DimensionRect> region;
163 for (int32_t i = 0; i < length / NUM_4; i++) {
164 CalcDimension xDimen =
165 CalcDimension(values[i * NUM_4 + NUM_0], static_cast<DimensionUnit>(units[i * NUM_4 + NUM_0]));
166 CalcDimension yDimen =
167 CalcDimension(values[i * NUM_4 + NUM_1], static_cast<DimensionUnit>(units[i * NUM_4 + NUM_1]));
168 CalcDimension widthDimen =
169 CalcDimension(values[i * NUM_4 + NUM_2], static_cast<DimensionUnit>(units[i * NUM_4 + NUM_2]));
170 CalcDimension heightDimen =
171 CalcDimension(values[i * NUM_4 + NUM_3], static_cast<DimensionUnit>(units[i * NUM_4 + NUM_3]));
172 DimensionOffset offsetDimen(xDimen, yDimen);
173 DimensionRect dimenRect(widthDimen, heightDimen, offsetDimen);
174 region.emplace_back(dimenRect);
175 }
176 TextModelNG::SetResponseRegion(frameNode, region);
177 }
178
ResetResponseRegion(ArkUINodeHandle node)179 void ResetResponseRegion(ArkUINodeHandle node)
180 {
181 auto *frameNode = reinterpret_cast<FrameNode *>(node);
182 CHECK_NULL_VOID(frameNode);
183 TextModelNG::ClearResponseRegion(frameNode);
184 }
ResetFontWeight(ArkUINodeHandle node)185 void ResetFontWeight(ArkUINodeHandle node)
186 {
187 auto* frameNode = reinterpret_cast<FrameNode*>(node);
188 CHECK_NULL_VOID(frameNode);
189 TextModelNG::SetFontWeight(frameNode, Ace::FontWeight::NORMAL);
190 TextModelNG::SetVariableFontWeight(frameNode, DEFAULT_VARIABLE_FONT_WEIGHT);
191 TextModelNG::SetEnableVariableFontWeight(frameNode, false);
192 }
193
SetFontStyle(ArkUINodeHandle node,ArkUI_Uint32 fontStyle)194 void SetFontStyle(ArkUINodeHandle node, ArkUI_Uint32 fontStyle)
195 {
196 auto* frameNode = reinterpret_cast<FrameNode*>(node);
197 CHECK_NULL_VOID(frameNode);
198 if (fontStyle < 0 || fontStyle >= FONT_STYLES.size()) {
199 return;
200 }
201 TextModelNG::SetItalicFontStyle(frameNode, FONT_STYLES[fontStyle]);
202 }
203
ResetFontStyle(ArkUINodeHandle node)204 void ResetFontStyle(ArkUINodeHandle node)
205 {
206 auto* frameNode = reinterpret_cast<FrameNode*>(node);
207 CHECK_NULL_VOID(frameNode);
208 TextModelNG::SetItalicFontStyle(frameNode, OHOS::Ace::FontStyle::NORMAL);
209 }
210
SetTextAlign(ArkUINodeHandle node,ArkUI_Uint32 testAlign)211 void SetTextAlign(ArkUINodeHandle node, ArkUI_Uint32 testAlign)
212 {
213 auto* frameNode = reinterpret_cast<FrameNode*>(node);
214 CHECK_NULL_VOID(frameNode);
215 if (testAlign < 0 || testAlign >= TEXT_ALIGNS.size()) {
216 return;
217 }
218 TextModelNG::SetTextAlign(frameNode, TEXT_ALIGNS[testAlign]);
219 }
220
GetTextAlign(ArkUINodeHandle node)221 int32_t GetTextAlign(ArkUINodeHandle node)
222 {
223 auto defaultTextAlign = static_cast<int32_t>(OHOS::Ace::TextAlign::START);
224 auto* frameNode = reinterpret_cast<FrameNode*>(node);
225 CHECK_NULL_RETURN(frameNode, defaultTextAlign);
226 return static_cast<int32_t>(TextModelNG::GetTextAlign(frameNode));
227 }
228
ResetTextAlign(ArkUINodeHandle node)229 void ResetTextAlign(ArkUINodeHandle node)
230 {
231 auto* frameNode = reinterpret_cast<FrameNode*>(node);
232 CHECK_NULL_VOID(frameNode);
233 TextModelNG::SetTextAlign(frameNode, OHOS::Ace::TextAlign::START);
234 }
235
SetFontColor(ArkUINodeHandle node,ArkUI_Uint32 color)236 void SetFontColor(ArkUINodeHandle node, ArkUI_Uint32 color)
237 {
238 auto* frameNode = reinterpret_cast<FrameNode*>(node);
239 CHECK_NULL_VOID(frameNode);
240 TextModelNG::SetTextColor(frameNode, Color(color));
241 }
242
ResetFontColor(ArkUINodeHandle node)243 void ResetFontColor(ArkUINodeHandle node)
244 {
245 auto* frameNode = reinterpret_cast<FrameNode*>(node);
246 CHECK_NULL_VOID(frameNode);
247 TextModelNG::ResetTextColor(frameNode);
248 }
249
GetFontColor(ArkUINodeHandle node)250 uint32_t GetFontColor(ArkUINodeHandle node)
251 {
252 auto* frameNode = reinterpret_cast<FrameNode*>(node);
253 CHECK_NULL_RETURN(frameNode, Color::BLACK.GetValue());
254 return TextModelNG::GetFontColor(frameNode).GetValue();
255 }
256
SetTextForegroundColor(ArkUINodeHandle node,ArkUI_Bool isColor,uint32_t color)257 void SetTextForegroundColor(ArkUINodeHandle node, ArkUI_Bool isColor, uint32_t color)
258 {
259 auto* frameNode = reinterpret_cast<FrameNode*>(node);
260 CHECK_NULL_VOID(frameNode);
261 if (isColor) {
262 TextModelNG::SetTextColor(frameNode, Color(color));
263 } else {
264 TextModelNG::SetTextColor(frameNode, Color::FOREGROUND);
265 auto strategy = static_cast<ForegroundColorStrategy>(color);
266 ViewAbstract::SetForegroundColorStrategy(frameNode, strategy);
267 }
268 }
269
ResetTextForegroundColor(ArkUINodeHandle node)270 void ResetTextForegroundColor(ArkUINodeHandle node)
271 {
272 ResetFontColor(node);
273 }
274
SetFontSize(ArkUINodeHandle node,ArkUI_Float32 fontSize,ArkUI_Int32 unit)275 void SetFontSize(ArkUINodeHandle node, ArkUI_Float32 fontSize, ArkUI_Int32 unit)
276 {
277 auto* frameNode = reinterpret_cast<FrameNode*>(node);
278 CHECK_NULL_VOID(frameNode);
279 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(unit);
280
281 if (fontSize < 0 || unitEnum < OHOS::Ace::DimensionUnit::PX || unitEnum > OHOS::Ace::DimensionUnit::CALC ||
282 unitEnum == OHOS::Ace::DimensionUnit::PERCENT) {
283 auto theme = GetTheme<TextTheme>();
284 CHECK_NULL_VOID(theme);
285 CalcDimension fontSize = theme->GetTextStyle().GetFontSize();
286 TextModelNG::SetFontSize(frameNode, fontSize);
287 } else {
288 TextModelNG::SetFontSize(frameNode, Dimension(fontSize, static_cast<OHOS::Ace::DimensionUnit>(unit)));
289 }
290 }
291
ResetFontSize(ArkUINodeHandle node)292 void ResetFontSize(ArkUINodeHandle node)
293 {
294 auto* frameNode = reinterpret_cast<FrameNode*>(node);
295 CHECK_NULL_VOID(frameNode);
296 auto theme = GetTheme<TextTheme>();
297 CHECK_NULL_VOID(theme);
298 CalcDimension fontSize = theme->GetTextStyle().GetFontSize();
299 TextModelNG::SetFontSize(frameNode, fontSize);
300 }
301
SetTextLineHeight(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)302 void SetTextLineHeight(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
303 {
304 auto* frameNode = reinterpret_cast<FrameNode*>(node);
305 CHECK_NULL_VOID(frameNode);
306 TextModelNG::SetLineHeight(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
307 }
308
GetTextLineHeight(ArkUINodeHandle node)309 float GetTextLineHeight(ArkUINodeHandle node)
310 {
311 auto* frameNode = reinterpret_cast<FrameNode*>(node);
312 CHECK_NULL_RETURN(frameNode, 0.0f);
313 return TextModelNG::GetLineHeight(frameNode);
314 }
315
ResetTextLineHeight(ArkUINodeHandle node)316 void ResetTextLineHeight(ArkUINodeHandle node)
317 {
318 auto* frameNode = reinterpret_cast<FrameNode*>(node);
319 CHECK_NULL_VOID(frameNode);
320 TextModelNG::SetLineHeight(frameNode, DEFAULT_LINE_HEIGHT);
321 }
322
SetTextTextOverflow(ArkUINodeHandle node,ArkUI_Int32 value)323 void SetTextTextOverflow(ArkUINodeHandle node, ArkUI_Int32 value)
324 {
325 auto* frameNode = reinterpret_cast<FrameNode*>(node);
326 CHECK_NULL_VOID(frameNode);
327 TextOverflow valueTextOverflow = static_cast<TextOverflow>(value);
328 TextModelNG::SetTextOverflow(frameNode, valueTextOverflow);
329 }
330
GetTextTextOverflow(ArkUINodeHandle node)331 int32_t GetTextTextOverflow(ArkUINodeHandle node)
332 {
333 int defaultTextOverflow = static_cast<int32_t>(TextOverflow::NONE);
334 auto* frameNode = reinterpret_cast<FrameNode*>(node);
335 CHECK_NULL_RETURN(frameNode, defaultTextOverflow);
336 return static_cast<int32_t>(TextModelNG::GetTextOverflow(frameNode));
337 }
338
ResetTextTextOverflow(ArkUINodeHandle node)339 void ResetTextTextOverflow(ArkUINodeHandle node)
340 {
341 auto* frameNode = reinterpret_cast<FrameNode*>(node);
342 CHECK_NULL_VOID(frameNode);
343 TextModelNG::SetTextOverflow(frameNode, TextOverflow::NONE);
344 }
345
SetTextDecoration(ArkUINodeHandle node,ArkUI_Int32 decoration,ArkUI_Uint32 color,ArkUI_Int32 style)346 void SetTextDecoration(ArkUINodeHandle node, ArkUI_Int32 decoration, ArkUI_Uint32 color, ArkUI_Int32 style)
347 {
348 auto* frameNode = reinterpret_cast<FrameNode*>(node);
349 CHECK_NULL_VOID(frameNode);
350 TextModelNG::SetTextDecoration(frameNode, static_cast<TextDecoration>(decoration));
351 TextModelNG::SetTextDecorationColor(frameNode, Color(color));
352 TextModelNG::SetTextDecorationStyle(frameNode, static_cast<TextDecorationStyle>(style));
353 }
354
GetTextDecoration(ArkUINodeHandle node,ArkUITextDecorationType * decoration)355 void GetTextDecoration(ArkUINodeHandle node, ArkUITextDecorationType* decoration)
356 {
357 CHECK_NULL_VOID(decoration);
358 auto* frameNode = reinterpret_cast<FrameNode*>(node);
359 CHECK_NULL_VOID(frameNode);
360 decoration->decorationType = static_cast<int32_t>(TextModelNG::GetDecoration(frameNode));
361 decoration->color = TextModelNG::GetTextDecorationColor(frameNode).GetValue();
362 decoration->style = static_cast<int32_t>(TextModelNG::GetTextDecorationStyle(frameNode));
363 }
364
ResetTextDecoration(ArkUINodeHandle node)365 void ResetTextDecoration(ArkUINodeHandle node)
366 {
367 auto* frameNode = reinterpret_cast<FrameNode*>(node);
368 CHECK_NULL_VOID(frameNode);
369 TextModelNG::SetTextDecoration(frameNode, DEFAULT_TEXT_DECORATION);
370 TextModelNG::SetTextDecorationColor(frameNode, DEFAULT_DECORATION_COLOR);
371 TextModelNG::SetTextDecorationStyle(frameNode, DEFAULT_DECORATION_STYLE);
372 }
373
SetTextTextCase(ArkUINodeHandle node,ArkUI_Int32 value)374 void SetTextTextCase(ArkUINodeHandle node, ArkUI_Int32 value)
375 {
376 auto* frameNode = reinterpret_cast<FrameNode*>(node);
377 CHECK_NULL_VOID(frameNode);
378 TextModelNG::SetTextCase(frameNode, static_cast<TextCase>(value));
379 }
380
GetTextTextCase(ArkUINodeHandle node)381 int32_t GetTextTextCase(ArkUINodeHandle node)
382 {
383 int32_t defaultTextCase = static_cast<int32_t>(DEFAULT_TEXT_CASE);
384 auto* frameNode = reinterpret_cast<FrameNode*>(node);
385 CHECK_NULL_RETURN(frameNode, defaultTextCase);
386 return static_cast<int32_t>(TextModelNG::GetTextCase(frameNode));
387 }
388
ResetTextTextCase(ArkUINodeHandle node)389 void ResetTextTextCase(ArkUINodeHandle node)
390 {
391 auto* frameNode = reinterpret_cast<FrameNode*>(node);
392 CHECK_NULL_VOID(frameNode);
393 TextModelNG::SetTextCase(frameNode, DEFAULT_TEXT_CASE);
394 }
395
SetTextMaxLines(ArkUINodeHandle node,ArkUI_Uint32 maxLine)396 void SetTextMaxLines(ArkUINodeHandle node, ArkUI_Uint32 maxLine)
397 {
398 auto* frameNode = reinterpret_cast<FrameNode*>(node);
399 CHECK_NULL_VOID(frameNode);
400 TextModelNG::SetMaxLines(frameNode, maxLine);
401 }
402
GetTextMaxLines(ArkUINodeHandle node)403 int32_t GetTextMaxLines(ArkUINodeHandle node)
404 {
405 auto* frameNode = reinterpret_cast<FrameNode*>(node);
406 CHECK_NULL_RETURN(frameNode, DEFAULT_MAX_LINE);
407 return TextModelNG::GetMaxLines(frameNode);
408 }
409
ResetTextMaxLines(ArkUINodeHandle node)410 void ResetTextMaxLines(ArkUINodeHandle node)
411 {
412 auto* frameNode = reinterpret_cast<FrameNode*>(node);
413 CHECK_NULL_VOID(frameNode);
414 TextModelNG::SetMaxLines(frameNode, DEFAULT_MAX_LINE);
415 }
416
SetTextMinFontSize(ArkUINodeHandle node,ArkUI_Float32 number,const ArkUI_Int32 unit)417 void SetTextMinFontSize(ArkUINodeHandle node, ArkUI_Float32 number, const ArkUI_Int32 unit)
418 {
419 auto* frameNode = reinterpret_cast<FrameNode*>(node);
420 CHECK_NULL_VOID(frameNode);
421 TextModelNG::SetAdaptMinFontSize(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
422 }
423
ResetTextMinFontSize(ArkUINodeHandle node)424 void ResetTextMinFontSize(ArkUINodeHandle node)
425 {
426 auto* frameNode = reinterpret_cast<FrameNode*>(node);
427 CHECK_NULL_VOID(frameNode);
428 TextModelNG::SetAdaptMinFontSize(frameNode, DEFAULT_MIN_FONT_SIZE);
429 }
430
SetTextDraggable(ArkUINodeHandle node,ArkUI_Uint32 draggable)431 void SetTextDraggable(ArkUINodeHandle node, ArkUI_Uint32 draggable)
432 {
433 auto* frameNode = reinterpret_cast<FrameNode*>(node);
434 CHECK_NULL_VOID(frameNode);
435 ViewAbstract::SetDraggable(frameNode, static_cast<bool>(draggable));
436 }
437
ResetTextDraggable(ArkUINodeHandle node)438 void ResetTextDraggable(ArkUINodeHandle node)
439 {
440 auto* frameNode = reinterpret_cast<FrameNode*>(node);
441 CHECK_NULL_VOID(frameNode);
442 ViewAbstract::SetDraggable(frameNode, DEFAULT_TEXT_DRAGGABLE);
443 }
444
SetTextPrivacySensitve(ArkUINodeHandle node,ArkUI_Uint32 sensitive)445 void SetTextPrivacySensitve(ArkUINodeHandle node, ArkUI_Uint32 sensitive)
446 {
447 auto* frameNode = reinterpret_cast<FrameNode*>(node);
448 CHECK_NULL_VOID(frameNode);
449 frameNode->SetPrivacySensitive(static_cast<bool>(sensitive));
450 frameNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
451 }
452
ResetTextPrivacySensitve(ArkUINodeHandle node)453 void ResetTextPrivacySensitve(ArkUINodeHandle node)
454 {
455 auto* frameNode = reinterpret_cast<FrameNode*>(node);
456 CHECK_NULL_VOID(frameNode);
457 frameNode->SetPrivacySensitive(DEFAULT_TEXT_SENSITIVE);
458 frameNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
459 }
460
SetTextMaxFontSize(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)461 void SetTextMaxFontSize(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
462 {
463 auto* frameNode = reinterpret_cast<FrameNode*>(node);
464 CHECK_NULL_VOID(frameNode);
465 TextModelNG::SetAdaptMaxFontSize(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
466 }
467
ResetTextMaxFontSize(ArkUINodeHandle node)468 void ResetTextMaxFontSize(ArkUINodeHandle node)
469 {
470 auto* frameNode = reinterpret_cast<FrameNode*>(node);
471 CHECK_NULL_VOID(frameNode);
472 TextModelNG::SetAdaptMaxFontSize(frameNode, DEFAULT_MAX_FONT_SIZE);
473 }
474
SetTextMinFontScale(ArkUINodeHandle node,ArkUI_Float32 number)475 void SetTextMinFontScale(ArkUINodeHandle node, ArkUI_Float32 number)
476 {
477 auto* frameNode = reinterpret_cast<FrameNode*>(node);
478 CHECK_NULL_VOID(frameNode);
479 TextModelNG::SetMinFontScale(frameNode, number);
480 }
481
ResetTextMinFontScale(ArkUINodeHandle node)482 void ResetTextMinFontScale(ArkUINodeHandle node)
483 {
484 auto* frameNode = reinterpret_cast<FrameNode*>(node);
485 CHECK_NULL_VOID(frameNode);
486 TextModelNG::SetMinFontScale(frameNode, DEFAULT_MIN_FONT_SCALE);
487 }
488
SetTextMaxFontScale(ArkUINodeHandle node,ArkUI_Float32 number)489 void SetTextMaxFontScale(ArkUINodeHandle node, ArkUI_Float32 number)
490 {
491 auto* frameNode = reinterpret_cast<FrameNode*>(node);
492 CHECK_NULL_VOID(frameNode);
493 TextModelNG::SetMaxFontScale(frameNode, number);
494 }
495
ResetTextMaxFontScale(ArkUINodeHandle node)496 void ResetTextMaxFontScale(ArkUINodeHandle node)
497 {
498 auto* frameNode = reinterpret_cast<FrameNode*>(node);
499 CHECK_NULL_VOID(frameNode);
500 TextModelNG::SetMaxFontScale(frameNode, DEFAULT_MAX_FONT_SCALE);
501 }
502
SetTextFontFamily(ArkUINodeHandle node,const char ** fontFamilies,ArkUI_Uint32 length)503 void SetTextFontFamily(ArkUINodeHandle node, const char** fontFamilies, ArkUI_Uint32 length)
504 {
505 CHECK_NULL_VOID(fontFamilies);
506 if (length <= 0) {
507 return;
508 }
509 auto* frameNode = reinterpret_cast<FrameNode*>(node);
510 CHECK_NULL_VOID(frameNode);
511 std::vector<std::string> families;
512 for (uint32_t i = 0; i < length; i++) {
513 const char* family = *(fontFamilies + i);
514 if (family != nullptr) {
515 families.emplace_back(std::string(family));
516 }
517 }
518 TextModelNG::SetFontFamily(frameNode, families);
519 }
520
ResetTextFontFamily(ArkUINodeHandle node)521 void ResetTextFontFamily(ArkUINodeHandle node)
522 {
523 auto* frameNode = reinterpret_cast<FrameNode*>(node);
524 CHECK_NULL_VOID(frameNode);
525 std::vector<std::string> families;
526 families.emplace_back(DEFAULT_FAMILY);
527 TextModelNG::SetFontFamily(frameNode, families);
528 }
529
SetTextCopyOption(ArkUINodeHandle node,ArkUI_Int32 copyOption)530 void SetTextCopyOption(ArkUINodeHandle node, ArkUI_Int32 copyOption)
531 {
532 auto* frameNode = reinterpret_cast<FrameNode*>(node);
533 CHECK_NULL_VOID(frameNode);
534 TextModelNG::SetCopyOption(frameNode, static_cast<CopyOptions>(copyOption));
535 }
536
ResetTextCopyOption(ArkUINodeHandle node)537 void ResetTextCopyOption(ArkUINodeHandle node)
538 {
539 auto* frameNode = reinterpret_cast<FrameNode*>(node);
540 CHECK_NULL_VOID(frameNode);
541 TextModelNG::SetCopyOption(frameNode, DEFAULT_COPY_OPTION);
542 }
543
SetTextTextShadow(ArkUINodeHandle node,struct ArkUITextShadowStruct * shadows,ArkUI_Uint32 length)544 void SetTextTextShadow(ArkUINodeHandle node, struct ArkUITextShadowStruct* shadows, ArkUI_Uint32 length)
545 {
546 CHECK_NULL_VOID(shadows);
547 auto* frameNode = reinterpret_cast<FrameNode*>(node);
548 CHECK_NULL_VOID(frameNode);
549 std::vector<Shadow> shadowList(length);
550 for (uint32_t i = 0; i < length; i++) {
551 Shadow shadow;
552 ArkUITextShadowStruct* shadowStruct = shadows + i;
553 shadow.SetBlurRadius(shadowStruct->radius);
554 shadow.SetShadowType(static_cast<ShadowType>(shadowStruct->type));
555 shadow.SetColor(Color(shadowStruct->color));
556 shadow.SetOffsetX(shadowStruct->offsetX);
557 shadow.SetOffsetY(shadowStruct->offsetY);
558 shadow.SetIsFilled(static_cast<bool>(shadowStruct->fill));
559 shadowList.at(i) = shadow;
560 }
561 TextModelNG::SetTextShadow(frameNode, shadowList);
562 }
563
GetTextShadowCount(ArkUINodeHandle node)564 ArkUI_Uint32 GetTextShadowCount(ArkUINodeHandle node)
565 {
566 auto* frameNode = reinterpret_cast<FrameNode*>(node);
567 CHECK_NULL_RETURN(frameNode, 0);
568 return TextModelNG::GetTextShadow(frameNode).size();
569 }
570
GetTextShadow(ArkUINodeHandle node,ArkUITextShadowStruct * shadow,uint32_t size)571 void GetTextShadow(ArkUINodeHandle node, ArkUITextShadowStruct* shadow, uint32_t size)
572 {
573 auto* frameNode = reinterpret_cast<FrameNode*>(node);
574 CHECK_NULL_VOID(frameNode);
575 std::vector<ArkUITextShadowStruct> shadowArray;
576 auto textShadowVector = TextModelNG::GetTextShadow(frameNode);
577 for (uint32_t i = 0; i < size; i++) {
578 if (i < textShadowVector.size()) {
579 *(shadow + i) = { static_cast<float>(textShadowVector[i].GetBlurRadius()),
580 static_cast<int32_t>(textShadowVector[i].GetShadowType()), textShadowVector[i].GetColor().GetValue(),
581 textShadowVector[i].GetOffset().GetX(), textShadowVector[i].GetOffset().GetY(),
582 textShadowVector[i].GetIsFilled()};
583 } else {
584 *(shadow + i) = { 0.0f, static_cast<int32_t>(ShadowType::COLOR),
585 Color::TRANSPARENT.GetValue(), 0.0f, 0.0f, 0 };
586 }
587 }
588 }
589
ResetTextTextShadow(ArkUINodeHandle node)590 void ResetTextTextShadow(ArkUINodeHandle node)
591 {
592 auto* frameNode = reinterpret_cast<FrameNode*>(node);
593 CHECK_NULL_VOID(frameNode);
594 Shadow shadow;
595 shadow.SetOffsetX(0.0);
596 shadow.SetOffsetY(0.0);
597 TextModelNG::SetTextShadow(frameNode, std::vector<Shadow> { shadow });
598 }
599
SetTextHeightAdaptivePolicy(ArkUINodeHandle node,ArkUI_Int32 value)600 void SetTextHeightAdaptivePolicy(ArkUINodeHandle node, ArkUI_Int32 value)
601 {
602 auto* frameNode = reinterpret_cast<FrameNode*>(node);
603 CHECK_NULL_VOID(frameNode);
604 value = std::clamp(value, 0, static_cast<int32_t>(HEIGHT_ADAPTIVE_POLICY.size()));
605 TextModelNG::SetHeightAdaptivePolicy(frameNode, HEIGHT_ADAPTIVE_POLICY[value]);
606 }
607
ResetTextHeightAdaptivePolicy(ArkUINodeHandle node)608 void ResetTextHeightAdaptivePolicy(ArkUINodeHandle node)
609 {
610 auto* frameNode = reinterpret_cast<FrameNode*>(node);
611 CHECK_NULL_VOID(frameNode);
612 TextModelNG::SetHeightAdaptivePolicy(frameNode, TextHeightAdaptivePolicy::MAX_LINES_FIRST);
613 }
614
SetTextTextIndent(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)615 void SetTextTextIndent(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
616 {
617 auto* frameNode = reinterpret_cast<FrameNode*>(node);
618 CHECK_NULL_VOID(frameNode);
619 TextModelNG::SetTextIndent(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
620 }
621
GetTextTextIndent(ArkUINodeHandle node)622 float GetTextTextIndent(ArkUINodeHandle node)
623 {
624 auto* frameNode = reinterpret_cast<FrameNode*>(node);
625 CHECK_NULL_RETURN(frameNode, 0.0f);
626 return TextModelNG::GetTextIndent(frameNode).ConvertToVp();
627 }
628
ResetTextTextIndent(ArkUINodeHandle node)629 void ResetTextTextIndent(ArkUINodeHandle node)
630 {
631 auto* frameNode = reinterpret_cast<FrameNode*>(node);
632 CHECK_NULL_VOID(frameNode);
633 TextModelNG::SetTextIndent(frameNode, CalcDimension(0, DimensionUnit::FP));
634 }
635
SetTextBaselineOffset(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)636 void SetTextBaselineOffset(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
637 {
638 auto* frameNode = reinterpret_cast<FrameNode*>(node);
639 CHECK_NULL_VOID(frameNode);
640 TextModelNG::SetBaselineOffset(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
641 }
642
ResetTextBaselineOffset(ArkUINodeHandle node)643 void ResetTextBaselineOffset(ArkUINodeHandle node)
644 {
645 auto* frameNode = reinterpret_cast<FrameNode*>(node);
646 CHECK_NULL_VOID(frameNode);
647 TextModelNG::SetBaselineOffset(frameNode, DEFAULT_BASELINE_OFFSET);
648 }
649
GetTextBaselineOffset(ArkUINodeHandle node)650 ArkUI_Float32 GetTextBaselineOffset(ArkUINodeHandle node)
651 {
652 auto* frameNode = reinterpret_cast<FrameNode*>(node);
653 CHECK_NULL_RETURN(frameNode, 0.0f);
654 return TextModelNG::GetTextBaselineOffset(frameNode).ConvertToVp();
655 }
656
SetTextLetterSpacing(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)657 void SetTextLetterSpacing(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
658 {
659 auto* frameNode = reinterpret_cast<FrameNode*>(node);
660 CHECK_NULL_VOID(frameNode);
661 TextModelNG::SetLetterSpacing(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
662 }
663
GetTextLetterSpacing(ArkUINodeHandle node)664 ArkUI_Float32 GetTextLetterSpacing(ArkUINodeHandle node)
665 {
666 auto* frameNode = reinterpret_cast<FrameNode*>(node);
667 CHECK_NULL_RETURN(frameNode, 0.0f);
668 return TextModelNG::GetLetterSpacing(frameNode).ConvertToVp();
669 }
670
ResetTextLetterSpacing(ArkUINodeHandle node)671 void ResetTextLetterSpacing(ArkUINodeHandle node)
672 {
673 auto* frameNode = reinterpret_cast<FrameNode*>(node);
674 CHECK_NULL_VOID(frameNode);
675 CalcDimension letterSpacing(0.0, DimensionUnit::FP);
676 TextModelNG::SetLetterSpacing(frameNode, letterSpacing);
677 }
678
SetTextFont(ArkUINodeHandle node,const struct ArkUIFontWithOptionsStruct * fontInfo)679 void SetTextFont(ArkUINodeHandle node, const struct ArkUIFontWithOptionsStruct* fontInfo)
680 {
681 CHECK_NULL_VOID(fontInfo);
682 auto* frameNode = reinterpret_cast<FrameNode*>(node);
683 CHECK_NULL_VOID(frameNode);
684 Font font;
685 font.fontSize = Dimension(fontInfo->fontSizeNumber, static_cast<DimensionUnit>(fontInfo->fontSizeUnit));
686 font.fontStyle = static_cast<Ace::FontStyle>(fontInfo->fontStyle);
687 font.fontWeight = static_cast<FontWeight>(fontInfo->fontWeight);
688 std::vector<std::string> families;
689 if (fontInfo->fontFamilies && fontInfo->familyLength > 0) {
690 if (fontInfo->familyLength > DEFAULT_MAX_FONT_FAMILY_LENGTH) {
691 return;
692 }
693 families.resize(fontInfo->familyLength);
694 for (uint32_t i = 0; i < fontInfo->familyLength; i++) {
695 families.at(i) = std::string(*(fontInfo->fontFamilies + i));
696 }
697 }
698 font.fontFamilies = families;
699 TextModelNG::SetFont(frameNode, font);
700 TextModelNG::SetVariableFontWeight(frameNode, fontInfo->variableFontWeight);
701 TextModelNG::SetEnableVariableFontWeight(frameNode, fontInfo->enableVariableFontWeight);
702 }
703
ResetTextFont(ArkUINodeHandle node)704 void ResetTextFont(ArkUINodeHandle node)
705 {
706 auto* frameNode = reinterpret_cast<FrameNode*>(node);
707 CHECK_NULL_VOID(frameNode);
708 Font font;
709 font.fontSize = DEFAULT_FONT_SIZE;
710 font.fontWeight = DEFAULT_FONT_WEIGHT;
711 font.fontStyle = DEFAULT_FONT_STYLE;
712 std::vector<std::string> families;
713 families.emplace_back(DEFAULT_FAMILY);
714 font.fontFamilies = families;
715 TextModelNG::SetFont(frameNode, font);
716 TextModelNG::SetVariableFontWeight(frameNode, DEFAULT_VARIABLE_FONT_WEIGHT);
717 TextModelNG::SetEnableVariableFontWeight(frameNode, false);
718 }
719
SetWordBreak(ArkUINodeHandle node,ArkUI_Uint32 wordBreak)720 void SetWordBreak(ArkUINodeHandle node, ArkUI_Uint32 wordBreak)
721 {
722 auto* frameNode = reinterpret_cast<FrameNode*>(node);
723 CHECK_NULL_VOID(frameNode);
724 if (wordBreak < 0 || wordBreak >= WORD_BREAK_TYPES.size()) {
725 wordBreak = 2; // 2 is the default value of WordBreak::BREAK_WORD
726 }
727 TextModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[wordBreak]);
728 }
729
ResetWordBreak(ArkUINodeHandle node)730 void ResetWordBreak(ArkUINodeHandle node)
731 {
732 auto* frameNode = reinterpret_cast<FrameNode*>(node);
733 CHECK_NULL_VOID(frameNode);
734 TextModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[2]); // 2 is the default value of WordBreak::BREAK_WORD
735 }
736
SetEllipsisMode(ArkUINodeHandle node,ArkUI_Uint32 ellipsisMode)737 void SetEllipsisMode(ArkUINodeHandle node, ArkUI_Uint32 ellipsisMode)
738 {
739 auto* frameNode = reinterpret_cast<FrameNode*>(node);
740 CHECK_NULL_VOID(frameNode);
741 if (ellipsisMode < 0 || ellipsisMode >= ELLIPSIS_MODALS.size()) {
742 ellipsisMode = 2; // 2 is the default value of EllipsisMode::TAIL
743 }
744 TextModelNG::SetEllipsisMode(frameNode, ELLIPSIS_MODALS[ellipsisMode]);
745 }
746
ResetEllipsisMode(ArkUINodeHandle node)747 void ResetEllipsisMode(ArkUINodeHandle node)
748 {
749 auto* frameNode = reinterpret_cast<FrameNode*>(node);
750 CHECK_NULL_VOID(frameNode);
751 TextModelNG::SetEllipsisMode(frameNode, ELLIPSIS_MODALS[2]); // 2 is the default value of EllipsisMode::TAIL
752 }
753
SetTextDetectEnable(ArkUINodeHandle node,ArkUI_Uint32 value)754 void SetTextDetectEnable(ArkUINodeHandle node, ArkUI_Uint32 value)
755 {
756 auto* frameNode = reinterpret_cast<FrameNode*>(node);
757 CHECK_NULL_VOID(frameNode);
758 TextModelNG::SetTextDetectEnable(frameNode, static_cast<bool>(value));
759 }
760
GetTextDetectEnable(ArkUINodeHandle node)761 ArkUI_Int32 GetTextDetectEnable(ArkUINodeHandle node)
762 {
763 auto* frameNode = reinterpret_cast<FrameNode*>(node);
764 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
765 return static_cast<ArkUI_Int32>(TextModelNG::GetTextDetectEnable(frameNode));
766 }
767
ResetTextDetectEnable(ArkUINodeHandle node)768 void ResetTextDetectEnable(ArkUINodeHandle node)
769 {
770 auto* frameNode = reinterpret_cast<FrameNode*>(node);
771 CHECK_NULL_VOID(frameNode);
772 TextModelNG::SetTextDetectEnable(frameNode, DEFAULT_ENABLE_TEXT_DETECTOR);
773 }
774
GetFontFamily(ArkUINodeHandle node)775 ArkUI_CharPtr GetFontFamily(ArkUINodeHandle node)
776 {
777 auto* frameNode = reinterpret_cast<FrameNode*>(node);
778 CHECK_NULL_RETURN(frameNode, nullptr);
779 std::vector<std::string> fontFamilies = TextModelNG::GetFontFamily(frameNode);
780 std::string families;
781 //set index start
782 uint32_t index = 0;
783 for (auto& family : fontFamilies) {
784 families += family;
785 if (index != fontFamilies.size() - 1) {
786 families += ",";
787 }
788 index++;
789 }
790 g_strValue = families;
791 return g_strValue.c_str();
792 }
793
GetCopyOption(ArkUINodeHandle node)794 ArkUI_Int32 GetCopyOption(ArkUINodeHandle node)
795 {
796 auto* frameNode = reinterpret_cast<FrameNode*>(node);
797 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
798 return static_cast<ArkUI_Int32>(TextModelNG::GetCopyOption(frameNode));
799 }
800
GetHeightAdaptivePolicy(ArkUINodeHandle node)801 ArkUI_Int32 GetHeightAdaptivePolicy(ArkUINodeHandle node)
802 {
803 auto* frameNode = reinterpret_cast<FrameNode*>(node);
804 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
805 return TEXT_HEIGHT_ADAPTIVE_POLICY_MAP[TextModelNG::GetHeightAdaptivePolicy(frameNode)];
806 }
807
GetTextMinFontSize(ArkUINodeHandle node)808 ArkUI_Float32 GetTextMinFontSize(ArkUINodeHandle node)
809 {
810 auto* frameNode = reinterpret_cast<FrameNode*>(node);
811 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
812 return static_cast<ArkUI_Float32>(TextModelNG::GetAdaptMinFontSize(frameNode).Value());
813 }
814
GetTextMaxFontSize(ArkUINodeHandle node)815 ArkUI_Float32 GetTextMaxFontSize(ArkUINodeHandle node)
816 {
817 auto* frameNode = reinterpret_cast<FrameNode*>(node);
818 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
819 return static_cast<ArkUI_Float32>(TextModelNG::GetAdaptMaxFontSize(frameNode).Value());
820 }
821
GetFont(ArkUINodeHandle node,ArkUITextFont * font)822 void GetFont(ArkUINodeHandle node, ArkUITextFont* font)
823 {
824 auto* frameNode = reinterpret_cast<FrameNode*>(node);
825 CHECK_NULL_VOID(frameNode);
826 Font value = TextModelNG::GetFont(frameNode);
827 if (value.fontSize.has_value()) {
828 font->fontSize = value.fontSize.value().GetNativeValue(static_cast<DimensionUnit>(font->fontSizeUnit));
829 }
830 if (value.fontWeight.has_value()) {
831 font->fontWeight = static_cast<ArkUI_Int32>(value.fontWeight.value());
832 }
833 if (!value.fontFamilies.empty()) {
834 std::string families;
835 //set index start
836 std::size_t index = 0;
837 for (auto& family : value.fontFamilies) {
838 families += family;
839 if (index != value.fontFamilies.size() - 1) {
840 families += ",";
841 }
842 index++;
843 }
844 g_strValue = families;
845 font->fontFamilies = g_strValue.c_str();
846 } else {
847 font->fontFamilies = "HarmonyOS Sans";
848 }
849 if (value.fontStyle.has_value()) {
850 font->fontStyle = static_cast<ArkUI_Int32>(value.fontStyle.value());
851 }
852 }
853
GetFontSize(ArkUINodeHandle node,ArkUI_Int32 unit)854 ArkUI_Float32 GetFontSize(ArkUINodeHandle node, ArkUI_Int32 unit)
855 {
856 auto* frameNode = reinterpret_cast<FrameNode*>(node);
857 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
858 return static_cast<ArkUI_Float32>(
859 TextModelNG::GetFontSize(frameNode).GetNativeValue(static_cast<DimensionUnit>(unit)));
860 }
861
GetFontWeight(ArkUINodeHandle node)862 ArkUI_Int32 GetFontWeight(ArkUINodeHandle node)
863 {
864 auto* frameNode = reinterpret_cast<FrameNode*>(node);
865 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
866 return static_cast<ArkUI_Int32>(TextModelNG::GetFontWeight(frameNode));
867 }
868
GetItalicFontStyle(ArkUINodeHandle node)869 ArkUI_Int32 GetItalicFontStyle(ArkUINodeHandle node)
870 {
871 auto* frameNode = reinterpret_cast<FrameNode*>(node);
872 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
873 return static_cast<ArkUI_Int32>(TextModelNG::GetItalicFontStyle(frameNode));
874 }
875
GetTextWordBreak(ArkUINodeHandle node)876 ArkUI_Int32 GetTextWordBreak(ArkUINodeHandle node)
877 {
878 auto* frameNode = reinterpret_cast<FrameNode*>(node);
879 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
880 return static_cast<ArkUI_Int32>(TextModelNG::GetWordBreak(frameNode));
881 }
882
GetTextEllipsisMode(ArkUINodeHandle node)883 ArkUI_Int32 GetTextEllipsisMode(ArkUINodeHandle node)
884 {
885 auto* frameNode = reinterpret_cast<FrameNode*>(node);
886 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
887 return static_cast<ArkUI_Int32>(TextModelNG::GetEllipsisMode(frameNode));
888 }
889
SetTextFontFeature(ArkUINodeHandle node,ArkUI_CharPtr value)890 void SetTextFontFeature(ArkUINodeHandle node, ArkUI_CharPtr value)
891 {
892 auto* frameNode = reinterpret_cast<FrameNode*>(node);
893 CHECK_NULL_VOID(frameNode);
894 std::string strValue = value;
895 TextModelNG::SetFontFeature(frameNode, ParseFontFeatureSettings(strValue));
896 }
897
ResetTextFontFeature(ArkUINodeHandle node)898 void ResetTextFontFeature(ArkUINodeHandle node)
899 {
900 auto* frameNode = reinterpret_cast<FrameNode*>(node);
901 CHECK_NULL_VOID(frameNode);
902 std::string strValue = "";
903 TextModelNG::SetFontFeature(frameNode, ParseFontFeatureSettings(strValue));
904 }
905
SetTextDataDetectorConfig(ArkUINodeHandle node,ArkUI_Uint32 * values,ArkUI_Int32 size)906 void SetTextDataDetectorConfig(ArkUINodeHandle node, ArkUI_Uint32* values, ArkUI_Int32 size)
907 {
908 std::string textTypes;
909 for (int i = 0; i < size; i++) {
910 auto index = values[i];
911 if (index < 0 || index >= TEXT_DETECT_TYPES.size()) {
912 continue;
913 }
914 if (i != 0) {
915 textTypes.append(",");
916 }
917 textTypes.append(TEXT_DETECT_TYPES[index]);
918 }
919 auto* frameNode = reinterpret_cast<FrameNode*>(node);
920 CHECK_NULL_VOID(frameNode);
921 TextModelNG::SetTextDetectConfig(frameNode, textTypes);
922 }
923
GetTextDataDetectorConfig(ArkUINodeHandle node,ArkUI_Int32 (* values)[32])924 ArkUI_Int32 GetTextDataDetectorConfig(ArkUINodeHandle node, ArkUI_Int32 (*values)[32])
925 {
926 auto* frameNode = reinterpret_cast<FrameNode*>(node);
927 CHECK_NULL_RETURN(frameNode, 0);
928 auto typeString = TextModelNG::GetTextDetectConfig(frameNode);
929 std::vector<std::string> types;
930 StringUtils::StringSplitter(typeString, ',', types);
931 for (uint32_t i = 0; i < types.size(); i++) {
932 auto ret = std::find(TEXT_DETECT_TYPES.begin(), TEXT_DETECT_TYPES.end(), types[i]);
933 (*values)[i] = ret != TEXT_DETECT_TYPES.end() ? ret - TEXT_DETECT_TYPES.begin() : -1;
934 }
935 return types.size();
936 }
937
ResetTextDataDetectorConfig(ArkUINodeHandle node)938 void ResetTextDataDetectorConfig(ArkUINodeHandle node)
939 {
940 auto* frameNode = reinterpret_cast<FrameNode*>(node);
941 CHECK_NULL_VOID(frameNode);
942 TextModelNG::SetTextDetectConfig(frameNode, "");
943 }
944
GetTextFontFeature(ArkUINodeHandle node)945 ArkUI_CharPtr GetTextFontFeature(ArkUINodeHandle node)
946 {
947 auto* frameNode = reinterpret_cast<FrameNode*>(node);
948 CHECK_NULL_RETURN(frameNode, nullptr);
949 g_strValue = UnParseFontFeatureSetting(TextModelNG::GetFontFeature(frameNode));
950 return g_strValue.c_str();
951 }
952
SetTextLineSpacing(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)953 void SetTextLineSpacing(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
954 {
955 auto* frameNode = reinterpret_cast<FrameNode*>(node);
956 CHECK_NULL_VOID(frameNode);
957 TextModelNG::SetLineSpacing(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
958 }
959
GetTextLineSpacing(ArkUINodeHandle node)960 float GetTextLineSpacing(ArkUINodeHandle node)
961 {
962 auto* frameNode = reinterpret_cast<FrameNode*>(node);
963 CHECK_NULL_RETURN(frameNode, 0.0f);
964 return TextModelNG::GetLineSpacing(frameNode);
965 }
966
ResetTextLineSpacing(ArkUINodeHandle node)967 void ResetTextLineSpacing(ArkUINodeHandle node)
968 {
969 auto* frameNode = reinterpret_cast<FrameNode*>(node);
970 CHECK_NULL_VOID(frameNode);
971 TextModelNG::SetLineSpacing(frameNode, DEFAULT_LINE_SPACING);
972 }
973
SetTextCaretColor(ArkUINodeHandle node,ArkUI_Uint32 color)974 void SetTextCaretColor(ArkUINodeHandle node, ArkUI_Uint32 color)
975 {
976 auto *frameNode = reinterpret_cast<FrameNode *>(node);
977 CHECK_NULL_VOID(frameNode);
978 TextModelNG::SetCaretColor(frameNode, Color(color));
979 }
980
GetTextCaretColor(ArkUINodeHandle node)981 ArkUI_Uint32 GetTextCaretColor(ArkUINodeHandle node)
982 {
983 auto *frameNode = reinterpret_cast<FrameNode *>(node);
984 CHECK_NULL_RETURN(frameNode, Color::BLACK.GetValue());
985 return TextModelNG::GetCaretColor(frameNode).GetValue();
986 }
987
ResetTextCaretColor(ArkUINodeHandle node)988 void ResetTextCaretColor(ArkUINodeHandle node)
989 {
990 auto *frameNode = reinterpret_cast<FrameNode *>(node);
991 CHECK_NULL_VOID(frameNode);
992 auto pipeline = frameNode->GetContext();
993 CHECK_NULL_VOID(pipeline);
994 auto theme = pipeline->GetThemeManager()->GetTheme<TextTheme>();
995 CHECK_NULL_VOID(theme);
996 auto caretColor = static_cast<int32_t>(theme->GetCaretColor().GetValue());
997 TextModelNG::SetCaretColor(frameNode, Color(caretColor));
998 }
999
SetTextSelectedBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)1000 void SetTextSelectedBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
1001 {
1002 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1003 CHECK_NULL_VOID(frameNode);
1004 TextModelNG::SetSelectedBackgroundColor(frameNode, Color(color));
1005 }
1006
GetTextSelectedBackgroundColor(ArkUINodeHandle node)1007 ArkUI_Uint32 GetTextSelectedBackgroundColor(ArkUINodeHandle node)
1008 {
1009 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1010 CHECK_NULL_RETURN(frameNode, Color::BLACK.GetValue());
1011 return TextModelNG::GetSelectedBackgroundColor(frameNode).GetValue();
1012 }
1013
ResetTextSelectedBackgroundColor(ArkUINodeHandle node)1014 void ResetTextSelectedBackgroundColor(ArkUINodeHandle node)
1015 {
1016 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1017 CHECK_NULL_VOID(frameNode);
1018 TextModelNG::ResetSelectedBackgroundColor(frameNode);
1019 }
1020
SetLineBreakStrategy(ArkUINodeHandle node,ArkUI_Uint32 lineBreakStrategy)1021 void SetLineBreakStrategy(ArkUINodeHandle node, ArkUI_Uint32 lineBreakStrategy)
1022 {
1023 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1024 CHECK_NULL_VOID(frameNode);
1025 if (lineBreakStrategy < 0 || lineBreakStrategy >= LINE_BREAK_STRATEGY_TYPES.size()) {
1026 lineBreakStrategy = 0; // 0 is the default value of LineBreakStrategy::GREEDY
1027 }
1028 TextModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[lineBreakStrategy]);
1029 }
1030
ResetLineBreakStrategy(ArkUINodeHandle node)1031 void ResetLineBreakStrategy(ArkUINodeHandle node)
1032 {
1033 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1034 CHECK_NULL_VOID(frameNode);
1035 // 0 is the default value of LineBreakStrategy::GREEDY
1036 TextModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[0]);
1037 }
1038
GetTextLineBreakStrategy(ArkUINodeHandle node)1039 ArkUI_Int32 GetTextLineBreakStrategy(ArkUINodeHandle node)
1040 {
1041 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1042 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1043 return static_cast<ArkUI_Int32>(TextModelNG::GetLineBreakStrategy(frameNode));
1044 }
1045
SetTextContentWithStyledString(ArkUINodeHandle node,ArkUI_StyledString * styledString)1046 void SetTextContentWithStyledString(ArkUINodeHandle node, ArkUI_StyledString* styledString)
1047 {
1048 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1049 CHECK_NULL_VOID(frameNode);
1050 CHECK_NULL_VOID(styledString);
1051 TextModelNG::SetTextContentWithStyledString(frameNode, styledString);
1052 }
1053
ResetTextContentWithStyledString(ArkUINodeHandle node)1054 void ResetTextContentWithStyledString(ArkUINodeHandle node)
1055 {
1056 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1057 CHECK_NULL_VOID(frameNode);
1058 TextModelNG::SetTextContentWithStyledString(frameNode, nullptr);
1059 }
1060
SetTextSelection(ArkUINodeHandle node,int32_t startIndex,int32_t endIndex)1061 void SetTextSelection(ArkUINodeHandle node, int32_t startIndex, int32_t endIndex)
1062 {
1063 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1064 CHECK_NULL_VOID(frameNode);
1065 TextModelNG::SetTextSelection(frameNode, startIndex, endIndex);
1066 }
1067
ResetTextSelection(ArkUINodeHandle node)1068 void ResetTextSelection(ArkUINodeHandle node)
1069 {
1070 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1071 CHECK_NULL_VOID(frameNode);
1072 TextModelNG::SetTextSelection(frameNode, DEFAULT_SELECTION, DEFAULT_SELECTION);
1073 }
1074
SetTextSelectableMode(ArkUINodeHandle node,ArkUI_Uint32 textSelectableMode)1075 void SetTextSelectableMode(ArkUINodeHandle node, ArkUI_Uint32 textSelectableMode)
1076 {
1077 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1078 CHECK_NULL_VOID(frameNode);
1079 if (textSelectableMode < 0 || textSelectableMode >= TEXT_SELECTABLE_MODE.size()) {
1080 textSelectableMode = 0;
1081 }
1082 TextModelNG::SetTextSelectableMode(frameNode, TEXT_SELECTABLE_MODE[textSelectableMode]);
1083 }
1084
ResetTextSelectableMode(ArkUINodeHandle node)1085 void ResetTextSelectableMode(ArkUINodeHandle node)
1086 {
1087 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1088 CHECK_NULL_VOID(frameNode);
1089 TextModelNG::SetTextSelectableMode(frameNode, TEXT_SELECTABLE_MODE[0]);
1090 }
1091
SetTextDataDetectorConfigWithEvent(ArkUINodeHandle node,const struct ArkUITextDetectConfigStruct * arkUITextDetectConfig)1092 void SetTextDataDetectorConfigWithEvent(
1093 ArkUINodeHandle node, const struct ArkUITextDetectConfigStruct* arkUITextDetectConfig)
1094 {
1095 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1096 CHECK_NULL_VOID(frameNode);
1097 TextDetectConfig textDetectConfig;
1098 textDetectConfig.types = arkUITextDetectConfig->types;
1099 if (arkUITextDetectConfig->onResult) {
1100 textDetectConfig.onResult =
1101 std::move(*(reinterpret_cast<std::function<void(const std::string&)>*>(arkUITextDetectConfig->onResult)));
1102 }
1103 textDetectConfig.entityColor = Color(arkUITextDetectConfig->entityColor);
1104 textDetectConfig.entityDecorationType = TextDecoration(arkUITextDetectConfig->entityDecorationType);
1105 textDetectConfig.entityDecorationColor = Color(arkUITextDetectConfig->entityDecorationColor);
1106 textDetectConfig.entityDecorationStyle = TextDecorationStyle(arkUITextDetectConfig->entityDecorationStyle);
1107 TextModelNG::SetTextDetectConfig(frameNode, textDetectConfig);
1108 }
1109
ResetTextDataDetectorConfigWithEvent(ArkUINodeHandle node)1110 void ResetTextDataDetectorConfigWithEvent(ArkUINodeHandle node)
1111 {
1112 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1113 CHECK_NULL_VOID(frameNode);
1114 TextDetectConfig textDetectConfig;
1115 TextModelNG::SetTextDetectConfig(frameNode, textDetectConfig);
1116 }
1117
SetTextOnCopy(ArkUINodeHandle node,void * callback)1118 void SetTextOnCopy(ArkUINodeHandle node, void* callback)
1119 {
1120 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1121 CHECK_NULL_VOID(frameNode);
1122 if (callback) {
1123 auto onCopy = reinterpret_cast<std::function<void(const std::u16string&)>*>(callback);
1124 TextModelNG::SetOnCopy(frameNode, std::move(*onCopy));
1125 } else {
1126 TextModelNG::SetOnCopy(frameNode, nullptr);
1127 }
1128 }
1129
ResetTextOnCopy(ArkUINodeHandle node)1130 void ResetTextOnCopy(ArkUINodeHandle node)
1131 {
1132 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1133 CHECK_NULL_VOID(frameNode);
1134 TextModelNG::SetOnCopy(frameNode, nullptr);
1135 }
1136
SetTextOnTextSelectionChange(ArkUINodeHandle node,void * callback)1137 void SetTextOnTextSelectionChange(ArkUINodeHandle node, void* callback)
1138 {
1139 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1140 CHECK_NULL_VOID(frameNode);
1141 if (callback) {
1142 auto onChange = reinterpret_cast<std::function<void(int32_t, int32_t)>*>(callback);
1143 TextModelNG::SetOnTextSelectionChange(frameNode, std::move(*onChange));
1144 } else {
1145 TextModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1146 }
1147 }
1148
ResetTextOnTextSelectionChange(ArkUINodeHandle node)1149 void ResetTextOnTextSelectionChange(ArkUINodeHandle node)
1150 {
1151 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1152 CHECK_NULL_VOID(frameNode);
1153 TextModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1154 }
1155
SetTextSelectionMenuOptions(ArkUINodeHandle node,void * onCreateMenuCallback,void * onMenuItemClickCallback)1156 void SetTextSelectionMenuOptions(ArkUINodeHandle node, void* onCreateMenuCallback, void* onMenuItemClickCallback)
1157 {
1158 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1159 CHECK_NULL_VOID(frameNode);
1160 if (onCreateMenuCallback) {
1161 NG::OnCreateMenuCallback onCreateMenu = *(reinterpret_cast<NG::OnCreateMenuCallback*>(onCreateMenuCallback));
1162 TextModelNG::OnCreateMenuCallbackUpdate(frameNode, std::move(onCreateMenu));
1163 } else {
1164 TextModelNG::OnCreateMenuCallbackUpdate(frameNode, nullptr);
1165 }
1166 if (onMenuItemClickCallback) {
1167 NG::OnMenuItemClickCallback onMenuItemClick =
1168 *(reinterpret_cast<NG::OnMenuItemClickCallback*>(onMenuItemClickCallback));
1169 TextModelNG::OnMenuItemClickCallbackUpdate(frameNode, std::move(onMenuItemClick));
1170 } else {
1171 TextModelNG::OnMenuItemClickCallbackUpdate(frameNode, nullptr);
1172 }
1173 }
1174
ResetTextSelectionMenuOptions(ArkUINodeHandle node)1175 void ResetTextSelectionMenuOptions(ArkUINodeHandle node)
1176 {
1177 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1178 CHECK_NULL_VOID(frameNode);
1179 NG::OnCreateMenuCallback onCreateMenuCallback;
1180 NG::OnMenuItemClickCallback onMenuItemClick;
1181 TextModelNG::OnCreateMenuCallbackUpdate(frameNode, std::move(onCreateMenuCallback));
1182 TextModelNG::OnMenuItemClickCallbackUpdate(frameNode, std::move(onMenuItemClick));
1183 }
1184
SetTextHalfLeading(ArkUINodeHandle node,ArkUI_Bool value)1185 void SetTextHalfLeading(ArkUINodeHandle node, ArkUI_Bool value)
1186 {
1187 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1188 CHECK_NULL_VOID(frameNode);
1189 TextModelNG::SetHalfLeading(frameNode, value);
1190 }
1191
ResetTextHalfLeading(ArkUINodeHandle node)1192 void ResetTextHalfLeading(ArkUINodeHandle node)
1193 {
1194 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1195 CHECK_NULL_VOID(frameNode);
1196 TextModelNG::SetHalfLeading(frameNode, false);
1197 }
1198
GetTextHalfLeading(ArkUINodeHandle node)1199 ArkUI_Int32 GetTextHalfLeading(ArkUINodeHandle node)
1200 {
1201 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1202 CHECK_NULL_RETURN(frameNode, false);
1203 return static_cast<ArkUI_Int32>(TextModelNG::GetHalfLeading(frameNode));
1204 }
1205
SetTextEnableHapticFeedback(ArkUINodeHandle node,ArkUI_Uint32 value)1206 void SetTextEnableHapticFeedback(ArkUINodeHandle node, ArkUI_Uint32 value)
1207 {
1208 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1209 CHECK_NULL_VOID(frameNode);
1210 TextModelNG::SetEnableHapticFeedback(frameNode, static_cast<bool>(value));
1211 }
1212
ResetTextEnableHapticFeedback(ArkUINodeHandle node)1213 void ResetTextEnableHapticFeedback(ArkUINodeHandle node)
1214 {
1215 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1216 CHECK_NULL_VOID(frameNode);
1217 TextModelNG::SetEnableHapticFeedback(frameNode, DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE);
1218 }
1219
SetMarqueeOptions(ArkUINodeHandle node,struct ArkUITextMarqueeOptions * value)1220 void SetMarqueeOptions(ArkUINodeHandle node, struct ArkUITextMarqueeOptions* value)
1221 {
1222 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1223 CHECK_NULL_VOID(frameNode);
1224
1225 TextMarqueeOptions marqueeOptions;
1226 marqueeOptions.UpdateTextMarqueeStart(value->start);
1227 marqueeOptions.UpdateTextMarqueeStep(value->step);
1228 marqueeOptions.UpdateTextMarqueeLoop(value->loop);
1229 marqueeOptions.UpdateTextMarqueeDirection(value->fromStart ? MarqueeDirection::LEFT : MarqueeDirection::RIGHT);
1230 marqueeOptions.UpdateTextMarqueeDelay(value->delay);
1231 marqueeOptions.UpdateTextMarqueeFadeout(value->fadeout);
1232 marqueeOptions.UpdateTextMarqueeStartPolicy(static_cast<MarqueeStartPolicy>(value->marqueeStartPolicy));
1233
1234 TextModelNG::SetMarqueeOptions(frameNode, marqueeOptions);
1235 }
1236
ResetMarqueeOptions(ArkUINodeHandle node)1237 void ResetMarqueeOptions(ArkUINodeHandle node)
1238 {
1239 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1240 CHECK_NULL_VOID(frameNode);
1241 TextMarqueeOptions marqueeOptions;
1242 TextModelNG::SetMarqueeOptions(frameNode, marqueeOptions);
1243 }
1244
SetOnMarqueeStateChange(ArkUINodeHandle node,void * callback)1245 void SetOnMarqueeStateChange(ArkUINodeHandle node, void* callback)
1246 {
1247 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1248 CHECK_NULL_VOID(frameNode);
1249 if (callback) {
1250 auto onChange = reinterpret_cast<std::function<void(int32_t)>*>(callback);
1251 TextModelNG::SetOnMarqueeStateChange(frameNode, std::move(*onChange));
1252 } else {
1253 TextModelNG::SetOnMarqueeStateChange(frameNode, nullptr);
1254 }
1255 }
1256
ResetOnMarqueeStateChange(ArkUINodeHandle node)1257 void ResetOnMarqueeStateChange(ArkUINodeHandle node)
1258 {
1259 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1260 CHECK_NULL_VOID(frameNode);
1261 TextModelNG::SetOnMarqueeStateChange(frameNode, nullptr);
1262 }
1263 } // namespace
1264
1265 namespace NodeModifier {
GetTextModifier()1266 const ArkUITextModifier* GetTextModifier()
1267 {
1268 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1269 static const ArkUITextModifier modifier = {
1270 .setContent = SetTextContent,
1271 .setFontWeight = SetFontWeight,
1272 .resetFontWeight = ResetFontWeight,
1273 .setFontStyle = SetFontStyle,
1274 .resetFontStyle = ResetFontStyle,
1275 .setTextAlign = SetTextAlign,
1276 .resetTextAlign = ResetTextAlign,
1277 .setFontColor = SetFontColor,
1278 .resetFontColor = ResetFontColor,
1279 .setTextForegroundColor = SetTextForegroundColor,
1280 .resetTextForegroundColor = ResetTextForegroundColor,
1281 .setFontSize = SetFontSize,
1282 .resetFontSize = ResetFontSize,
1283 .setTextLineHeight = SetTextLineHeight,
1284 .resetTextLineHeight = ResetTextLineHeight,
1285 .setTextOverflow = SetTextTextOverflow,
1286 .resetTextOverflow = ResetTextTextOverflow,
1287 .setTextDecoration = SetTextDecoration,
1288 .resetTextDecoration = ResetTextDecoration,
1289 .setTextCase = SetTextTextCase,
1290 .resetTextCase = ResetTextTextCase,
1291 .setTextMaxLines = SetTextMaxLines,
1292 .resetTextMaxLines = ResetTextMaxLines,
1293 .setTextMinFontSize = SetTextMinFontSize,
1294 .resetTextMinFontSize = ResetTextMinFontSize,
1295 .setTextDraggable = SetTextDraggable,
1296 .resetTextDraggable = ResetTextDraggable,
1297 .setTextPrivacySensitive = SetTextPrivacySensitve,
1298 .resetTextPrivacySensitive = ResetTextPrivacySensitve,
1299 .setTextMaxFontSize = SetTextMaxFontSize,
1300 .resetTextMaxFontSize = ResetTextMaxFontSize,
1301 .setTextFontFamily = SetTextFontFamily,
1302 .resetTextFontFamily = ResetTextFontFamily,
1303 .setTextCopyOption = SetTextCopyOption,
1304 .resetTextCopyOption = ResetTextCopyOption,
1305 .setTextShadow = SetTextTextShadow,
1306 .resetTextShadow = ResetTextTextShadow,
1307 .setTextHeightAdaptivePolicy = SetTextHeightAdaptivePolicy,
1308 .resetTextHeightAdaptivePolicy = ResetTextHeightAdaptivePolicy,
1309 .setTextIndent = SetTextTextIndent,
1310 .resetTextIndent = ResetTextTextIndent,
1311 .setTextBaselineOffset = SetTextBaselineOffset,
1312 .resetTextBaselineOffset = ResetTextBaselineOffset,
1313 .setTextLetterSpacing = SetTextLetterSpacing,
1314 .resetTextLetterSpacing = ResetTextLetterSpacing,
1315 .setTextFont = SetTextFont,
1316 .resetTextFont = ResetTextFont,
1317 .setFontWeightStr = SetFontWeightStr,
1318 .setFontWeightWithOption = SetFontWeightWithOption,
1319 .setWordBreak = SetWordBreak,
1320 .resetWordBreak = ResetWordBreak,
1321 .getFontFamily = GetFontFamily,
1322 .getCopyOption = GetCopyOption,
1323 .getHeightAdaptivePolicy = GetHeightAdaptivePolicy,
1324 .getTextMinFontSize = GetTextMinFontSize,
1325 .getTextMaxFontSize = GetTextMaxFontSize,
1326 .getFont = GetFont,
1327 .getFontSize = GetFontSize,
1328 .getFontWeight = GetFontWeight,
1329 .getItalicFontStyle = GetItalicFontStyle,
1330 .setEllipsisMode = SetEllipsisMode,
1331 .resetEllipsisMode = ResetEllipsisMode,
1332 .setEnableDataDetector = SetTextDetectEnable,
1333 .resetEnableDataDetector = ResetTextDetectEnable,
1334 .getTextContent = GetTextContent,
1335 .getTextLineHeight = GetTextLineHeight,
1336 .getTextDecoration = GetTextDecoration,
1337 .getTextTextCase = GetTextTextCase,
1338 .getTextLetterSpacing = GetTextLetterSpacing,
1339 .getTextMaxLines = GetTextMaxLines,
1340 .getTextAlign = GetTextAlign,
1341 .getTextTextOverflow = GetTextTextOverflow,
1342 .getTextTextIndent = GetTextTextIndent,
1343 .getFontColor = GetFontColor,
1344 .getTextBaselineOffset = GetTextBaselineOffset,
1345 .getTextShadowsCount = GetTextShadowCount,
1346 .getTextShadows = GetTextShadow,
1347 .getTextWordBreak = GetTextWordBreak,
1348 .getTextEllipsisMode = GetTextEllipsisMode,
1349 .setTextFontFeature = SetTextFontFeature,
1350 .resetTextFontFeature = ResetTextFontFeature,
1351 .setTextLineSpacing = SetTextLineSpacing,
1352 .getTextLineSpacing = GetTextLineSpacing,
1353 .resetTextLineSpacing = ResetTextLineSpacing,
1354 .getTextFontFeature = GetTextFontFeature,
1355 .getEnableDataDetector = GetTextDetectEnable,
1356 .setTextDataDetectorConfig = SetTextDataDetectorConfig,
1357 .getTextDataDetectorConfig = GetTextDataDetectorConfig,
1358 .resetTextDataDetectorConfig = ResetTextDataDetectorConfig,
1359 .setLineBreakStrategy = SetLineBreakStrategy,
1360 .resetLineBreakStrategy = ResetLineBreakStrategy,
1361 .getTextLineBreakStrategy = GetTextLineBreakStrategy,
1362 .setTextCaretColor = SetTextCaretColor,
1363 .getTextCaretColor = GetTextCaretColor,
1364 .resetTextCaretColor = ResetTextCaretColor,
1365 .setTextSelectedBackgroundColor = SetTextSelectedBackgroundColor,
1366 .getTextSelectedBackgroundColor = GetTextSelectedBackgroundColor,
1367 .resetTextSelectedBackgroundColor = ResetTextSelectedBackgroundColor,
1368 .setTextContentWithStyledString = SetTextContentWithStyledString,
1369 .resetTextContentWithStyledString = ResetTextContentWithStyledString,
1370 .setTextSelection = SetTextSelection,
1371 .resetTextSelection = ResetTextSelection,
1372 .setTextSelectableMode = SetTextSelectableMode,
1373 .resetTextSelectableMode = ResetTextSelectableMode,
1374 .setTextDataDetectorConfigWithEvent = SetTextDataDetectorConfigWithEvent,
1375 .resetTextDataDetectorConfigWithEvent = ResetTextDataDetectorConfigWithEvent,
1376 .setTextOnCopy = SetTextOnCopy,
1377 .resetTextOnCopy = ResetTextOnCopy,
1378 .setTextOnTextSelectionChange = SetTextOnTextSelectionChange,
1379 .resetTextOnTextSelectionChange = ResetTextOnTextSelectionChange,
1380 .setTextMinFontScale = SetTextMinFontScale,
1381 .resetTextMinFontScale = ResetTextMinFontScale,
1382 .setTextMaxFontScale = SetTextMaxFontScale,
1383 .resetTextMaxFontScale = ResetTextMaxFontScale,
1384 .setTextSelectionMenuOptions = SetTextSelectionMenuOptions,
1385 .resetTextSelectionMenuOptions = ResetTextSelectionMenuOptions,
1386 .setTextHalfLeading = SetTextHalfLeading,
1387 .resetTextHalfLeading = ResetTextHalfLeading,
1388 .getTextHalfLeading = GetTextHalfLeading,
1389 .setTextOnClick = SetOnClick,
1390 .resetTextOnClick = ResetOnClick,
1391 .setTextResponseRegion = SetResponseRegion,
1392 .resetTextResponseRegion = ResetResponseRegion,
1393 .setTextEnableHapticFeedback = SetTextEnableHapticFeedback,
1394 .resetTextEnableHapticFeedback = ResetTextEnableHapticFeedback,
1395 .setTextMarqueeOptions = SetMarqueeOptions,
1396 .resetTextMarqueeOptions = ResetMarqueeOptions,
1397 .setOnMarqueeStateChange = SetOnMarqueeStateChange,
1398 .resetOnMarqueeStateChange = ResetOnMarqueeStateChange,
1399 .setImmutableFontWeight = SetImmutableFontWeight,
1400 };
1401 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1402
1403 return &modifier;
1404 }
1405
GetCJUITextModifier()1406 const CJUITextModifier* GetCJUITextModifier()
1407 {
1408 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1409 static const CJUITextModifier modifier = {
1410 .setContent = SetTextContent,
1411 .setFontWeight = SetFontWeight,
1412 .resetFontWeight = ResetFontWeight,
1413 .setFontStyle = SetFontStyle,
1414 .resetFontStyle = ResetFontStyle,
1415 .setTextAlign = SetTextAlign,
1416 .resetTextAlign = ResetTextAlign,
1417 .setFontColor = SetFontColor,
1418 .resetFontColor = ResetFontColor,
1419 .setTextForegroundColor = SetTextForegroundColor,
1420 .resetTextForegroundColor = ResetTextForegroundColor,
1421 .setFontSize = SetFontSize,
1422 .resetFontSize = ResetFontSize,
1423 .setTextLineHeight = SetTextLineHeight,
1424 .resetTextLineHeight = ResetTextLineHeight,
1425 .setTextOverflow = SetTextTextOverflow,
1426 .resetTextOverflow = ResetTextTextOverflow,
1427 .setTextDecoration = SetTextDecoration,
1428 .resetTextDecoration = ResetTextDecoration,
1429 .setTextCase = SetTextTextCase,
1430 .resetTextCase = ResetTextTextCase,
1431 .setTextMaxLines = SetTextMaxLines,
1432 .resetTextMaxLines = ResetTextMaxLines,
1433 .setTextMinFontSize = SetTextMinFontSize,
1434 .resetTextMinFontSize = ResetTextMinFontSize,
1435 .setTextDraggable = SetTextDraggable,
1436 .resetTextDraggable = ResetTextDraggable,
1437 .setTextPrivacySensitive = SetTextPrivacySensitve,
1438 .resetTextPrivacySensitive = ResetTextPrivacySensitve,
1439 .setTextMaxFontSize = SetTextMaxFontSize,
1440 .resetTextMaxFontSize = ResetTextMaxFontSize,
1441 .setTextFontFamily = SetTextFontFamily,
1442 .resetTextFontFamily = ResetTextFontFamily,
1443 .setTextCopyOption = SetTextCopyOption,
1444 .resetTextCopyOption = ResetTextCopyOption,
1445 .setTextShadow = SetTextTextShadow,
1446 .resetTextShadow = ResetTextTextShadow,
1447 .setTextHeightAdaptivePolicy = SetTextHeightAdaptivePolicy,
1448 .resetTextHeightAdaptivePolicy = ResetTextHeightAdaptivePolicy,
1449 .setTextIndent = SetTextTextIndent,
1450 .resetTextIndent = ResetTextTextIndent,
1451 .setTextBaselineOffset = SetTextBaselineOffset,
1452 .resetTextBaselineOffset = ResetTextBaselineOffset,
1453 .setTextLetterSpacing = SetTextLetterSpacing,
1454 .resetTextLetterSpacing = ResetTextLetterSpacing,
1455 .setTextFont = SetTextFont,
1456 .resetTextFont = ResetTextFont,
1457 .setFontWeightStr = SetFontWeightStr,
1458 .setWordBreak = SetWordBreak,
1459 .resetWordBreak = ResetWordBreak,
1460 .getFontFamily = GetFontFamily,
1461 .getCopyOption = GetCopyOption,
1462 .getHeightAdaptivePolicy = GetHeightAdaptivePolicy,
1463 .getTextMinFontSize = GetTextMinFontSize,
1464 .getTextMaxFontSize = GetTextMaxFontSize,
1465 .getFont = GetFont,
1466 .getFontSize = GetFontSize,
1467 .getFontWeight = GetFontWeight,
1468 .getItalicFontStyle = GetItalicFontStyle,
1469 .setEllipsisMode = SetEllipsisMode,
1470 .resetEllipsisMode = ResetEllipsisMode,
1471 .setEnableDataDetector = SetTextDetectEnable,
1472 .resetEnableDataDetector = ResetTextDetectEnable,
1473 .getTextContent = GetTextContent,
1474 .getTextLineHeight = GetTextLineHeight,
1475 .getTextDecoration = GetTextDecoration,
1476 .getTextTextCase = GetTextTextCase,
1477 .getTextLetterSpacing = GetTextLetterSpacing,
1478 .getTextMaxLines = GetTextMaxLines,
1479 .getTextAlign = GetTextAlign,
1480 .getTextTextOverflow = GetTextTextOverflow,
1481 .getTextTextIndent = GetTextTextIndent,
1482 .getFontColor = GetFontColor,
1483 .getTextBaselineOffset = GetTextBaselineOffset,
1484 .getTextShadowsCount = GetTextShadowCount,
1485 .getTextShadows = GetTextShadow,
1486 .getTextWordBreak = GetTextWordBreak,
1487 .getTextEllipsisMode = GetTextEllipsisMode,
1488 .setTextFontFeature = SetTextFontFeature,
1489 .resetTextFontFeature = ResetTextFontFeature,
1490 .getTextFontFeature = GetTextFontFeature,
1491 .getEnableDataDetector = GetTextDetectEnable,
1492 .setTextDataDetectorConfig = SetTextDataDetectorConfig,
1493 .getTextDataDetectorConfig = GetTextDataDetectorConfig,
1494 .resetTextDataDetectorConfig = ResetTextDataDetectorConfig,
1495 .setTextLineSpacing = SetTextLineSpacing,
1496 .getTextLineSpacing = GetTextLineSpacing,
1497 .resetTextLineSpacing = ResetTextLineSpacing,
1498 .setTextSelectedBackgroundColor = SetTextSelectedBackgroundColor,
1499 .getTextSelectedBackgroundColor = GetTextSelectedBackgroundColor,
1500 .resetTextSelectedBackgroundColor = ResetTextSelectedBackgroundColor,
1501 .setLineBreakStrategy = SetLineBreakStrategy,
1502 .resetLineBreakStrategy = ResetLineBreakStrategy,
1503 .getTextLineBreakStrategy = GetTextLineBreakStrategy,
1504 .setTextContentWithStyledString = SetTextContentWithStyledString,
1505 .resetTextContentWithStyledString = ResetTextContentWithStyledString,
1506 .setTextSelection = SetTextSelection,
1507 .resetTextSelection = ResetTextSelection,
1508 .setTextSelectableMode = SetTextSelectableMode,
1509 .resetTextSelectableMode = ResetTextSelectableMode,
1510 .setTextDataDetectorConfigWithEvent = SetTextDataDetectorConfigWithEvent,
1511 .resetTextDataDetectorConfigWithEvent = ResetTextDataDetectorConfigWithEvent,
1512 .setTextOnCopy = SetTextOnCopy,
1513 .resetTextOnCopy = ResetTextOnCopy,
1514 .setTextOnTextSelectionChange = SetTextOnTextSelectionChange,
1515 .resetTextOnTextSelectionChange = ResetTextOnTextSelectionChange,
1516 .setFontWeightWithOption = SetFontWeightWithOption,
1517 .setTextMinFontScale = SetTextMinFontScale,
1518 .resetTextMinFontScale = ResetTextMinFontScale,
1519 .setTextMaxFontScale = SetTextMaxFontScale,
1520 .resetTextMaxFontScale = ResetTextMaxFontScale,
1521 .setTextSelectionMenuOptions = SetTextSelectionMenuOptions,
1522 .resetTextSelectionMenuOptions = ResetTextSelectionMenuOptions,
1523 .setTextHalfLeading = SetTextHalfLeading,
1524 .resetTextHalfLeading = ResetTextHalfLeading,
1525 .getTextHalfLeading = GetTextHalfLeading,
1526 .setTextOnClick = SetOnClick,
1527 .resetTextOnClick = ResetOnClick,
1528 .setTextResponseRegion = SetResponseRegion,
1529 .resetTextResponseRegion = ResetResponseRegion,
1530 };
1531 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1532
1533 return &modifier;
1534 }
1535
SetOnDetectResultUpdate(ArkUINodeHandle node,void * extraParam)1536 void SetOnDetectResultUpdate(ArkUINodeHandle node, void* extraParam)
1537 {
1538 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1539 CHECK_NULL_VOID(frameNode);
1540 auto onDetectResultUpdate = [node, extraParam](const std::string& str) {
1541 ArkUINodeEvent event;
1542 event.kind = TEXT_INPUT;
1543 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1544 event.textInputEvent.subKind = ON_DETECT_RESULT_UPDATE;
1545 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
1546 SendArkUISyncEvent(&event);
1547 };
1548 TextModelNG::SetOnDetectResultUpdate(frameNode, std::move(onDetectResultUpdate));
1549 }
1550
ResetOnDetectResultUpdate(ArkUINodeHandle node)1551 void ResetOnDetectResultUpdate(ArkUINodeHandle node)
1552 {
1553 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1554 CHECK_NULL_VOID(frameNode);
1555 TextModelNG::SetOnDetectResultUpdate(frameNode, nullptr);
1556 }
1557 } // namespace NodeModifier
1558 } // namespace OHOS::Ace::NG
1559