1 /*
2 * Copyright (c) 2023 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_area_modifier.h"
16
17 #include "bridge/common/utils/utils.h"
18 #include "base/utils/utf_helper.h"
19 #include "core/components/text_field/textfield_theme.h"
20 #include "core/components_ng/pattern/text_field/text_field_model_ng.h"
21 #include "core/components/common/properties/text_style_parser.h"
22 #include "interfaces/native/node/node_model.h"
23
24 namespace OHOS::Ace::NG {
25 namespace {
26 constexpr int NUM_0 = 0;
27 constexpr int NUM_1 = 1;
28 constexpr int NUM_2 = 2;
29 constexpr int NUM_3 = 3;
30 constexpr int NUM_4 = 4;
31 constexpr int NUM_16 = 16;
32 constexpr int NUM_24 = 24;
33 constexpr int NUM_36 = 36;
34 constexpr int DEFAULT_LENGTH = 4;
35 constexpr InputStyle DEFAULT_TEXT_AREA_STYLE = InputStyle::DEFAULT;
36 constexpr bool DEFAULT_SELECTION_MENU_HIDDEN = false;
37 constexpr uint32_t DEFAULT_MAX_VIEW_LINE = 3;
38 constexpr CopyOptions DEFAULT_COPY_OPTIONS_VALUE = CopyOptions::Local;
39 constexpr FontWeight DEFAULT_FONT_WEIGHT = FontWeight::NORMAL;
40 constexpr Ace::FontStyle DEFAULT_FONT_STYLE = Ace::FontStyle::NORMAL;
41 constexpr DisplayMode DEFAULT_BAR_STATE_VALUE = DisplayMode::AUTO;
42 constexpr bool DEFAULT_KEY_BOARD_VALUE = true;
43 constexpr bool DEFAULT_ENABLE_AUTO_FILL = true;
44 constexpr float DEFAULT_MIN_FONT_SCALE = 0.0f;
45 constexpr float DEFAULT_MAX_FONT_SCALE = static_cast<float>(INT32_MAX);
46 constexpr char DEFAULT_FONT_FAMILY[] = "HarmonyOS Sans";
47 const double DEFAULT_DASH_DIMENSION = -1;
48 const uint32_t ERROR_UINT_CODE = -1;
49 const int32_t ERROR_INT_CODE = -1;
50 constexpr TextDecoration DEFAULT_TEXT_DECORATION = TextDecoration::NONE;
51 constexpr Color DEFAULT_DECORATION_COLOR = Color(0xff000000);
52 constexpr TextDecorationStyle DEFAULT_DECORATION_STYLE = TextDecorationStyle::SOLID;
53 const std::vector<EllipsisMode> ELLIPSIS_MODALS = { EllipsisMode::HEAD, EllipsisMode::MIDDLE, EllipsisMode::TAIL };
54 constexpr int16_t DEFAULT_ALPHA = 255;
55 constexpr double DEFAULT_OPACITY = 0.2;
56 const float ERROR_FLOAT_CODE = -1.0f;
57 std::string g_strValue;
58 constexpr bool DEFAULT_ENABLE_PREVIEW_TEXT_VALUE = true;
59 constexpr bool DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE = true;
60 constexpr int32_t ELLIPSIS_MODE_TAIL = 2;
61
SetTextAreaStyle(ArkUINodeHandle node,ArkUI_Int32 style)62 void SetTextAreaStyle(ArkUINodeHandle node, ArkUI_Int32 style)
63 {
64 auto *frameNode = reinterpret_cast<FrameNode *>(node);
65 CHECK_NULL_VOID(frameNode);
66 TextFieldModelNG::SetInputStyle(frameNode, static_cast<InputStyle>(style));
67 }
68
ResetTextAreaStyle(ArkUINodeHandle node)69 void ResetTextAreaStyle(ArkUINodeHandle node)
70 {
71 auto *frameNode = reinterpret_cast<FrameNode *>(node);
72 CHECK_NULL_VOID(frameNode);
73 TextFieldModelNG::SetInputStyle(frameNode, DEFAULT_TEXT_AREA_STYLE);
74 }
75
SetTextAreaSelectionMenuHidden(ArkUINodeHandle node,ArkUI_Uint32 contextMenuHidden)76 void SetTextAreaSelectionMenuHidden(ArkUINodeHandle node, ArkUI_Uint32 contextMenuHidden)
77 {
78 auto *frameNode = reinterpret_cast<FrameNode *>(node);
79 CHECK_NULL_VOID(frameNode);
80 TextFieldModelNG::SetSelectionMenuHidden(frameNode, static_cast<bool>(contextMenuHidden));
81 }
82
ResetTextAreaSelectionMenuHidden(ArkUINodeHandle node)83 void ResetTextAreaSelectionMenuHidden(ArkUINodeHandle node)
84 {
85 auto *frameNode = reinterpret_cast<FrameNode *>(node);
86 CHECK_NULL_VOID(frameNode);
87 TextFieldModelNG::SetSelectionMenuHidden(frameNode, DEFAULT_SELECTION_MENU_HIDDEN);
88 }
89
SetTextAreaMaxLines(ArkUINodeHandle node,ArkUI_Uint32 maxLine)90 void SetTextAreaMaxLines(ArkUINodeHandle node, ArkUI_Uint32 maxLine)
91 {
92 auto *frameNode = reinterpret_cast<FrameNode *>(node);
93 CHECK_NULL_VOID(frameNode);
94 TextFieldModelNG::SetMaxViewLines(frameNode, maxLine);
95 TextFieldModelNG::SetNormalMaxViewLines(frameNode, maxLine);
96 }
97
SetTextAreaMinFontScale(ArkUINodeHandle node,ArkUI_Float32 number)98 void SetTextAreaMinFontScale(ArkUINodeHandle node, ArkUI_Float32 number)
99 {
100 auto* frameNode = reinterpret_cast<FrameNode*>(node);
101 CHECK_NULL_VOID(frameNode);
102 TextFieldModelNG::SetMinFontScale(frameNode, number);
103 }
104
ResetTextAreaMinFontScale(ArkUINodeHandle node)105 void ResetTextAreaMinFontScale(ArkUINodeHandle node)
106 {
107 auto* frameNode = reinterpret_cast<FrameNode*>(node);
108 CHECK_NULL_VOID(frameNode);
109 TextFieldModelNG::SetMinFontScale(frameNode, DEFAULT_MIN_FONT_SCALE);
110 }
111
SetTextAreaMaxFontScale(ArkUINodeHandle node,ArkUI_Float32 number)112 void SetTextAreaMaxFontScale(ArkUINodeHandle node, ArkUI_Float32 number)
113 {
114 auto* frameNode = reinterpret_cast<FrameNode*>(node);
115 CHECK_NULL_VOID(frameNode);
116 TextFieldModelNG::SetMaxFontScale(frameNode, number);
117 }
118
ResetTextAreaMaxFontScale(ArkUINodeHandle node)119 void ResetTextAreaMaxFontScale(ArkUINodeHandle node)
120 {
121 auto* frameNode = reinterpret_cast<FrameNode*>(node);
122 CHECK_NULL_VOID(frameNode);
123 TextFieldModelNG::SetMaxFontScale(frameNode, DEFAULT_MAX_FONT_SCALE);
124 }
125
ResetTextAreaMaxLines(ArkUINodeHandle node)126 void ResetTextAreaMaxLines(ArkUINodeHandle node)
127 {
128 auto *frameNode = reinterpret_cast<FrameNode *>(node);
129 CHECK_NULL_VOID(frameNode);
130 TextFieldModelNG::SetMaxViewLines(frameNode, DEFAULT_MAX_VIEW_LINE);
131 TextFieldModelNG::SetNormalMaxViewLines(frameNode, Infinity<uint32_t>());
132 }
133
SetTextAreaCopyOption(ArkUINodeHandle node,ArkUI_Int32 value)134 void SetTextAreaCopyOption(ArkUINodeHandle node, ArkUI_Int32 value)
135 {
136 auto *frameNode = reinterpret_cast<FrameNode *>(node);
137 CHECK_NULL_VOID(frameNode);
138 TextFieldModelNG::SetCopyOption(frameNode, static_cast<CopyOptions>(value));
139 }
140
ResetTextAreaCopyOption(ArkUINodeHandle node)141 void ResetTextAreaCopyOption(ArkUINodeHandle node)
142 {
143 auto *frameNode = reinterpret_cast<FrameNode *>(node);
144 CHECK_NULL_VOID(frameNode);
145 TextFieldModelNG::SetCopyOption(frameNode, DEFAULT_COPY_OPTIONS_VALUE);
146 }
147
SetTextAreaPlaceholderColor(ArkUINodeHandle node,ArkUI_Uint32 color)148 void SetTextAreaPlaceholderColor(ArkUINodeHandle node, ArkUI_Uint32 color)
149 {
150 auto *frameNode = reinterpret_cast<FrameNode *>(node);
151 CHECK_NULL_VOID(frameNode);
152 TextFieldModelNG::SetPlaceholderColor(frameNode, Color(color));
153 }
154
ResetTextAreaPlaceholderColor(ArkUINodeHandle node)155 void ResetTextAreaPlaceholderColor(ArkUINodeHandle node)
156 {
157 auto *frameNode = reinterpret_cast<FrameNode *>(node);
158 CHECK_NULL_VOID(frameNode);
159 TextFieldModelNG::ResetPlaceholderColor(frameNode);
160 }
161
SetTextAreaTextAlign(ArkUINodeHandle node,ArkUI_Int32 value)162 void SetTextAreaTextAlign(ArkUINodeHandle node, ArkUI_Int32 value)
163 {
164 auto *frameNode = reinterpret_cast<FrameNode *>(node);
165 CHECK_NULL_VOID(frameNode);
166 TextAlign value_textAlign = static_cast<TextAlign>(value);
167 TextFieldModelNG::SetTextAlign(frameNode, value_textAlign);
168 }
169
ResetTextAreaTextAlign(ArkUINodeHandle node)170 void ResetTextAreaTextAlign(ArkUINodeHandle node)
171 {
172 auto *frameNode = reinterpret_cast<FrameNode *>(node);
173 CHECK_NULL_VOID(frameNode);
174 TextFieldModelNG::SetTextAlign(frameNode, TextAlign::START);
175 }
176
SetTextAreaPlaceholderFont(ArkUINodeHandle node,const struct ArkUIResourceLength * size,ArkUI_CharPtr weight,ArkUI_CharPtr family,ArkUI_Int32 style)177 void SetTextAreaPlaceholderFont(ArkUINodeHandle node, const struct ArkUIResourceLength *size, ArkUI_CharPtr weight,
178 ArkUI_CharPtr family, ArkUI_Int32 style)
179 {
180 auto *frameNode = reinterpret_cast<FrameNode *>(node);
181 CHECK_NULL_VOID(frameNode);
182 Font font;
183 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(size->unit);
184 if (size->unit >= 0) {
185 if (unitEnum == DimensionUnit::CALC) {
186 font.fontSize = CalcDimension(size->string, DimensionUnit::CALC);
187 } else {
188 font.fontSize = CalcDimension(size->value, unitEnum);
189 }
190 } else {
191 auto pipeline = frameNode->GetContext();
192 CHECK_NULL_VOID(pipeline);
193 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
194 CHECK_NULL_VOID(theme);
195 font.fontSize = theme->GetFontSize();
196 }
197
198 if (weight != nullptr) {
199 font.fontWeight = Framework::ConvertStrToFontWeight(weight);
200 } else {
201 font.fontWeight = DEFAULT_FONT_WEIGHT;
202 }
203
204 if (family != nullptr) {
205 font.fontFamilies = Framework::ConvertStrToFontFamilies(std::string(family));
206 } else {
207 std::vector<std::string> fontFamilies;
208 fontFamilies.emplace_back(std::string(DEFAULT_FONT_FAMILY));
209 font.fontFamilies = fontFamilies;
210 }
211
212 if (style >= 0) {
213 font.fontStyle = static_cast<Ace::FontStyle>(style);
214 } else {
215 font.fontStyle = DEFAULT_FONT_STYLE;
216 }
217 TextFieldModelNG::SetPlaceholderFont(frameNode, font);
218 }
219
SetTextAreaPlaceholderFontEnum(ArkUINodeHandle node,const struct ArkUIResourceLength * size,ArkUI_Int32 weight,ArkUI_CharPtr family,ArkUI_Int32 style)220 void SetTextAreaPlaceholderFontEnum(ArkUINodeHandle node, const struct ArkUIResourceLength* size, ArkUI_Int32 weight,
221 ArkUI_CharPtr family, ArkUI_Int32 style)
222 {
223 auto *frameNode = reinterpret_cast<FrameNode *>(node);
224 CHECK_NULL_VOID(frameNode);
225 Font font;
226 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(size->unit);
227 if (size->unit >= 0) {
228 if (unitEnum == DimensionUnit::CALC) {
229 font.fontSize = CalcDimension(size->string, DimensionUnit::CALC);
230 } else {
231 font.fontSize = CalcDimension(size->value, unitEnum);
232 }
233 } else {
234 auto pipeline = frameNode->GetContext();
235 CHECK_NULL_VOID(pipeline);
236 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
237 CHECK_NULL_VOID(theme);
238 font.fontSize = theme->GetFontSize();
239 }
240
241 if (weight > -1) {
242 font.fontWeight = static_cast<FontWeight>(weight);
243 } else {
244 font.fontWeight = DEFAULT_FONT_WEIGHT;
245 }
246
247 if (family != nullptr) {
248 font.fontFamilies = Framework::ConvertStrToFontFamilies(std::string(family));
249 } else {
250 std::vector<std::string> fontFamilies;
251 fontFamilies.emplace_back(std::string(DEFAULT_FONT_FAMILY));
252 font.fontFamilies = fontFamilies;
253 }
254
255 if (style >= 0) {
256 font.fontStyle = static_cast<Ace::FontStyle>(style);
257 } else {
258 font.fontStyle = DEFAULT_FONT_STYLE;
259 }
260 TextFieldModelNG::SetPlaceholderFont(frameNode, font);
261 }
262
ResetTextAreaPlaceholderFont(ArkUINodeHandle node)263 void ResetTextAreaPlaceholderFont(ArkUINodeHandle node)
264 {
265 auto *frameNode = reinterpret_cast<FrameNode *>(node);
266 CHECK_NULL_VOID(frameNode);
267 auto pipeline = frameNode->GetContext();
268 CHECK_NULL_VOID(pipeline);
269 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
270 CHECK_NULL_VOID(theme);
271 Font font;
272 font.fontSize = theme->GetFontSize();
273 font.fontWeight = DEFAULT_FONT_WEIGHT;
274 font.fontStyle = DEFAULT_FONT_STYLE;
275 std::vector<std::string> fontFamilies;
276 fontFamilies.emplace_back(std::string(DEFAULT_FONT_FAMILY));
277 font.fontFamilies = fontFamilies;
278 TextFieldModelNG::SetPlaceholderFont(frameNode, font);
279 }
280
SetTextAreaBarState(ArkUINodeHandle node,ArkUI_Uint32 barStateValue)281 void SetTextAreaBarState(ArkUINodeHandle node, ArkUI_Uint32 barStateValue)
282 {
283 auto *frameNode = reinterpret_cast<FrameNode *>(node);
284 CHECK_NULL_VOID(frameNode);
285 DisplayMode displayMode = static_cast<DisplayMode>(barStateValue);
286 TextFieldModelNG::SetBarState(frameNode, displayMode);
287 }
288
ResetTextAreaBarState(ArkUINodeHandle node)289 void ResetTextAreaBarState(ArkUINodeHandle node)
290 {
291 auto *frameNode = reinterpret_cast<FrameNode *>(node);
292 CHECK_NULL_VOID(frameNode);
293 TextFieldModelNG::SetBarState(frameNode, DEFAULT_BAR_STATE_VALUE);
294 }
295
SetTextAreaEnableKeyboardOnFocus(ArkUINodeHandle node,ArkUI_Uint32 keyboardOnFocusValue)296 void SetTextAreaEnableKeyboardOnFocus(ArkUINodeHandle node, ArkUI_Uint32 keyboardOnFocusValue)
297 {
298 auto *frameNode = reinterpret_cast<FrameNode *>(node);
299 CHECK_NULL_VOID(frameNode);
300 TextFieldModelNG::RequestKeyboardOnFocus(frameNode, static_cast<bool>(keyboardOnFocusValue));
301 }
302
ResetTextAreaEnableKeyboardOnFocus(ArkUINodeHandle node)303 void ResetTextAreaEnableKeyboardOnFocus(ArkUINodeHandle node)
304 {
305 auto *frameNode = reinterpret_cast<FrameNode *>(node);
306 CHECK_NULL_VOID(frameNode);
307 TextFieldModelNG::RequestKeyboardOnFocus(frameNode, DEFAULT_KEY_BOARD_VALUE);
308 }
309
SetTextAreaFontFamily(ArkUINodeHandle node,ArkUI_CharPtr fontFamily)310 void SetTextAreaFontFamily(ArkUINodeHandle node, ArkUI_CharPtr fontFamily)
311 {
312 auto *frameNode = reinterpret_cast<FrameNode *>(node);
313 CHECK_NULL_VOID(frameNode);
314 std::vector<std::string> fontFamilies;
315 fontFamilies = Framework::ConvertStrToFontFamilies(std::string(fontFamily));
316 TextFieldModelNG::SetFontFamily(frameNode, fontFamilies);
317 }
318
ResetTextAreaFontFamily(ArkUINodeHandle node)319 void ResetTextAreaFontFamily(ArkUINodeHandle node)
320 {
321 auto *frameNode = reinterpret_cast<FrameNode *>(node);
322 CHECK_NULL_VOID(frameNode);
323 std::vector<std::string> fontFamilies;
324 fontFamilies.emplace_back(std::string(DEFAULT_FONT_FAMILY));
325 TextFieldModelNG::SetFontFamily(frameNode, fontFamilies);
326 }
327
SetTextAreaShowCounter(ArkUINodeHandle node,ArkUI_Uint32 value)328 void SetTextAreaShowCounter(ArkUINodeHandle node, ArkUI_Uint32 value)
329 {
330 auto *frameNode = reinterpret_cast<FrameNode *>(node);
331 CHECK_NULL_VOID(frameNode);
332 TextFieldModelNG::SetShowCounter(frameNode, static_cast<bool>(value));
333 }
334
ResetTextAreaShowCounter(ArkUINodeHandle node)335 void ResetTextAreaShowCounter(ArkUINodeHandle node)
336 {
337 auto *frameNode = reinterpret_cast<FrameNode *>(node);
338 CHECK_NULL_VOID(frameNode);
339 TextFieldModelNG::SetShowCounter(frameNode, false);
340 }
341
SetTextAreaCaretColor(ArkUINodeHandle node,ArkUI_Uint32 color)342 void SetTextAreaCaretColor(ArkUINodeHandle node, ArkUI_Uint32 color)
343 {
344 auto *frameNode = reinterpret_cast<FrameNode *>(node);
345 CHECK_NULL_VOID(frameNode);
346 TextFieldModelNG::SetCaretColor(frameNode, Color(color));
347 }
348
ResetTextAreaCaretColor(ArkUINodeHandle node)349 void ResetTextAreaCaretColor(ArkUINodeHandle node)
350 {
351 auto *frameNode = reinterpret_cast<FrameNode *>(node);
352 CHECK_NULL_VOID(frameNode);
353 TextFieldModelNG::ResetCaretColor(frameNode);
354 }
355
SetTextAreaMaxLength(ArkUINodeHandle node,ArkUI_Int32 value)356 void SetTextAreaMaxLength(ArkUINodeHandle node, ArkUI_Int32 value)
357 {
358 auto *frameNode = reinterpret_cast<FrameNode *>(node);
359 CHECK_NULL_VOID(frameNode);
360 TextFieldModelNG::SetMaxLength(frameNode, value);
361 }
362
ResetTextAreaMaxLength(ArkUINodeHandle node)363 void ResetTextAreaMaxLength(ArkUINodeHandle node)
364 {
365 auto *frameNode = reinterpret_cast<FrameNode *>(node);
366 CHECK_NULL_VOID(frameNode);
367 TextFieldModelNG::ResetMaxLength(frameNode);
368 }
369
SetTextAreaFontColor(ArkUINodeHandle node,ArkUI_Uint32 color)370 void SetTextAreaFontColor(ArkUINodeHandle node, ArkUI_Uint32 color)
371 {
372 auto *frameNode = reinterpret_cast<FrameNode *>(node);
373 CHECK_NULL_VOID(frameNode);
374 TextFieldModelNG::SetTextColor(frameNode, Color(color));
375 }
376
ResetTextAreaFontColor(ArkUINodeHandle node)377 void ResetTextAreaFontColor(ArkUINodeHandle node)
378 {
379 auto *frameNode = reinterpret_cast<FrameNode *>(node);
380 CHECK_NULL_VOID(frameNode);
381 TextFieldModelNG::ResetTextColor(frameNode);
382 }
383
SetTextAreaFontStyle(ArkUINodeHandle node,ArkUI_Uint32 value)384 void SetTextAreaFontStyle(ArkUINodeHandle node, ArkUI_Uint32 value)
385 {
386 auto *frameNode = reinterpret_cast<FrameNode *>(node);
387 CHECK_NULL_VOID(frameNode);
388 TextFieldModelNG::SetFontStyle(frameNode, static_cast<Ace::FontStyle>(value));
389 }
390
ResetTextAreaFontStyle(ArkUINodeHandle node)391 void ResetTextAreaFontStyle(ArkUINodeHandle node)
392 {
393 auto *frameNode = reinterpret_cast<FrameNode *>(node);
394 CHECK_NULL_VOID(frameNode);
395 TextFieldModelNG::SetFontStyle(frameNode, OHOS::Ace::FontStyle::NORMAL);
396 }
397
SetTextAreaFontWeightStr(ArkUINodeHandle node,ArkUI_CharPtr fontWeight)398 void SetTextAreaFontWeightStr(ArkUINodeHandle node, ArkUI_CharPtr fontWeight)
399 {
400 auto *frameNode = reinterpret_cast<FrameNode *>(node);
401 CHECK_NULL_VOID(frameNode);
402 TextFieldModelNG::SetFontWeight(frameNode, Framework::ConvertStrToFontWeight(fontWeight));
403 }
404
SetTextAreaFontWeight(ArkUINodeHandle node,ArkUI_Int32 fontWeight)405 void SetTextAreaFontWeight(ArkUINodeHandle node, ArkUI_Int32 fontWeight)
406 {
407 auto *frameNode = reinterpret_cast<FrameNode *>(node);
408 CHECK_NULL_VOID(frameNode);
409 TextFieldModelNG::SetFontWeight(frameNode, static_cast<FontWeight>(fontWeight));
410 }
411
ResetTextAreaFontWeight(ArkUINodeHandle node)412 void ResetTextAreaFontWeight(ArkUINodeHandle node)
413 {
414 auto *frameNode = reinterpret_cast<FrameNode *>(node);
415 CHECK_NULL_VOID(frameNode);
416 TextFieldModelNG::SetFontWeight(frameNode, OHOS::Ace::FontWeight::NORMAL);
417 }
418
SetTextAreaFontSize(ArkUINodeHandle node,const struct ArkUIResourceLength * size)419 void SetTextAreaFontSize(ArkUINodeHandle node, const struct ArkUIResourceLength *size)
420 {
421 auto *frameNode = reinterpret_cast<FrameNode *>(node);
422 CHECK_NULL_VOID(frameNode);
423 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(size->unit);
424 if (unitEnum == DimensionUnit::CALC) {
425 TextFieldModelNG::SetFontSize(frameNode, CalcDimension(size->string, DimensionUnit::CALC));
426 } else {
427 TextFieldModelNG::SetFontSize(frameNode, CalcDimension(size->value, unitEnum));
428 }
429 }
430
ResetTextAreaFontSize(ArkUINodeHandle node)431 void ResetTextAreaFontSize(ArkUINodeHandle node)
432 {
433 auto *frameNode = reinterpret_cast<FrameNode *>(node);
434 CHECK_NULL_VOID(frameNode);
435 auto pipeline = frameNode->GetContext();
436 CHECK_NULL_VOID(pipeline);
437 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
438 CHECK_NULL_VOID(theme);
439 TextFieldModelNG::SetFontSize(frameNode, Dimension(theme->GetFontSize()));
440 }
441
SetCounterType(ArkUINodeHandle node,ArkUI_Int32 value)442 void SetCounterType(ArkUINodeHandle node, ArkUI_Int32 value)
443 {
444 auto *frameNode = reinterpret_cast<FrameNode *>(node);
445 CHECK_NULL_VOID(frameNode);
446 TextFieldModelNG::SetCounterType(frameNode, value);
447 }
448
SetTextAreaPlaceholderString(ArkUINodeHandle node,ArkUI_CharPtr value)449 void SetTextAreaPlaceholderString(ArkUINodeHandle node, ArkUI_CharPtr value)
450 {
451 auto *frameNode = reinterpret_cast<FrameNode *>(node);
452 CHECK_NULL_VOID(frameNode);
453 std::string placeholderStr(value);
454 TextFieldModelNG::SetTextFieldPlaceHolder(frameNode, UtfUtils::Str8DebugToStr16(placeholderStr));
455 }
456
SetTextAreaTextString(ArkUINodeHandle node,ArkUI_CharPtr value)457 void SetTextAreaTextString(ArkUINodeHandle node, ArkUI_CharPtr value)
458 {
459 auto *frameNode = reinterpret_cast<FrameNode *>(node);
460 CHECK_NULL_VOID(frameNode);
461 std::string textStr(value);
462 TextFieldModelNG::SetTextFieldText(frameNode, UtfUtils::Str8DebugToStr16(textStr));
463 }
464
StopTextAreaTextEditing(ArkUINodeHandle node)465 void StopTextAreaTextEditing(ArkUINodeHandle node)
466 {
467 auto *frameNode = reinterpret_cast<FrameNode *>(node);
468 CHECK_NULL_VOID(frameNode);
469 TextFieldModelNG::StopTextFieldEditing(frameNode);
470 }
471
GetTextAreaPlaceholder(ArkUINodeHandle node)472 ArkUI_CharPtr GetTextAreaPlaceholder(ArkUINodeHandle node)
473 {
474 auto *frameNode = reinterpret_cast<FrameNode *>(node);
475 CHECK_NULL_RETURN(frameNode, "");
476 g_strValue = UtfUtils::Str16DebugToStr8(TextFieldModelNG::GetPlaceholderText(frameNode));
477 return g_strValue.c_str();
478 }
479
GetTextAreaText(ArkUINodeHandle node)480 ArkUI_CharPtr GetTextAreaText(ArkUINodeHandle node)
481 {
482 auto *frameNode = reinterpret_cast<FrameNode *>(node);
483 CHECK_NULL_RETURN(frameNode, "");
484 g_strValue = UtfUtils::Str16DebugToStr8(TextFieldModelNG::GetTextFieldText(frameNode));
485 return g_strValue.c_str();
486 }
487
GetTextAreaCaretColor(ArkUINodeHandle node)488 ArkUI_Uint32 GetTextAreaCaretColor(ArkUINodeHandle node)
489 {
490 auto *frameNode = reinterpret_cast<FrameNode *>(node);
491 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
492 return TextFieldModelNG::GetCaretColor(frameNode).GetValue();
493 }
494
GetTextAreaMaxLength(ArkUINodeHandle node)495 ArkUI_Uint32 GetTextAreaMaxLength(ArkUINodeHandle node)
496 {
497 auto *frameNode = reinterpret_cast<FrameNode *>(node);
498 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
499 return TextFieldModelNG::GetMaxLength(frameNode);
500 }
501
GetTextAreaPlaceholderColor(ArkUINodeHandle node)502 ArkUI_Uint32 GetTextAreaPlaceholderColor(ArkUINodeHandle node)
503 {
504 auto *frameNode = reinterpret_cast<FrameNode *>(node);
505 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
506 return TextFieldModelNG::GetPlaceholderColor(frameNode).GetValue();
507 }
508
GetTextAreaPlaceholderFont(ArkUINodeHandle node,ArkUITextFont * font)509 void GetTextAreaPlaceholderFont(ArkUINodeHandle node, ArkUITextFont* font)
510 {
511 auto* frameNode = reinterpret_cast<FrameNode*>(node);
512 CHECK_NULL_VOID(frameNode);
513 Font value = TextFieldModelNG::GetPlaceholderFont(frameNode);
514 if (value.fontSize.has_value()) {
515 font->fontSize = value.fontSize.value().GetNativeValue(static_cast<DimensionUnit>(font->fontSizeUnit));
516 }
517 if (value.fontWeight.has_value()) {
518 font->fontWeight = static_cast<ArkUI_Int32>(value.fontWeight.value());
519 }
520 if (!value.fontFamilies.empty()) {
521 std::string families;
522 uint32_t index = 0;
523 for (auto& family : value.fontFamilies) {
524 families += family;
525 if (index != value.fontFamilies.size() - 1) {
526 families += ",";
527 }
528 index ++;
529 }
530 g_strValue = families;
531 font->fontFamilies = g_strValue.c_str();
532 }
533 if (value.fontStyle.has_value()) {
534 font->fontStyle = static_cast<ArkUI_Int32>(value.fontStyle.value());
535 }
536 }
537
GetTextAreaEditing(ArkUINodeHandle node)538 ArkUI_Bool GetTextAreaEditing(ArkUINodeHandle node)
539 {
540 auto *frameNode = reinterpret_cast<FrameNode *>(node);
541 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
542 return TextFieldModelNG::GetTextFieldEditing(frameNode);
543 }
544
SetTextAreaBackgroundColor(ArkUINodeHandle node,uint32_t color)545 void SetTextAreaBackgroundColor(ArkUINodeHandle node, uint32_t color)
546 {
547 auto* frameNode = reinterpret_cast<FrameNode*>(node);
548 CHECK_NULL_VOID(frameNode);
549 TextFieldModelNG::SetBackgroundColor(frameNode, Color(color));
550 }
551
ResetTextAreaBackgroundColor(ArkUINodeHandle node)552 void ResetTextAreaBackgroundColor(ArkUINodeHandle node)
553 {
554 auto* frameNode = reinterpret_cast<FrameNode*>(node);
555 CHECK_NULL_VOID(frameNode);
556 TextFieldModelNG::ResetBackgroundColor(frameNode);
557 }
558
SetTextAreaType(ArkUINodeHandle node,ArkUI_Int32 type)559 void SetTextAreaType(ArkUINodeHandle node, ArkUI_Int32 type)
560 {
561 auto* frameNode = reinterpret_cast<FrameNode*>(node);
562 CHECK_NULL_VOID(frameNode);
563 TextFieldModelNG::SetType(frameNode, CastToTextInputType(type));
564 }
565
ResetTextAreaType(ArkUINodeHandle node)566 void ResetTextAreaType(ArkUINodeHandle node)
567 {
568 auto* frameNode = reinterpret_cast<FrameNode*>(node);
569 CHECK_NULL_VOID(frameNode);
570 TextFieldModelNG::SetType(frameNode, Ace::TextInputType::TEXT);
571 }
572
GetTextAreaType(ArkUINodeHandle node)573 ArkUI_Int32 GetTextAreaType(ArkUINodeHandle node)
574 {
575 auto *frameNode = reinterpret_cast<FrameNode *>(node);
576 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
577 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetType(frameNode));
578 }
579
GetTextAreaTextAlign(ArkUINodeHandle node)580 ArkUI_Int32 GetTextAreaTextAlign(ArkUINodeHandle node)
581 {
582 auto *frameNode = reinterpret_cast<FrameNode *>(node);
583 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
584 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetTextAlign(frameNode));
585 }
586
SetTextAreaShowCounterOptions(ArkUINodeHandle node,ArkUI_Bool open,ArkUI_Int32 thresholdPercentage,ArkUI_Bool highlightBorder)587 void SetTextAreaShowCounterOptions(
588 ArkUINodeHandle node, ArkUI_Bool open, ArkUI_Int32 thresholdPercentage, ArkUI_Bool highlightBorder)
589 {
590 auto* frameNode = reinterpret_cast<FrameNode*>(node);
591 CHECK_NULL_VOID(frameNode);
592 TextFieldModelNG::SetShowCounter(frameNode, open);
593 TextFieldModelNG::SetCounterType(frameNode, thresholdPercentage);
594 TextFieldModelNG::SetShowCounterBorder(frameNode, highlightBorder);
595 }
596
ResetTextAreaShowCounterOptions(ArkUINodeHandle node)597 void ResetTextAreaShowCounterOptions(ArkUINodeHandle node)
598 {
599 auto *frameNode = reinterpret_cast<FrameNode *>(node);
600 CHECK_NULL_VOID(frameNode);
601 TextFieldModelNG::SetShowCounter(frameNode, false);
602 TextFieldModelNG::SetCounterType(frameNode, -1);
603 TextFieldModelNG::SetShowCounterBorder(frameNode, true);
604 }
605
GetTextAreaShowCounterOptions(ArkUINodeHandle node,ArkUIShowCountOptions * options)606 void GetTextAreaShowCounterOptions(ArkUINodeHandle node, ArkUIShowCountOptions* options)
607 {
608 auto *frameNode = reinterpret_cast<FrameNode *>(node);
609 CHECK_NULL_VOID(frameNode);
610 options->open = TextFieldModelNG::GetShowCounter(frameNode);
611 options->thresholdPercentage = TextFieldModelNG::GetCounterType(frameNode);
612 options->highlightBorder = TextFieldModelNG::GetShowCounterBorder(frameNode);
613 }
SetTextAreaDecoration(ArkUINodeHandle node,ArkUI_Int32 decoration,ArkUI_Uint32 color,ArkUI_Int32 style)614 void SetTextAreaDecoration(ArkUINodeHandle node, ArkUI_Int32 decoration, ArkUI_Uint32 color, ArkUI_Int32 style)
615 {
616 auto* frameNode = reinterpret_cast<FrameNode*>(node);
617 CHECK_NULL_VOID(frameNode);
618 TextFieldModelNG::SetTextDecoration(frameNode, static_cast<TextDecoration>(decoration));
619 TextFieldModelNG::SetTextDecorationColor(frameNode, Color(color));
620 TextFieldModelNG::SetTextDecorationStyle(frameNode, static_cast<TextDecorationStyle>(style));
621 }
622
ResetTextAreaDecoration(ArkUINodeHandle node)623 void ResetTextAreaDecoration(ArkUINodeHandle node)
624 {
625 auto* frameNode = reinterpret_cast<FrameNode*>(node);
626 CHECK_NULL_VOID(frameNode);
627 TextFieldModelNG::SetTextDecoration(frameNode, DEFAULT_TEXT_DECORATION);
628 TextFieldModelNG::SetTextDecorationColor(frameNode, DEFAULT_DECORATION_COLOR);
629 TextFieldModelNG::SetTextDecorationStyle(frameNode, DEFAULT_DECORATION_STYLE);
630 }
631
SetTextAreaLetterSpacing(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)632 void SetTextAreaLetterSpacing(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
633 {
634 auto* frameNode = reinterpret_cast<FrameNode*>(node);
635 CHECK_NULL_VOID(frameNode);
636 TextFieldModelNG::SetLetterSpacing(frameNode, CalcDimension(value, (DimensionUnit)unit));
637 }
638
ResetTextAreaLetterSpacing(ArkUINodeHandle node)639 void ResetTextAreaLetterSpacing(ArkUINodeHandle node)
640 {
641 auto* frameNode = reinterpret_cast<FrameNode*>(node);
642 CHECK_NULL_VOID(frameNode);
643 CalcDimension value;
644 value.Reset();
645 TextFieldModelNG::SetLetterSpacing(frameNode, value);
646 }
647
GetTextAreaLetterSpacing(ArkUINodeHandle node)648 ArkUI_Float32 GetTextAreaLetterSpacing(ArkUINodeHandle node)
649 {
650 auto* frameNode = reinterpret_cast<FrameNode*>(node);
651 CHECK_NULL_RETURN(frameNode, 0.0f);
652 return TextFieldModelNG::GetLetterSpacing(frameNode).ConvertToFp();
653 }
654
SetTextAreaLineHeight(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)655 void SetTextAreaLineHeight(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
656 {
657 auto* frameNode = reinterpret_cast<FrameNode*>(node);
658 CHECK_NULL_VOID(frameNode);
659 TextFieldModelNG::SetLineHeight(frameNode, CalcDimension(value, (DimensionUnit)unit));
660 }
661
ResetTextAreaLineHeight(ArkUINodeHandle node)662 void ResetTextAreaLineHeight(ArkUINodeHandle node)
663 {
664 auto* frameNode = reinterpret_cast<FrameNode*>(node);
665 CHECK_NULL_VOID(frameNode);
666 CalcDimension value;
667 value.Reset();
668 TextFieldModelNG::SetLineHeight(frameNode, value);
669 }
670
SetTextAreaHalfLeading(ArkUINodeHandle node,ArkUI_Uint32 halfLeading)671 void SetTextAreaHalfLeading(ArkUINodeHandle node, ArkUI_Uint32 halfLeading)
672 {
673 auto* frameNode = reinterpret_cast<FrameNode*>(node);
674 CHECK_NULL_VOID(frameNode);
675 TextFieldModelNG::SetHalfLeading(frameNode, static_cast<bool>(halfLeading));
676 }
677
ResetTextAreaHalfLeading(ArkUINodeHandle node)678 void ResetTextAreaHalfLeading(ArkUINodeHandle node)
679 {
680 auto* frameNode = reinterpret_cast<FrameNode*>(node);
681 CHECK_NULL_VOID(frameNode);
682 bool value = false;
683 TextFieldModelNG::SetHalfLeading(frameNode, value);
684 }
685
SetTextAreaKeyboardAppearance(ArkUINodeHandle node,ArkUI_Uint32 keyboardAppearance)686 void SetTextAreaKeyboardAppearance(ArkUINodeHandle node, ArkUI_Uint32 keyboardAppearance)
687 {
688 auto* frameNode = reinterpret_cast<FrameNode*>(node);
689 CHECK_NULL_VOID(frameNode);
690 auto value = static_cast<KeyboardAppearance>(keyboardAppearance);
691 TextFieldModelNG::SetKeyboardAppearance(frameNode, value);
692 }
693
ResetTextAreaKeyboardAppearance(ArkUINodeHandle node)694 void ResetTextAreaKeyboardAppearance(ArkUINodeHandle node)
695 {
696 auto* frameNode = reinterpret_cast<FrameNode*>(node);
697 CHECK_NULL_VOID(frameNode);
698 auto value = KeyboardAppearance::NONE_IMMERSIVE;
699 TextFieldModelNG::SetKeyboardAppearance(frameNode, value);
700 }
701
SetTextAreaFontFeature(ArkUINodeHandle node,ArkUI_CharPtr value)702 void SetTextAreaFontFeature(ArkUINodeHandle node, ArkUI_CharPtr value)
703 {
704 auto* frameNode = reinterpret_cast<FrameNode*>(node);
705 CHECK_NULL_VOID(frameNode);
706 std::string strValue = value;
707 TextFieldModelNG::SetFontFeature(frameNode, ParseFontFeatureSettings(strValue));
708 }
709
ResetTextAreaFontFeature(ArkUINodeHandle node)710 void ResetTextAreaFontFeature(ArkUINodeHandle node)
711 {
712 auto* frameNode = reinterpret_cast<FrameNode*>(node);
713 std::string strValue = "";
714 TextFieldModelNG::SetFontFeature(frameNode, ParseFontFeatureSettings(strValue));
715 }
716
SetTextAreaWordBreak(ArkUINodeHandle node,ArkUI_Uint32 wordBreak)717 void SetTextAreaWordBreak(ArkUINodeHandle node, ArkUI_Uint32 wordBreak)
718 {
719 auto* frameNode = reinterpret_cast<FrameNode*>(node);
720 CHECK_NULL_VOID(frameNode);
721 if (wordBreak < 0 || wordBreak >= WORD_BREAK_TYPES.size()) {
722 wordBreak = 2; // 2 is the default value of WordBreak::BREAK_WORD
723 }
724 TextFieldModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[wordBreak]);
725 }
726
ResetTextAreaWordBreak(ArkUINodeHandle node)727 void ResetTextAreaWordBreak(ArkUINodeHandle node)
728 {
729 auto* frameNode = reinterpret_cast<FrameNode*>(node);
730 CHECK_NULL_VOID(frameNode);
731 TextFieldModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[2]); // 2 is the default value of WordBreak::BREAK_WORD
732 }
733
SetTextAreaAdaptMinFontSize(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)734 void SetTextAreaAdaptMinFontSize(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
735 {
736 auto *frameNode = reinterpret_cast<FrameNode *>(node);
737 CHECK_NULL_VOID(frameNode);
738 TextFieldModelNG::SetAdaptMinFontSize(frameNode, CalcDimension(value, (DimensionUnit)unit));
739 }
740
ResetTextAreaAdaptMinFontSize(ArkUINodeHandle node)741 void ResetTextAreaAdaptMinFontSize(ArkUINodeHandle node)
742 {
743 auto *frameNode = reinterpret_cast<FrameNode *>(node);
744 CHECK_NULL_VOID(frameNode);
745 auto pipelineContext = frameNode->GetContext();
746 CHECK_NULL_VOID(pipelineContext);
747 auto theme = pipelineContext->GetTheme<TextFieldTheme>();
748 CHECK_NULL_VOID(theme);
749 CalcDimension minFontSize = theme->GetTextStyle().GetAdaptMinFontSize();
750 TextFieldModelNG::SetAdaptMinFontSize(frameNode, minFontSize);
751 }
752
SetTextAreaAdaptMaxFontSize(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)753 void SetTextAreaAdaptMaxFontSize(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
754 {
755 auto *frameNode = reinterpret_cast<FrameNode *>(node);
756 CHECK_NULL_VOID(frameNode);
757 TextFieldModelNG::SetAdaptMaxFontSize(frameNode, CalcDimension(value, (DimensionUnit)unit));
758 }
759
ResetTextAreaAdaptMaxFontSize(ArkUINodeHandle node)760 void ResetTextAreaAdaptMaxFontSize(ArkUINodeHandle node)
761 {
762 auto *frameNode = reinterpret_cast<FrameNode *>(node);
763 CHECK_NULL_VOID(frameNode);
764 auto pipelineContext = frameNode->GetContext();
765 CHECK_NULL_VOID(pipelineContext);
766 auto theme = pipelineContext->GetTheme<TextFieldTheme>();
767 CHECK_NULL_VOID(theme);
768 CalcDimension maxFontSize = theme->GetTextStyle().GetAdaptMaxFontSize();
769 TextFieldModelNG::SetAdaptMaxFontSize(frameNode, maxFontSize);
770 }
771
SetTextAreaHeightAdaptivePolicy(ArkUINodeHandle node,ArkUI_Int32 value)772 void SetTextAreaHeightAdaptivePolicy(ArkUINodeHandle node, ArkUI_Int32 value)
773 {
774 auto *frameNode = reinterpret_cast<FrameNode *>(node);
775 CHECK_NULL_VOID(frameNode);
776 TextFieldModelNG::SetHeightAdaptivePolicy(frameNode, static_cast<Ace::TextHeightAdaptivePolicy>(value));
777 }
778
ResetTextAreaHeightAdaptivePolicy(ArkUINodeHandle node)779 void ResetTextAreaHeightAdaptivePolicy(ArkUINodeHandle node)
780 {
781 auto *frameNode = reinterpret_cast<FrameNode *>(node);
782 CHECK_NULL_VOID(frameNode);
783 TextFieldModelNG::SetHeightAdaptivePolicy(frameNode, TextHeightAdaptivePolicy::MAX_LINES_FIRST);
784 }
785
GetTextAreaSelectionMenuHidden(ArkUINodeHandle node)786 ArkUI_Bool GetTextAreaSelectionMenuHidden(ArkUINodeHandle node)
787 {
788 auto* frameNode = reinterpret_cast<FrameNode*>(node);
789 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
790 return TextFieldModelNG::GetSelectionMenuHidden(frameNode);
791 }
792
SetTextAreaSelectedBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)793 void SetTextAreaSelectedBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
794 {
795 auto* frameNode = reinterpret_cast<FrameNode*>(node);
796 CHECK_NULL_VOID(frameNode);
797 Color selectedColor = Color(color);
798 if (selectedColor.GetAlpha() == DEFAULT_ALPHA) {
799 // Default setting of 20% opacity
800 selectedColor = selectedColor.ChangeOpacity(DEFAULT_OPACITY);
801 }
802 TextFieldModelNG::SetSelectedBackgroundColor(frameNode, Color(color));
803 }
804
ResetTextAreaSelectedBackgroundColor(ArkUINodeHandle node)805 void ResetTextAreaSelectedBackgroundColor(ArkUINodeHandle node)
806 {
807 auto* frameNode = reinterpret_cast<FrameNode*>(node);
808 CHECK_NULL_VOID(frameNode);
809 Color selectedColor;
810 auto pipeline = frameNode->GetContext();
811 CHECK_NULL_VOID(pipeline);
812 auto theme = pipeline->GetTheme<TextFieldTheme>();
813 CHECK_NULL_VOID(theme);
814 selectedColor = theme->GetSelectedColor();
815 if (selectedColor.GetAlpha() == DEFAULT_ALPHA) {
816 // Default setting of 20% opacity
817 selectedColor = selectedColor.ChangeOpacity(DEFAULT_OPACITY);
818 }
819 TextFieldModelNG::SetSelectedBackgroundColor(frameNode, selectedColor);
820 }
821
SetTextAreaCaret(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)822 void SetTextAreaCaret(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
823 {
824 auto* frameNode = reinterpret_cast<FrameNode*>(node);
825 CHECK_NULL_VOID(frameNode);
826 CaretStyle caretStyle;
827 caretStyle.caretWidth = CalcDimension(value, (DimensionUnit)unit);
828 TextFieldModelNG::SetCaretStyle(frameNode, caretStyle);
829 }
830
SetTextAreaCaretStyle(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit,ArkUI_Uint32 caretColor)831 void SetTextAreaCaretStyle(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit, ArkUI_Uint32 caretColor)
832 {
833 auto* frameNode = reinterpret_cast<FrameNode*>(node);
834 CHECK_NULL_VOID(frameNode);
835 CaretStyle caretStyle;
836 caretStyle.caretWidth = CalcDimension(value, (DimensionUnit)unit);
837 TextFieldModelNG::SetCaretStyle(frameNode, caretStyle);
838 TextFieldModelNG::SetCaretColor(frameNode, Color(caretColor));
839 }
840
ResetTextAreaCaretStyle(ArkUINodeHandle node)841 void ResetTextAreaCaretStyle(ArkUINodeHandle node)
842 {
843 auto* frameNode = reinterpret_cast<FrameNode*>(node);
844 auto pipeline = frameNode->GetContext();
845 CHECK_NULL_VOID(pipeline);
846 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
847 CHECK_NULL_VOID(theme);
848 CaretStyle caretStyle;
849 caretStyle.caretWidth = theme->GetCursorWidth();
850 uint32_t caretColor = theme->GetCursorColor().GetValue();
851 TextFieldModelNG::SetCaretStyle(frameNode, caretStyle);
852 TextFieldModelNG::SetCaretColor(frameNode, Color(caretColor));
853 }
854
SetTextAreaTextOverflow(ArkUINodeHandle node,ArkUI_Int32 value)855 void SetTextAreaTextOverflow(ArkUINodeHandle node, ArkUI_Int32 value)
856 {
857 auto* frameNode = reinterpret_cast<FrameNode*>(node);
858 CHECK_NULL_VOID(frameNode);
859 TextOverflow valueTextOverflow = static_cast<TextOverflow>(value);
860 TextFieldModelNG::SetTextOverflow(frameNode, valueTextOverflow);
861 }
862
ResetTextAreaTextOverflow(ArkUINodeHandle node)863 void ResetTextAreaTextOverflow(ArkUINodeHandle node)
864 {
865 auto* frameNode = reinterpret_cast<FrameNode*>(node);
866 CHECK_NULL_VOID(frameNode);
867 TextFieldModelNG::SetTextOverflow(frameNode, TextOverflow::DEFAULT);
868 }
869
SetTextAreaTextIndent(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)870 void SetTextAreaTextIndent(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
871 {
872 auto* frameNode = reinterpret_cast<FrameNode*>(node);
873 CHECK_NULL_VOID(frameNode);
874 TextFieldModelNG::SetTextIndent(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
875 }
876
ResetTextAreaTextIndent(ArkUINodeHandle node)877 void ResetTextAreaTextIndent(ArkUINodeHandle node)
878 {
879 auto* frameNode = reinterpret_cast<FrameNode*>(node);
880 CHECK_NULL_VOID(frameNode);
881 TextFieldModelNG::SetTextIndent(frameNode, CalcDimension(0, DimensionUnit::VP));
882 }
883
SetTextAreaLineSpacing(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)884 void SetTextAreaLineSpacing(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
885 {
886 auto* frameNode = reinterpret_cast<FrameNode*>(node);
887 CHECK_NULL_VOID(frameNode);
888 TextFieldModelNG::SetLineSpacing(frameNode, CalcDimension(value, (DimensionUnit)unit));
889 }
890
ResetTextAreaLineSpacing(ArkUINodeHandle node)891 void ResetTextAreaLineSpacing(ArkUINodeHandle node)
892 {
893 auto* frameNode = reinterpret_cast<FrameNode*>(node);
894 CHECK_NULL_VOID(frameNode);
895 CalcDimension value;
896 value.Reset();
897 TextFieldModelNG::SetLineSpacing(frameNode, value);
898 }
899
GetTextAreaFontFeature(ArkUINodeHandle node)900 ArkUI_CharPtr GetTextAreaFontFeature(ArkUINodeHandle node)
901 {
902 auto* frameNode = reinterpret_cast<FrameNode*>(node);
903 CHECK_NULL_RETURN(frameNode, nullptr);
904 g_strValue = UnParseFontFeatureSetting(TextFieldModelNG::GetFontFeature(frameNode));
905 return g_strValue.c_str();
906 }
907
GetTextAreaAdaptMinFontSize(ArkUINodeHandle node)908 ArkUI_Float32 GetTextAreaAdaptMinFontSize(ArkUINodeHandle node)
909 {
910 auto* frameNode = reinterpret_cast<FrameNode*>(node);
911 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
912 return TextFieldModelNG::GetAdaptMinFontSize(frameNode).Value();
913 }
914
GetTextAreaAdaptMaxFontSize(ArkUINodeHandle node)915 ArkUI_Float32 GetTextAreaAdaptMaxFontSize(ArkUINodeHandle node)
916 {
917 auto* frameNode = reinterpret_cast<FrameNode*>(node);
918 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
919 return TextFieldModelNG::GetAdaptMaxFontSize(frameNode).Value();
920 }
921
GetTextAreaLineHeight(ArkUINodeHandle node)922 ArkUI_Float32 GetTextAreaLineHeight(ArkUINodeHandle node)
923 {
924 auto* frameNode = reinterpret_cast<FrameNode*>(node);
925 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
926 return TextFieldModelNG::GetLineHeight(frameNode).Value();
927 }
928
GetgetTextAreaMaxLines(ArkUINodeHandle node)929 ArkUI_Int32 GetgetTextAreaMaxLines(ArkUINodeHandle node)
930 {
931 auto* frameNode = reinterpret_cast<FrameNode*>(node);
932 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
933 return TextFieldModelNG::GetMaxLines(frameNode);
934 }
SetTextAreaPadding(ArkUINodeHandle node,const struct ArkUISizeType * top,const struct ArkUISizeType * right,const struct ArkUISizeType * bottom,const struct ArkUISizeType * left)935 void SetTextAreaPadding(ArkUINodeHandle node, const struct ArkUISizeType* top, const struct ArkUISizeType* right,
936 const struct ArkUISizeType* bottom, const struct ArkUISizeType* left)
937 {
938 auto* frameNode = reinterpret_cast<FrameNode*>(node);
939 CHECK_NULL_VOID(frameNode);
940 CalcLength topDimen;
941 CalcLength rightDimen;
942 CalcLength bottomDimen;
943 CalcLength leftDimen;
944 if (top->string != nullptr) {
945 topDimen = CalcLength(top->string);
946 } else {
947 topDimen = CalcLength(top->value, static_cast<DimensionUnit>(top->unit));
948 }
949 if (right->string != nullptr) {
950 rightDimen = CalcLength(right->string);
951 } else {
952 rightDimen = CalcLength(right->value, static_cast<DimensionUnit>(right->unit));
953 }
954 if (bottom->string != nullptr) {
955 bottomDimen = CalcLength(bottom->string);
956 } else {
957 bottomDimen = CalcLength(bottom->value, static_cast<DimensionUnit>(bottom->unit));
958 }
959 if (left->string != nullptr) {
960 leftDimen = CalcLength(left->string);
961 } else {
962 leftDimen = CalcLength(left->value, static_cast<DimensionUnit>(left->unit));
963 }
964 NG::PaddingProperty paddings;
965 paddings.top = std::optional<CalcLength>(topDimen);
966 paddings.bottom = std::optional<CalcLength>(bottomDimen);
967 paddings.left = std::optional<CalcLength>(leftDimen);
968 paddings.right = std::optional<CalcLength>(rightDimen);
969 TextFieldModelNG::SetPadding(frameNode, paddings);
970 }
971
ResetTextAreaPadding(ArkUINodeHandle node)972 void ResetTextAreaPadding(ArkUINodeHandle node)
973 {
974 auto* frameNode = reinterpret_cast<FrameNode*>(node);
975 CHECK_NULL_VOID(frameNode);
976 auto pipeline = frameNode->GetContext();
977 CHECK_NULL_VOID(pipeline);
978 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
979 CHECK_NULL_VOID(theme);
980 auto textFieldPadding = theme->GetPadding();
981 NG::PaddingProperty paddings;
982 paddings.top = NG::CalcLength(textFieldPadding.Top());
983 paddings.bottom = NG::CalcLength(textFieldPadding.Bottom());
984 paddings.left = NG::CalcLength(textFieldPadding.Left());
985 paddings.right = NG::CalcLength(textFieldPadding.Right());
986 TextFieldModelNG::SetPadding(frameNode, paddings);
987 }
988
SetTextAreaOnChange(ArkUINodeHandle node,void * callback)989 void SetTextAreaOnChange(ArkUINodeHandle node, void* callback)
990 {
991 auto* frameNode = reinterpret_cast<FrameNode*>(node);
992 CHECK_NULL_VOID(frameNode);
993 if (callback) {
994 auto onChange = reinterpret_cast<std::function<void(const ChangeValueInfo&)>*>(callback);
995 TextFieldModelNG::SetOnChange(frameNode, std::move(*onChange));
996 } else {
997 TextFieldModelNG::SetOnChange(frameNode, nullptr);
998 }
999 }
1000
ResetTextAreaOnChange(ArkUINodeHandle node)1001 void ResetTextAreaOnChange(ArkUINodeHandle node)
1002 {
1003 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1004 CHECK_NULL_VOID(frameNode);
1005 TextFieldModelNG::SetOnChange(frameNode, nullptr);
1006 }
1007
SetTextAreaEnterKeyType(ArkUINodeHandle node,ArkUI_Int32 value)1008 void SetTextAreaEnterKeyType(ArkUINodeHandle node, ArkUI_Int32 value)
1009 {
1010 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1011 CHECK_NULL_VOID(frameNode);
1012 TextFieldModelNG::SetEnterKeyType(frameNode, CastToTextInputAction(value));
1013 }
1014
ResetTextAreaEnterKeyType(ArkUINodeHandle node)1015 void ResetTextAreaEnterKeyType(ArkUINodeHandle node)
1016 {
1017 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1018 CHECK_NULL_VOID(frameNode);
1019 TextFieldModelNG::SetEnterKeyType(frameNode, TextInputAction::NEW_LINE);
1020 }
1021
SetTextAreaInputFilter(ArkUINodeHandle node,ArkUI_CharPtr value,void * callback)1022 void SetTextAreaInputFilter(ArkUINodeHandle node, ArkUI_CharPtr value, void* callback)
1023 {
1024 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1025 CHECK_NULL_VOID(frameNode);
1026 std::string inputFilter(value);
1027 if (callback) {
1028 auto onError = reinterpret_cast<std::function<void(const std::u16string&)>*>(callback);
1029 TextFieldModelNG::SetInputFilter(frameNode, inputFilter, *onError);
1030 } else {
1031 TextFieldModelNG::SetInputFilter(frameNode, inputFilter, nullptr);
1032 }
1033 }
1034
ResetTextAreaInputFilter(ArkUINodeHandle node)1035 void ResetTextAreaInputFilter(ArkUINodeHandle node)
1036 {
1037 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1038 CHECK_NULL_VOID(frameNode);
1039 TextFieldModelNG::SetInputFilter(frameNode, "", nullptr);
1040 }
1041
SetTextAreaOnTextSelectionChange(ArkUINodeHandle node,void * callback)1042 void SetTextAreaOnTextSelectionChange(ArkUINodeHandle node, void* callback)
1043 {
1044 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1045 CHECK_NULL_VOID(frameNode);
1046 if (callback) {
1047 auto onChange = reinterpret_cast<std::function<void(int32_t, int32_t)>*>(callback);
1048 TextFieldModelNG::SetOnTextSelectionChange(frameNode, std::move(*onChange));
1049 } else {
1050 TextFieldModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1051 }
1052 }
1053
ResetTextAreaOnTextSelectionChange(ArkUINodeHandle node)1054 void ResetTextAreaOnTextSelectionChange(ArkUINodeHandle node)
1055 {
1056 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1057 CHECK_NULL_VOID(frameNode);
1058 TextFieldModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1059 }
1060
SetTextAreaOnContentScroll(ArkUINodeHandle node,void * callback)1061 void SetTextAreaOnContentScroll(ArkUINodeHandle node, void* callback)
1062 {
1063 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1064 CHECK_NULL_VOID(frameNode);
1065 if (callback) {
1066 auto onScroll = reinterpret_cast<std::function<void(float, float)>*>(callback);
1067 TextFieldModelNG::SetOnContentScroll(frameNode, std::move(*onScroll));
1068 } else {
1069 TextFieldModelNG::SetOnContentScroll(frameNode, nullptr);
1070 }
1071 }
1072
ResetTextAreaOnContentScroll(ArkUINodeHandle node)1073 void ResetTextAreaOnContentScroll(ArkUINodeHandle node)
1074 {
1075 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1076 CHECK_NULL_VOID(frameNode);
1077 TextFieldModelNG::SetOnContentScroll(frameNode, nullptr);
1078 }
1079
SetTextAreaOnEditChange(ArkUINodeHandle node,void * callback)1080 void SetTextAreaOnEditChange(ArkUINodeHandle node, void* callback)
1081 {
1082 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1083 CHECK_NULL_VOID(frameNode);
1084 if (callback) {
1085 auto onEditChange = reinterpret_cast<std::function<void(bool)>*>(callback);
1086 TextFieldModelNG::SetOnEditChange(frameNode, std::move(*onEditChange));
1087 } else {
1088 TextFieldModelNG::SetOnEditChange(frameNode, nullptr);
1089 }
1090 }
1091
ResetTextAreaOnEditChange(ArkUINodeHandle node)1092 void ResetTextAreaOnEditChange(ArkUINodeHandle node)
1093 {
1094 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1095 CHECK_NULL_VOID(frameNode);
1096 TextFieldModelNG::SetOnEditChange(frameNode, nullptr);
1097 }
1098
SetTextAreaOnCopy(ArkUINodeHandle node,void * callback)1099 void SetTextAreaOnCopy(ArkUINodeHandle node, void* callback)
1100 {
1101 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1102 CHECK_NULL_VOID(frameNode);
1103 if (callback) {
1104 auto onCopy = reinterpret_cast<std::function<void(const std::u16string&)>*>(callback);
1105 TextFieldModelNG::SetOnCopy(frameNode, std::move(*onCopy));
1106 } else {
1107 TextFieldModelNG::SetOnCopy(frameNode, nullptr);
1108 }
1109 }
1110
ResetTextAreaOnCopy(ArkUINodeHandle node)1111 void ResetTextAreaOnCopy(ArkUINodeHandle node)
1112 {
1113 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1114 CHECK_NULL_VOID(frameNode);
1115 TextFieldModelNG::SetOnCopy(frameNode, nullptr);
1116 }
1117
SetTextAreaOnCut(ArkUINodeHandle node,void * callback)1118 void SetTextAreaOnCut(ArkUINodeHandle node, void* callback)
1119 {
1120 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1121 CHECK_NULL_VOID(frameNode);
1122 if (callback) {
1123 auto onCut = reinterpret_cast<std::function<void(const std::u16string&)>*>(callback);
1124 TextFieldModelNG::SetOnCut(frameNode, std::move(*onCut));
1125 } else {
1126 TextFieldModelNG::SetOnCut(frameNode, nullptr);
1127 }
1128 }
1129
ResetTextAreaOnCut(ArkUINodeHandle node)1130 void ResetTextAreaOnCut(ArkUINodeHandle node)
1131 {
1132 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1133 CHECK_NULL_VOID(frameNode);
1134 TextFieldModelNG::SetOnCut(frameNode, nullptr);
1135 }
1136
SetTextAreaOnPaste(ArkUINodeHandle node,void * callback)1137 void SetTextAreaOnPaste(ArkUINodeHandle node, void* callback)
1138 {
1139 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1140 CHECK_NULL_VOID(frameNode);
1141 if (callback) {
1142 auto onPasteWithEvent = reinterpret_cast<std::function<void(
1143 const std::u16string&, NG::TextCommonEvent&)>*>(callback);
1144 TextFieldModelNG::SetOnPasteWithEvent(frameNode, std::move(*onPasteWithEvent));
1145 } else {
1146 TextFieldModelNG::SetOnPasteWithEvent(frameNode, nullptr);
1147 }
1148 }
1149
ResetTextAreaOnPaste(ArkUINodeHandle node)1150 void ResetTextAreaOnPaste(ArkUINodeHandle node)
1151 {
1152 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1153 CHECK_NULL_VOID(frameNode);
1154 TextFieldModelNG::SetOnPasteWithEvent(frameNode, nullptr);
1155 }
1156
SetTextAreaLineBreakStrategy(ArkUINodeHandle node,ArkUI_Uint32 lineBreakStrategy)1157 void SetTextAreaLineBreakStrategy(ArkUINodeHandle node, ArkUI_Uint32 lineBreakStrategy)
1158 {
1159 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1160 CHECK_NULL_VOID(frameNode);
1161 if (lineBreakStrategy < 0 || lineBreakStrategy >= LINE_BREAK_STRATEGY_TYPES.size()) {
1162 lineBreakStrategy = 0; // 0 is the default value of LineBreakStrategy::GREEDY
1163 }
1164 TextFieldModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[lineBreakStrategy]);
1165 }
1166
ResetTextAreaLineBreakStrategy(ArkUINodeHandle node)1167 void ResetTextAreaLineBreakStrategy(ArkUINodeHandle node)
1168 {
1169 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1170 CHECK_NULL_VOID(frameNode);
1171 // 0 is the default value of LineBreakStrategy::GREEDY
1172 TextFieldModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[0]);
1173 }
1174
SetTextAreaOnSubmitWithEvent(ArkUINodeHandle node,void * callback)1175 void SetTextAreaOnSubmitWithEvent(ArkUINodeHandle node, void* callback)
1176 {
1177 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1178 CHECK_NULL_VOID(frameNode);
1179 if (callback) {
1180 auto onSubmit = reinterpret_cast<std::function<void(int32_t, NG::TextFieldCommonEvent&)>*>(callback);
1181 TextFieldModelNG::SetOnSubmit(frameNode, std::move(*onSubmit));
1182 } else {
1183 TextFieldModelNG::SetOnSubmit(frameNode, nullptr);
1184 }
1185 }
1186
ResetTextAreaOnSubmitWithEvent(ArkUINodeHandle node)1187 void ResetTextAreaOnSubmitWithEvent(ArkUINodeHandle node)
1188 {
1189 auto *frameNode = reinterpret_cast<FrameNode*>(node);
1190 CHECK_NULL_VOID(frameNode);
1191 TextFieldModelNG::SetOnSubmit(frameNode, nullptr);
1192 }
1193
SetTextAreaContentType(ArkUINodeHandle node,ArkUI_Int32 contentType)1194 void SetTextAreaContentType(ArkUINodeHandle node, ArkUI_Int32 contentType)
1195 {
1196 auto *frameNode = reinterpret_cast<FrameNode*>(node);
1197 CHECK_NULL_VOID(frameNode);
1198 if (contentType < 0 || contentType > static_cast<ArkUI_Int32>(TextContentType::END)) {
1199 contentType = -1;
1200 }
1201 TextFieldModelNG::SetContentType(frameNode, static_cast<NG::TextContentType>(contentType));
1202 }
1203
ResetTextAreaContentType(ArkUINodeHandle node)1204 void ResetTextAreaContentType(ArkUINodeHandle node)
1205 {
1206 auto *frameNode = reinterpret_cast<FrameNode*>(node);
1207 CHECK_NULL_VOID(frameNode);
1208 TextFieldModelNG::SetContentType(frameNode, static_cast<NG::TextContentType>(TextContentType::UNSPECIFIED));
1209 }
1210
SetTextAreaEnableAutoFill(ArkUINodeHandle node,ArkUI_Uint32 enableAutoFill)1211 void SetTextAreaEnableAutoFill(ArkUINodeHandle node, ArkUI_Uint32 enableAutoFill)
1212 {
1213 auto *frameNode = reinterpret_cast<FrameNode*>(node);
1214 CHECK_NULL_VOID(frameNode);
1215 TextFieldModelNG::SetEnableAutoFill(frameNode, static_cast<bool>(enableAutoFill));
1216 }
1217
ResetTextAreaEnableAutoFill(ArkUINodeHandle node)1218 void ResetTextAreaEnableAutoFill(ArkUINodeHandle node)
1219 {
1220 auto *frameNode = reinterpret_cast<FrameNode*>(node);
1221 CHECK_NULL_VOID(frameNode);
1222 TextFieldModelNG::SetEnableAutoFill(frameNode, DEFAULT_ENABLE_AUTO_FILL);
1223 }
1224
ConvertBorderStyle(int32_t value)1225 BorderStyle ConvertBorderStyle(int32_t value)
1226 {
1227 auto style = static_cast<BorderStyle>(value);
1228 if (style < BorderStyle::SOLID || style > BorderStyle::NONE) {
1229 style = BorderStyle::SOLID;
1230 }
1231 return style;
1232 }
1233
SetOptionalBorder(std::optional<Dimension> & optionalDimension,const ArkUI_Float32 * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)1234 void SetOptionalBorder(std::optional<Dimension>& optionalDimension, const ArkUI_Float32* values, ArkUI_Int32 valuesSize,
1235 ArkUI_Int32& offset)
1236 {
1237 bool hasValue = static_cast<bool>(values[offset]);
1238 if (hasValue) {
1239 optionalDimension =
1240 Dimension(values[offset + NUM_1], static_cast<OHOS::Ace::DimensionUnit>(values[offset + NUM_2]));
1241 }
1242 offset = offset + NUM_3;
1243 }
1244
SetAllWidthOptionalBorder(NG::BorderWidthProperty & borderWidth,const ArkUI_Float32 * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)1245 void SetAllWidthOptionalBorder(NG::BorderWidthProperty& borderWidth, const ArkUI_Float32* values,
1246 ArkUI_Int32 valuesSize, ArkUI_Int32& offset)
1247 {
1248 SetOptionalBorder(borderWidth.leftDimen, values, valuesSize, offset);
1249 SetOptionalBorder(borderWidth.rightDimen, values, valuesSize, offset);
1250 SetOptionalBorder(borderWidth.topDimen, values, valuesSize, offset);
1251 SetOptionalBorder(borderWidth.bottomDimen, values, valuesSize, offset);
1252 }
1253
SetAllRadiusOptionalBorder(NG::BorderRadiusProperty & borderRadius,const ArkUI_Float32 * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)1254 void SetAllRadiusOptionalBorder(NG::BorderRadiusProperty& borderRadius, const ArkUI_Float32* values,
1255 ArkUI_Int32 valuesSize, ArkUI_Int32& offset)
1256 {
1257 SetOptionalBorder(borderRadius.radiusTopLeft, values, valuesSize, offset);
1258 SetOptionalBorder(borderRadius.radiusTopRight, values, valuesSize, offset);
1259 SetOptionalBorder(borderRadius.radiusBottomLeft, values, valuesSize, offset);
1260 SetOptionalBorder(borderRadius.radiusBottomRight, values, valuesSize, offset);
1261 }
1262
SetOptionalBorderColor(std::optional<Color> & optionalColor,const uint32_t * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)1263 void SetOptionalBorderColor(
1264 std::optional<Color>& optionalColor, const uint32_t* values, ArkUI_Int32 valuesSize, ArkUI_Int32& offset)
1265 {
1266 auto hasValue = values[offset];
1267 if (static_cast<bool>(hasValue)) {
1268 optionalColor = Color(values[offset + NUM_1]);
1269 }
1270 offset = offset + NUM_2;
1271 }
1272
SetAllOptionalBorderColor(NG::BorderColorProperty & borderColors,const uint32_t * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)1273 void SetAllOptionalBorderColor(
1274 NG::BorderColorProperty& borderColors, const uint32_t* values, ArkUI_Int32 valuesSize, ArkUI_Int32& offset)
1275 {
1276 SetOptionalBorderColor(borderColors.leftColor, values, valuesSize, offset);
1277 SetOptionalBorderColor(borderColors.rightColor, values, valuesSize, offset);
1278 SetOptionalBorderColor(borderColors.topColor, values, valuesSize, offset);
1279 SetOptionalBorderColor(borderColors.bottomColor, values, valuesSize, offset);
1280 }
1281
SetOptionalBorderStyle(std::optional<BorderStyle> & optionalStyle,const uint32_t * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)1282 void SetOptionalBorderStyle(
1283 std::optional<BorderStyle>& optionalStyle, const uint32_t* values, ArkUI_Int32 valuesSize, ArkUI_Int32& offset)
1284 {
1285 auto hasValue = values[offset];
1286 if (static_cast<bool>(hasValue)) {
1287 optionalStyle = ConvertBorderStyle(values[offset + NUM_1]);
1288 }
1289 offset = offset + NUM_2;
1290 }
1291
SetAllOptionalBorderStyle(NG::BorderStyleProperty & borderStyles,const uint32_t * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)1292 void SetAllOptionalBorderStyle(
1293 NG::BorderStyleProperty& borderStyles, const uint32_t* values, ArkUI_Int32 valuesSize, ArkUI_Int32& offset)
1294 {
1295 SetOptionalBorderStyle(borderStyles.styleLeft, values, valuesSize, offset);
1296 SetOptionalBorderStyle(borderStyles.styleRight, values, valuesSize, offset);
1297 SetOptionalBorderStyle(borderStyles.styleTop, values, valuesSize, offset);
1298 SetOptionalBorderStyle(borderStyles.styleBottom, values, valuesSize, offset);
1299 }
1300
SetTextAreaBorder(ArkUINodeHandle node,const ArkUI_Float32 * values,ArkUI_Int32 valuesSize,const uint32_t * colorAndStyle,int32_t colorAndStyleSize)1301 void SetTextAreaBorder(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize,
1302 const uint32_t* colorAndStyle, int32_t colorAndStyleSize)
1303 {
1304 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1305 CHECK_NULL_VOID(frameNode);
1306 if ((values == nullptr) || (valuesSize != NUM_24) || (colorAndStyle == nullptr) || colorAndStyleSize != NUM_16) {
1307 return;
1308 }
1309
1310 int32_t offset = NUM_0;
1311 NG::BorderWidthProperty borderWidth;
1312 SetAllWidthOptionalBorder(borderWidth, values, valuesSize, offset);
1313 borderWidth.multiValued = true;
1314 if (borderWidth.leftDimen.has_value() || borderWidth.rightDimen.has_value() || borderWidth.topDimen.has_value() ||
1315 borderWidth.bottomDimen.has_value()) {
1316 TextFieldModelNG::SetBorderWidth(frameNode, borderWidth);
1317 }
1318
1319 NG::BorderRadiusProperty borderRadius;
1320 SetAllRadiusOptionalBorder(borderRadius, values, valuesSize, offset);
1321 borderRadius.multiValued = true;
1322 if (borderRadius.radiusTopLeft.has_value() || borderRadius.radiusTopRight.has_value() ||
1323 borderRadius.radiusBottomLeft.has_value() || borderRadius.radiusBottomRight.has_value()) {
1324 TextFieldModelNG::SetBorderRadius(frameNode, borderRadius);
1325 }
1326
1327 int32_t colorAndStyleOffset = NUM_0;
1328 NG::BorderColorProperty borderColors;
1329 SetAllOptionalBorderColor(borderColors, colorAndStyle,
1330 colorAndStyleSize, colorAndStyleOffset);
1331 borderColors.multiValued = true;
1332 TextFieldModelNG::SetBorderColor(frameNode, borderColors);
1333
1334 NG::BorderStyleProperty borderStyles;
1335 SetAllOptionalBorderStyle(borderStyles, colorAndStyle,
1336 colorAndStyleSize, colorAndStyleOffset);
1337 borderStyles.multiValued = true;
1338 TextFieldModelNG::SetBorderStyle(frameNode, borderStyles);
1339 }
1340
SetTextAreaBorderDash(ArkUINodeHandle node,const ArkUI_Float32 * values,ArkUI_Int32 valuesSize)1341 void SetTextAreaBorderDash(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize)
1342 {
1343 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1344 CHECK_NULL_VOID(frameNode);
1345 if ((values == nullptr) || (valuesSize != NUM_36)) {
1346 return;
1347 }
1348 auto isRightToLeft = AceApplicationInfo::GetInstance().IsRightToLeft();
1349 int32_t offset = NUM_0;
1350 NG::BorderWidthProperty borderDashGap;
1351 SetOptionalBorder(borderDashGap.leftDimen, values, valuesSize, offset);
1352 SetOptionalBorder(borderDashGap.rightDimen, values, valuesSize, offset);
1353 SetOptionalBorder(borderDashGap.topDimen, values, valuesSize, offset);
1354 SetOptionalBorder(borderDashGap.bottomDimen, values, valuesSize, offset);
1355 if (isRightToLeft) {
1356 SetOptionalBorder(borderDashGap.rightDimen, values, valuesSize, offset);
1357 SetOptionalBorder(borderDashGap.leftDimen, values, valuesSize, offset);
1358 } else {
1359 SetOptionalBorder(borderDashGap.leftDimen, values, valuesSize, offset);
1360 SetOptionalBorder(borderDashGap.rightDimen, values, valuesSize, offset);
1361 }
1362 borderDashGap.multiValued = true;
1363 if (borderDashGap.leftDimen.has_value() || borderDashGap.rightDimen.has_value() ||
1364 borderDashGap.topDimen.has_value() || borderDashGap.bottomDimen.has_value()) {
1365 ViewAbstract::SetDashGap(frameNode, borderDashGap);
1366 } else {
1367 ViewAbstract::SetDashGap(frameNode, Dimension(DEFAULT_DASH_DIMENSION));
1368 }
1369
1370 NG::BorderWidthProperty borderDashWidth;
1371 SetOptionalBorder(borderDashWidth.leftDimen, values, valuesSize, offset);
1372 SetOptionalBorder(borderDashWidth.rightDimen, values, valuesSize, offset);
1373 SetOptionalBorder(borderDashWidth.topDimen, values, valuesSize, offset);
1374 SetOptionalBorder(borderDashWidth.bottomDimen, values, valuesSize, offset);
1375 if (isRightToLeft) {
1376 SetOptionalBorder(borderDashWidth.rightDimen, values, valuesSize, offset);
1377 SetOptionalBorder(borderDashWidth.leftDimen, values, valuesSize, offset);
1378 } else {
1379 SetOptionalBorder(borderDashWidth.leftDimen, values, valuesSize, offset);
1380 SetOptionalBorder(borderDashWidth.rightDimen, values, valuesSize, offset);
1381 }
1382 borderDashWidth.multiValued = true;
1383 if (borderDashWidth.leftDimen.has_value() || borderDashWidth.rightDimen.has_value() ||
1384 borderDashWidth.topDimen.has_value() || borderDashWidth.bottomDimen.has_value()) {
1385 ViewAbstract::SetDashWidth(frameNode, borderDashWidth);
1386 } else {
1387 ViewAbstract::SetDashWidth(frameNode, Dimension(DEFAULT_DASH_DIMENSION));
1388 }
1389 }
1390
ResetTextAreaBorder(ArkUINodeHandle node)1391 void ResetTextAreaBorder(ArkUINodeHandle node)
1392 {
1393 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1394 CHECK_NULL_VOID(frameNode);
1395 BorderWidthProperty borderWidth;
1396 borderWidth.SetBorderWidth(Dimension(0));
1397 TextFieldModelNG::SetBorderWidth(frameNode, borderWidth);
1398
1399 BorderRadiusProperty borderRadius;
1400 borderRadius.SetRadius(Dimension(0));
1401 TextFieldModelNG::SetBorderRadius(frameNode, borderRadius);
1402
1403 BorderColorProperty borderColor;
1404 borderColor.SetColor(Color::BLACK);
1405 TextFieldModelNG::SetBorderColor(frameNode, borderColor);
1406
1407 BorderStyleProperty borderStyle;
1408 borderStyle.SetBorderStyle(BorderStyle::SOLID);
1409 TextFieldModelNG::SetBorderStyle(frameNode, borderStyle);
1410 }
1411
SetTextAreaBorderWidth(ArkUINodeHandle node,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length)1412 void SetTextAreaBorderWidth(ArkUINodeHandle node, const ArkUI_Float32* values,
1413 const ArkUI_Int32* units, ArkUI_Int32 length)
1414 {
1415 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1416 CHECK_NULL_VOID(frameNode);
1417 if (length != DEFAULT_LENGTH) {
1418 return;
1419 }
1420 std::optional<CalcDimension> topDimen;
1421 std::optional<CalcDimension> rightDimen;
1422 std::optional<CalcDimension> bottomDimen;
1423 std::optional<CalcDimension> leftDimen;
1424
1425 if (values[NUM_0] != -1 &&
1426 static_cast<OHOS::Ace::DimensionUnit>(units[NUM_0]) != OHOS::Ace::DimensionUnit::INVALID) {
1427 topDimen = Dimension(values[NUM_0], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_0]));
1428 }
1429 if (values[NUM_1] != -1 &&
1430 static_cast<OHOS::Ace::DimensionUnit>(units[NUM_1]) != OHOS::Ace::DimensionUnit::INVALID) {
1431 rightDimen = Dimension(values[NUM_1], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_1]));
1432 }
1433 if (values[NUM_2] != -1 &&
1434 static_cast<OHOS::Ace::DimensionUnit>(units[NUM_2]) != OHOS::Ace::DimensionUnit::INVALID) {
1435 bottomDimen = Dimension(values[NUM_2], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_2]));
1436 }
1437 if (values[NUM_3] != -1 &&
1438 static_cast<OHOS::Ace::DimensionUnit>(units[NUM_3]) != OHOS::Ace::DimensionUnit::INVALID) {
1439 leftDimen = Dimension(values[NUM_3], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_3]));
1440 }
1441
1442 NG::BorderWidthProperty borderWidth;
1443 borderWidth.leftDimen = leftDimen;
1444 borderWidth.rightDimen = rightDimen;
1445 borderWidth.topDimen = topDimen;
1446 borderWidth.bottomDimen = bottomDimen;
1447 borderWidth.multiValued = true;
1448 TextFieldModelNG::SetBorderWidth(frameNode, borderWidth);
1449 }
1450
ResetTextAreaBorderWidth(ArkUINodeHandle node)1451 void ResetTextAreaBorderWidth(ArkUINodeHandle node)
1452 {
1453 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1454 CHECK_NULL_VOID(frameNode);
1455 BorderWidthProperty borderWidth;
1456 borderWidth.SetBorderWidth(Dimension(0));
1457 TextFieldModelNG::SetBorderWidth(frameNode, borderWidth);
1458 }
1459
SetTextAreaBorderColor(ArkUINodeHandle node,uint32_t topColorInt,uint32_t rightColorInt,uint32_t bottomColorInt,uint32_t leftColorInt)1460 void SetTextAreaBorderColor(ArkUINodeHandle node, uint32_t topColorInt,
1461 uint32_t rightColorInt, uint32_t bottomColorInt, uint32_t leftColorInt)
1462 {
1463 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1464 CHECK_NULL_VOID(frameNode);
1465 NG::BorderColorProperty borderColors;
1466 borderColors.topColor = Color(topColorInt);
1467 borderColors.rightColor = Color(rightColorInt);
1468 borderColors.bottomColor = Color(bottomColorInt);
1469 borderColors.leftColor = Color(leftColorInt);
1470 borderColors.multiValued = true;
1471 TextFieldModelNG::SetBorderColor(frameNode, borderColors);
1472 }
1473
ResetTextAreaBorderColor(ArkUINodeHandle node)1474 void ResetTextAreaBorderColor(ArkUINodeHandle node)
1475 {
1476 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1477 CHECK_NULL_VOID(frameNode);
1478 BorderColorProperty borderColor;
1479 borderColor.SetColor(Color::BLACK);
1480 TextFieldModelNG::SetBorderColor(frameNode, borderColor);
1481 }
1482
SetTextAreaBorderStyle(ArkUINodeHandle node,const ArkUI_Int32 * styles,ArkUI_Int32 length)1483 void SetTextAreaBorderStyle(ArkUINodeHandle node, const ArkUI_Int32* styles, ArkUI_Int32 length)
1484 {
1485 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1486 CHECK_NULL_VOID(frameNode);
1487 if (length == NUM_1) {
1488 BorderStyleProperty borderStyle;
1489 borderStyle.SetBorderStyle(ConvertBorderStyle(styles[NUM_0]));
1490 TextFieldModelNG::SetBorderStyle(frameNode, borderStyle);
1491 return;
1492 }
1493 if (length == NUM_4) {
1494 NG::BorderStyleProperty borderStyles;
1495 borderStyles.styleLeft = ConvertBorderStyle(styles[NUM_3]);
1496 borderStyles.styleRight = ConvertBorderStyle(styles[NUM_1]);
1497 borderStyles.styleTop = ConvertBorderStyle(styles[NUM_0]);
1498 borderStyles.styleBottom = ConvertBorderStyle(styles[NUM_2]);
1499 borderStyles.multiValued = true;
1500 TextFieldModelNG::SetBorderStyle(frameNode, borderStyles);
1501 }
1502 }
1503
ResetTextAreaBorderStyle(ArkUINodeHandle node)1504 void ResetTextAreaBorderStyle(ArkUINodeHandle node)
1505 {
1506 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1507 CHECK_NULL_VOID(frameNode);
1508 BorderStyleProperty borderStyle;
1509 borderStyle.SetBorderStyle(BorderStyle::SOLID);
1510 TextFieldModelNG::SetBorderStyle(frameNode, borderStyle);
1511 }
1512
SetTextAreaBorderRadius(ArkUINodeHandle node,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length)1513 void SetTextAreaBorderRadius(ArkUINodeHandle node, const ArkUI_Float32* values,
1514 const ArkUI_Int32* units, ArkUI_Int32 length)
1515 {
1516 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1517 CHECK_NULL_VOID(frameNode);
1518 if (length != DEFAULT_LENGTH) {
1519 return;
1520 }
1521 NG::BorderRadiusProperty borderRadius;
1522 borderRadius.radiusTopLeft = Dimension(values[NUM_0], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_0]));
1523 borderRadius.radiusTopRight = Dimension(values[NUM_1], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_1]));
1524 borderRadius.radiusBottomLeft = Dimension(values[NUM_2], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_2]));
1525 borderRadius.radiusBottomRight = Dimension(values[NUM_3], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_3]));
1526 borderRadius.multiValued = true;
1527 TextFieldModelNG::SetBorderRadius(frameNode, borderRadius);
1528 }
1529
ResetTextAreaBorderRadius(ArkUINodeHandle node)1530 void ResetTextAreaBorderRadius(ArkUINodeHandle node)
1531 {
1532 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1533 CHECK_NULL_VOID(frameNode);
1534 BorderRadiusProperty borderRadius;
1535 borderRadius.SetRadius(Dimension(0));
1536 TextFieldModelNG::SetBorderRadius(frameNode, borderRadius);
1537 }
1538
SetTextAreaMargin(ArkUINodeHandle node,const struct ArkUISizeType * top,const struct ArkUISizeType * right,const struct ArkUISizeType * bottom,const struct ArkUISizeType * left)1539 void SetTextAreaMargin(ArkUINodeHandle node, const struct ArkUISizeType* top, const struct ArkUISizeType* right,
1540 const struct ArkUISizeType* bottom, const struct ArkUISizeType* left)
1541 {
1542 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1543 CHECK_NULL_VOID(frameNode);
1544 CalcLength topDimen;
1545 CalcLength rightDimen;
1546 CalcLength bottomDimen;
1547 CalcLength leftDimen;
1548 if (top->string != nullptr) {
1549 topDimen = CalcLength(top->string);
1550 } else {
1551 topDimen = CalcLength(top->value, static_cast<DimensionUnit>(top->unit));
1552 }
1553 if (right->string != nullptr) {
1554 rightDimen = CalcLength(right->string);
1555 } else {
1556 rightDimen = CalcLength(right->value, static_cast<DimensionUnit>(right->unit));
1557 }
1558 if (bottom->string != nullptr) {
1559 bottomDimen = CalcLength(bottom->string);
1560 } else {
1561 bottomDimen = CalcLength(bottom->value, static_cast<DimensionUnit>(bottom->unit));
1562 }
1563 if (left->string != nullptr) {
1564 leftDimen = CalcLength(left->string);
1565 } else {
1566 leftDimen = CalcLength(left->value, static_cast<DimensionUnit>(left->unit));
1567 }
1568 NG::PaddingProperty paddings;
1569 paddings.top = std::optional<CalcLength>(topDimen);
1570 paddings.bottom = std::optional<CalcLength>(bottomDimen);
1571 paddings.left = std::optional<CalcLength>(leftDimen);
1572 paddings.right = std::optional<CalcLength>(rightDimen);
1573 TextFieldModelNG::SetMargin(frameNode, paddings);
1574 }
1575
ResetTextAreaMargin(ArkUINodeHandle node)1576 void ResetTextAreaMargin(ArkUINodeHandle node)
1577 {
1578 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1579 CHECK_NULL_VOID(frameNode);
1580 NG::PaddingProperty paddings;
1581 paddings.top = NG::CalcLength(0.0);
1582 paddings.bottom = NG::CalcLength(0.0);
1583 paddings.left = NG::CalcLength(0.0);
1584 paddings.right = NG::CalcLength(0.0);
1585 TextFieldModelNG::SetMargin(frameNode, paddings);
1586 }
1587
GetTextAreaMargin(ArkUINodeHandle node,ArkUI_Float32 (* values)[4],ArkUI_Int32 length,ArkUI_Int32 unit)1588 void GetTextAreaMargin(ArkUINodeHandle node, ArkUI_Float32 (*values)[4], ArkUI_Int32 length, ArkUI_Int32 unit)
1589 {
1590 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1591 CHECK_NULL_VOID(frameNode);
1592 auto margin = TextFieldModelNG::GetMargin(frameNode);
1593 (*values)[NUM_0] = margin.top->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1594 (*values)[NUM_1] = margin.right->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1595 (*values)[NUM_2] = margin.bottom->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1596 (*values)[NUM_3] = margin.left->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1597 }
1598
SetTextAreaOnWillChange(ArkUINodeHandle node,ArkUI_Int64 callback)1599 void SetTextAreaOnWillChange(ArkUINodeHandle node, ArkUI_Int64 callback)
1600 {
1601 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1602 CHECK_NULL_VOID(frameNode);
1603 if (callback) {
1604 auto onWillChange = reinterpret_cast<std::function<bool(const ChangeValueInfo&)>*>(callback);
1605 TextFieldModelNG::SetOnWillChangeEvent(frameNode, std::move(*onWillChange));
1606 } else {
1607 TextFieldModelNG::SetOnWillChangeEvent(frameNode, nullptr);
1608 }
1609 }
1610
ResetTextAreaOnWillChange(ArkUINodeHandle node)1611 void ResetTextAreaOnWillChange(ArkUINodeHandle node)
1612 {
1613 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1614 CHECK_NULL_VOID(frameNode);
1615 TextFieldModelNG::SetOnWillChangeEvent(frameNode, nullptr);
1616 }
1617
SetTextAreaOnWillInsert(ArkUINodeHandle node,ArkUI_Int64 callback)1618 void SetTextAreaOnWillInsert(ArkUINodeHandle node, ArkUI_Int64 callback)
1619 {
1620 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1621 CHECK_NULL_VOID(frameNode);
1622 if (callback) {
1623 auto onWillInsert = reinterpret_cast<std::function<bool(const InsertValueInfo&)>*>(callback);
1624 TextFieldModelNG::SetOnWillInsertValueEvent(frameNode, std::move(*onWillInsert));
1625 } else {
1626 TextFieldModelNG::SetOnWillInsertValueEvent(frameNode, nullptr);
1627 }
1628 }
1629
ResetTextAreaOnWillInsert(ArkUINodeHandle node)1630 void ResetTextAreaOnWillInsert(ArkUINodeHandle node)
1631 {
1632 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1633 CHECK_NULL_VOID(frameNode);
1634 TextFieldModelNG::SetOnWillInsertValueEvent(frameNode, nullptr);
1635 }
1636
SetTextAreaOnDidInsert(ArkUINodeHandle node,ArkUI_Int64 callback)1637 void SetTextAreaOnDidInsert(ArkUINodeHandle node, ArkUI_Int64 callback)
1638 {
1639 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1640 CHECK_NULL_VOID(frameNode);
1641 if (callback) {
1642 auto onDidInsert = reinterpret_cast<std::function<void(const InsertValueInfo&)>*>(callback);
1643 TextFieldModelNG::SetOnDidInsertValueEvent(frameNode, std::move(*onDidInsert));
1644 } else {
1645 TextFieldModelNG::SetOnDidInsertValueEvent(frameNode, nullptr);
1646 }
1647 }
1648
ResetTextAreaOnDidInsert(ArkUINodeHandle node)1649 void ResetTextAreaOnDidInsert(ArkUINodeHandle node)
1650 {
1651 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1652 CHECK_NULL_VOID(frameNode);
1653 TextFieldModelNG::SetOnDidInsertValueEvent(frameNode, nullptr);
1654 }
1655
SetTextAreaOnWillDelete(ArkUINodeHandle node,ArkUI_Int64 callback)1656 void SetTextAreaOnWillDelete(ArkUINodeHandle node, ArkUI_Int64 callback)
1657 {
1658 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1659 CHECK_NULL_VOID(frameNode);
1660 if (callback) {
1661 auto onWillDelete = reinterpret_cast<std::function<bool(const DeleteValueInfo&)>*>(callback);
1662 TextFieldModelNG::SetOnWillDeleteEvent(frameNode, std::move(*onWillDelete));
1663 } else {
1664 TextFieldModelNG::SetOnWillDeleteEvent(frameNode, nullptr);
1665 }
1666 }
1667
ResetTextAreaOnWillDelete(ArkUINodeHandle node)1668 void ResetTextAreaOnWillDelete(ArkUINodeHandle node)
1669 {
1670 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1671 CHECK_NULL_VOID(frameNode);
1672 TextFieldModelNG::SetOnWillDeleteEvent(frameNode, nullptr);
1673 }
1674
SetTextAreaOnDidDelete(ArkUINodeHandle node,ArkUI_Int64 callback)1675 void SetTextAreaOnDidDelete(ArkUINodeHandle node, ArkUI_Int64 callback)
1676 {
1677 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1678 CHECK_NULL_VOID(frameNode);
1679 if (callback) {
1680 auto onDidDelete = reinterpret_cast<std::function<void(const DeleteValueInfo&)>*>(callback);
1681 TextFieldModelNG::SetOnDidDeleteEvent(frameNode, std::move(*onDidDelete));
1682 } else {
1683 TextFieldModelNG::SetOnDidDeleteEvent(frameNode, nullptr);
1684 }
1685 }
1686
ResetTextAreaOnDidDelete(ArkUINodeHandle node)1687 void ResetTextAreaOnDidDelete(ArkUINodeHandle node)
1688 {
1689 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1690 CHECK_NULL_VOID(frameNode);
1691 TextFieldModelNG::SetOnDidDeleteEvent(frameNode, nullptr);
1692 }
1693
SetTextAreaEnablePreviewText(ArkUINodeHandle node,ArkUI_Uint32 value)1694 void SetTextAreaEnablePreviewText(ArkUINodeHandle node, ArkUI_Uint32 value)
1695 {
1696 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1697 CHECK_NULL_VOID(frameNode);
1698 TextFieldModelNG::SetEnablePreviewText(frameNode, static_cast<bool>(value));
1699 }
1700
ResetTextAreaEnablePreviewText(ArkUINodeHandle node)1701 void ResetTextAreaEnablePreviewText(ArkUINodeHandle node)
1702 {
1703 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1704 CHECK_NULL_VOID(frameNode);
1705 TextFieldModelNG::SetEnablePreviewText(frameNode, DEFAULT_ENABLE_PREVIEW_TEXT_VALUE);
1706 }
1707
GetTextAreaEnablePreviewText(ArkUINodeHandle node)1708 ArkUI_Bool GetTextAreaEnablePreviewText(ArkUINodeHandle node)
1709 {
1710 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1711 CHECK_NULL_RETURN(frameNode, false);
1712 return static_cast<int>(TextFieldModelNG::GetEnablePreviewText(frameNode));
1713 }
1714
GetTextAreaPadding(ArkUINodeHandle node,ArkUI_Float32 (* values)[4],ArkUI_Int32 length,ArkUI_Int32 unit)1715 void GetTextAreaPadding(ArkUINodeHandle node, ArkUI_Float32 (*values)[4], ArkUI_Int32 length, ArkUI_Int32 unit)
1716 {
1717 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1718 CHECK_NULL_VOID(frameNode);
1719 auto padding = TextFieldModelNG::GetPadding(frameNode);
1720 (*values)[NUM_0] = padding.top->GetDimensionContainsNegative().GetNativeValue(static_cast<DimensionUnit>(unit));
1721 (*values)[NUM_1] = padding.right->GetDimensionContainsNegative().GetNativeValue(static_cast<DimensionUnit>(unit));
1722 (*values)[NUM_2] = padding.bottom->GetDimensionContainsNegative().GetNativeValue(static_cast<DimensionUnit>(unit));
1723 (*values)[NUM_3] = padding.left->GetDimensionContainsNegative().GetNativeValue(static_cast<DimensionUnit>(unit));
1724 }
1725
SetTextAreaSelectionMenuOptions(ArkUINodeHandle node,void * onCreateMenuCallback,void * onMenuItemClickCallback)1726 void SetTextAreaSelectionMenuOptions(ArkUINodeHandle node, void* onCreateMenuCallback, void* onMenuItemClickCallback)
1727 {
1728 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1729 CHECK_NULL_VOID(frameNode);
1730 if (onCreateMenuCallback) {
1731 NG::OnCreateMenuCallback onCreateMenu = *(reinterpret_cast<NG::OnCreateMenuCallback*>(onCreateMenuCallback));
1732 TextFieldModelNG::OnCreateMenuCallbackUpdate(frameNode, std::move(onCreateMenu));
1733 } else {
1734 TextFieldModelNG::OnCreateMenuCallbackUpdate(frameNode, nullptr);
1735 }
1736 if (onMenuItemClickCallback) {
1737 NG::OnMenuItemClickCallback onMenuItemClick =
1738 *(reinterpret_cast<NG::OnMenuItemClickCallback*>(onMenuItemClickCallback));
1739 TextFieldModelNG::OnMenuItemClickCallbackUpdate(frameNode, std::move(onMenuItemClick));
1740 } else {
1741 TextFieldModelNG::OnMenuItemClickCallbackUpdate(frameNode, nullptr);
1742 }
1743 }
1744
ResetTextAreaSelectionMenuOptions(ArkUINodeHandle node)1745 void ResetTextAreaSelectionMenuOptions(ArkUINodeHandle node)
1746 {
1747 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1748 CHECK_NULL_VOID(frameNode);
1749 NG::OnCreateMenuCallback onCreateMenuCallback;
1750 NG::OnMenuItemClickCallback onMenuItemClick;
1751 TextFieldModelNG::OnCreateMenuCallbackUpdate(frameNode, std::move(onCreateMenuCallback));
1752 TextFieldModelNG::OnMenuItemClickCallbackUpdate(frameNode, std::move(onMenuItemClick));
1753 }
1754
SetTextAreaWidth(ArkUINodeHandle node,ArkUI_CharPtr value)1755 void SetTextAreaWidth(ArkUINodeHandle node, ArkUI_CharPtr value)
1756 {
1757 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1758 CHECK_NULL_VOID(frameNode);
1759 auto widthValue = std::string(value);
1760 TextFieldModelNG::SetWidth(frameNode, widthValue);
1761 }
1762
ResetTextAreaWidth(ArkUINodeHandle node)1763 void ResetTextAreaWidth(ArkUINodeHandle node)
1764 {
1765 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1766 CHECK_NULL_VOID(frameNode);
1767 TextFieldModelNG::ClearWidth(frameNode);
1768 }
1769
SetTextAreaEnableHapticFeedback(ArkUINodeHandle node,ArkUI_Uint32 value)1770 void SetTextAreaEnableHapticFeedback(ArkUINodeHandle node, ArkUI_Uint32 value)
1771 {
1772 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1773 CHECK_NULL_VOID(frameNode);
1774 TextFieldModelNG::SetEnableHapticFeedback(frameNode, static_cast<bool>(value));
1775 }
1776
ResetTextAreaEnableHapticFeedback(ArkUINodeHandle node)1777 void ResetTextAreaEnableHapticFeedback(ArkUINodeHandle node)
1778 {
1779 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1780 CHECK_NULL_VOID(frameNode);
1781 TextFieldModelNG::SetEnableHapticFeedback(frameNode, DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE);
1782 }
1783
SetEllipsisMode(ArkUINodeHandle node,ArkUI_Uint32 ellipsisMode)1784 void SetEllipsisMode(ArkUINodeHandle node, ArkUI_Uint32 ellipsisMode)
1785 {
1786 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1787 CHECK_NULL_VOID(frameNode);
1788 if (ellipsisMode < 0 || ellipsisMode >= ELLIPSIS_MODALS.size()) {
1789 ellipsisMode = ELLIPSIS_MODE_TAIL;
1790 }
1791 TextFieldModelNG::SetEllipsisMode(frameNode, ELLIPSIS_MODALS[ellipsisMode]);
1792 }
1793
ResetEllipsisMode(ArkUINodeHandle node)1794 void ResetEllipsisMode(ArkUINodeHandle node)
1795 {
1796 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1797 CHECK_NULL_VOID(frameNode);
1798 TextFieldModelNG::SetEllipsisMode(frameNode, ELLIPSIS_MODALS[ELLIPSIS_MODE_TAIL]);
1799 }
1800
SetStopBackPress(ArkUINodeHandle node,ArkUI_Uint32 value)1801 void SetStopBackPress(ArkUINodeHandle node, ArkUI_Uint32 value)
1802 {
1803 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1804 CHECK_NULL_VOID(frameNode);
1805 TextFieldModelNG::SetStopBackPress(frameNode, static_cast<bool>(value));
1806 }
1807
ResetStopBackPress(ArkUINodeHandle node)1808 void ResetStopBackPress(ArkUINodeHandle node)
1809 {
1810 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1811 CHECK_NULL_VOID(frameNode);
1812 TextFieldModelNG::SetStopBackPress(frameNode, true);
1813 }
1814 } // namespace
1815
1816 namespace NodeModifier {
GetTextAreaModifier()1817 const ArkUITextAreaModifier* GetTextAreaModifier()
1818 {
1819 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1820 static const ArkUITextAreaModifier modifier = {
1821 .setTextAreaStyle = SetTextAreaStyle,
1822 .resetTextAreaStyle = ResetTextAreaStyle,
1823 .setTextAreaSelectionMenuHidden = SetTextAreaSelectionMenuHidden,
1824 .resetTextAreaSelectionMenuHidden = ResetTextAreaSelectionMenuHidden,
1825 .setTextAreaMaxLines = SetTextAreaMaxLines,
1826 .resetTextAreaMaxLines = ResetTextAreaMaxLines,
1827 .setTextAreaCopyOption = SetTextAreaCopyOption,
1828 .resetTextAreaCopyOption = ResetTextAreaCopyOption,
1829 .setTextAreaPlaceholderColor = SetTextAreaPlaceholderColor,
1830 .resetTextAreaPlaceholderColor = ResetTextAreaPlaceholderColor,
1831 .setTextAreaTextAlign = SetTextAreaTextAlign,
1832 .resetTextAreaTextAlign = ResetTextAreaTextAlign,
1833 .setTextAreaPlaceholderFont = SetTextAreaPlaceholderFont,
1834 .resetTextAreaPlaceholderFont = ResetTextAreaPlaceholderFont,
1835 .setTextAreaBarState = SetTextAreaBarState,
1836 .resetTextAreaBarState = ResetTextAreaBarState,
1837 .setTextAreaEnableKeyboardOnFocus = SetTextAreaEnableKeyboardOnFocus,
1838 .resetTextAreaEnableKeyboardOnFocus = ResetTextAreaEnableKeyboardOnFocus,
1839 .setTextAreaFontFamily = SetTextAreaFontFamily,
1840 .resetTextAreaFontFamily = ResetTextAreaFontFamily,
1841 .setTextAreaShowCounter = SetTextAreaShowCounter,
1842 .resetTextAreaShowCounter = ResetTextAreaShowCounter,
1843 .setTextAreaCaretColor = SetTextAreaCaretColor,
1844 .resetTextAreaCaretColor = ResetTextAreaCaretColor,
1845 .setTextAreaMaxLength = SetTextAreaMaxLength,
1846 .resetTextAreaMaxLength = ResetTextAreaMaxLength,
1847 .setTextAreaFontColor = SetTextAreaFontColor,
1848 .resetTextAreaFontColor = ResetTextAreaFontColor,
1849 .setTextAreaFontStyle = SetTextAreaFontStyle,
1850 .resetTextAreaFontStyle = ResetTextAreaFontStyle,
1851 .setTextAreaFontWeight = SetTextAreaFontWeight,
1852 .resetTextAreaFontWeight = ResetTextAreaFontWeight,
1853 .setTextAreaFontSize = SetTextAreaFontSize,
1854 .resetTextAreaFontSize = ResetTextAreaFontSize,
1855 .setCounterType = SetCounterType,
1856 .setTextAreaPlaceholderString = SetTextAreaPlaceholderString,
1857 .setTextAreaTextString = SetTextAreaTextString,
1858 .stopTextAreaTextEditing = StopTextAreaTextEditing,
1859 .setTextAreaFontWeightStr = SetTextAreaFontWeightStr,
1860 .setTextAreaPlaceholderFontEnum = SetTextAreaPlaceholderFontEnum,
1861 .getTextAreaPlaceholder = GetTextAreaPlaceholder,
1862 .getTextAreaText = GetTextAreaText,
1863 .getTextAreaCaretColor = GetTextAreaCaretColor,
1864 .getTextAreaMaxLength = GetTextAreaMaxLength,
1865 .getTextAreaPlaceholderColor = GetTextAreaPlaceholderColor,
1866 .getTextAreaPlaceholderFont = GetTextAreaPlaceholderFont,
1867 .getTextAreaEditing = GetTextAreaEditing,
1868 .setTextAreaBackgroundColor = SetTextAreaBackgroundColor,
1869 .resetTextAreaBackgroundColor = ResetTextAreaBackgroundColor,
1870 .setTextAreaType = SetTextAreaType,
1871 .resetTextAreaType = ResetTextAreaType,
1872 .getTextAreaType = GetTextAreaType,
1873 .getTextAreaTextAlign = GetTextAreaTextAlign,
1874 .setTextAreaShowCounterOptions = SetTextAreaShowCounterOptions,
1875 .resetTextAreaShowCounterOptions = ResetTextAreaShowCounterOptions,
1876 .getTextAreaShowCounterOptions = GetTextAreaShowCounterOptions,
1877 .setTextAreaDecoration = SetTextAreaDecoration,
1878 .resetTextAreaDecoration = ResetTextAreaDecoration,
1879 .setTextAreaLetterSpacing = SetTextAreaLetterSpacing,
1880 .resetTextAreaLetterSpacing = ResetTextAreaLetterSpacing,
1881 .setTextAreaLineHeight = SetTextAreaLineHeight,
1882 .resetTextAreaLineHeight = ResetTextAreaLineHeight,
1883 .setTextAreaHalfLeading = SetTextAreaHalfLeading,
1884 .resetTextAreaHalfLeading = ResetTextAreaHalfLeading,
1885 .setTextAreaFontFeature = SetTextAreaFontFeature,
1886 .resetTextAreaFontFeature = ResetTextAreaFontFeature,
1887 .setTextAreaWordBreak = SetTextAreaWordBreak,
1888 .resetTextAreaWordBreak = ResetTextAreaWordBreak,
1889 .setTextAreaAdaptMinFontSize = SetTextAreaAdaptMinFontSize,
1890 .resetTextAreaAdaptMinFontSize = ResetTextAreaAdaptMinFontSize,
1891 .setTextAreaAdaptMaxFontSize = SetTextAreaAdaptMaxFontSize,
1892 .resetTextAreaAdaptMaxFontSize = ResetTextAreaAdaptMaxFontSize,
1893 .setTextAreaHeightAdaptivePolicy = SetTextAreaHeightAdaptivePolicy,
1894 .resetTextAreaHeightAdaptivePolicy = ResetTextAreaHeightAdaptivePolicy,
1895 .setTextAreaSelectedBackgroundColor = SetTextAreaSelectedBackgroundColor,
1896 .resetTextAreaSelectedBackgroundColor = ResetTextAreaSelectedBackgroundColor,
1897 .setTextAreaCaretStyle = SetTextAreaCaretStyle,
1898 .resetTextAreaCaretStyle = ResetTextAreaCaretStyle,
1899 .setTextAreaTextOverflow = SetTextAreaTextOverflow,
1900 .resetTextAreaTextOverflow = ResetTextAreaTextOverflow,
1901 .setTextAreaTextIndent = SetTextAreaTextIndent,
1902 .resetTextAreaTextIndent = ResetTextAreaTextIndent,
1903 .setTextAreaLineSpacing = SetTextAreaLineSpacing,
1904 .resetTextAreaLineSpacing = ResetTextAreaLineSpacing,
1905 .getTextAreaSelectionMenuHidden = GetTextAreaSelectionMenuHidden,
1906 .getTextAreaAdaptMinFontSize = GetTextAreaAdaptMinFontSize,
1907 .getTextAreaAdaptMaxFontSize = GetTextAreaAdaptMaxFontSize,
1908 .getTextAreaLineHeight = GetTextAreaLineHeight,
1909 .getTextAreaMaxLines = GetgetTextAreaMaxLines,
1910 .setTextAreaPadding = SetTextAreaPadding,
1911 .resetTextAreaPadding = ResetTextAreaPadding,
1912 .getTextAreaFontFeature = GetTextAreaFontFeature,
1913 .setTextAreaOnChange = SetTextAreaOnChange,
1914 .resetTextAreaOnChange = ResetTextAreaOnChange,
1915 .setTextAreaEnterKeyType = SetTextAreaEnterKeyType,
1916 .resetTextAreaEnterKeyType = ResetTextAreaEnterKeyType,
1917 .setTextAreaInputFilter = SetTextAreaInputFilter,
1918 .resetTextAreaInputFilter = ResetTextAreaInputFilter,
1919 .setTextAreaOnTextSelectionChange = SetTextAreaOnTextSelectionChange,
1920 .resetTextAreaOnTextSelectionChange = ResetTextAreaOnTextSelectionChange,
1921 .setTextAreaOnContentScroll = SetTextAreaOnContentScroll,
1922 .resetTextAreaOnContentScroll = ResetTextAreaOnContentScroll,
1923 .setTextAreaOnEditChange = SetTextAreaOnEditChange,
1924 .resetTextAreaOnEditChange = ResetTextAreaOnEditChange,
1925 .setTextAreaOnCopy = SetTextAreaOnCopy,
1926 .resetTextAreaOnCopy = ResetTextAreaOnCopy,
1927 .setTextAreaOnCut = SetTextAreaOnCut,
1928 .resetTextAreaOnCut = ResetTextAreaOnCut,
1929 .setTextAreaOnPaste = SetTextAreaOnPaste,
1930 .resetTextAreaOnPaste = ResetTextAreaOnPaste,
1931 .setTextAreaLineBreakStrategy = SetTextAreaLineBreakStrategy,
1932 .resetTextAreaLineBreakStrategy = ResetTextAreaLineBreakStrategy,
1933 .setTextAreaOnSubmitWithEvent = SetTextAreaOnSubmitWithEvent,
1934 .resetTextAreaOnSubmitWithEvent = ResetTextAreaOnSubmitWithEvent,
1935 .setTextAreaContentType = SetTextAreaContentType,
1936 .resetTextAreaContentType = ResetTextAreaContentType,
1937 .setTextAreaEnableAutoFill = SetTextAreaEnableAutoFill,
1938 .resetTextAreaEnableAutoFill = ResetTextAreaEnableAutoFill,
1939 .setTextAreaBorder = SetTextAreaBorder,
1940 .resetTextAreaBorder = ResetTextAreaBorder,
1941 .setTextAreaBorderWidth = SetTextAreaBorderWidth,
1942 .resetTextAreaBorderWidth = ResetTextAreaBorderWidth,
1943 .setTextAreaBorderColor = SetTextAreaBorderColor,
1944 .resetTextAreaBorderColor = ResetTextAreaBorderColor,
1945 .setTextAreaBorderStyle = SetTextAreaBorderStyle,
1946 .resetTextAreaBorderStyle = ResetTextAreaBorderStyle,
1947 .setTextAreaBorderRadius = SetTextAreaBorderRadius,
1948 .resetTextAreaBorderRadius = ResetTextAreaBorderRadius,
1949 .setTextAreaMargin = SetTextAreaMargin,
1950 .resetTextAreaMargin = ResetTextAreaMargin,
1951 .setTextAreaCaret = SetTextAreaCaret,
1952 .getTextAreaMargin = GetTextAreaMargin,
1953 .setTextAreaOnWillChange = SetTextAreaOnWillChange,
1954 .resetTextAreaOnWillChange = ResetTextAreaOnWillChange,
1955 .setTextAreaOnWillInsert = SetTextAreaOnWillInsert,
1956 .resetTextAreaOnWillInsert = ResetTextAreaOnWillInsert,
1957 .setTextAreaOnDidInsert = SetTextAreaOnDidInsert,
1958 .resetTextAreaOnDidInsert = ResetTextAreaOnDidInsert,
1959 .setTextAreaOnWillDelete = SetTextAreaOnWillDelete,
1960 .resetTextAreaOnWillDelete = ResetTextAreaOnWillDelete,
1961 .setTextAreaOnDidDelete = SetTextAreaOnDidDelete,
1962 .resetTextAreaOnDidDelete = ResetTextAreaOnDidDelete,
1963 .setTextAreaEnablePreviewText = SetTextAreaEnablePreviewText,
1964 .resetTextAreaEnablePreviewText = ResetTextAreaEnablePreviewText,
1965 .getTextAreaPadding = GetTextAreaPadding,
1966 .setTextAreaSelectionMenuOptions = SetTextAreaSelectionMenuOptions,
1967 .resetTextAreaSelectionMenuOptions = ResetTextAreaSelectionMenuOptions,
1968 .setTextAreaWidth = SetTextAreaWidth,
1969 .resetTextAreaWidth = ResetTextAreaWidth,
1970 .setTextAreaEnableHapticFeedback = SetTextAreaEnableHapticFeedback,
1971 .resetTextAreaEnableHapticFeedback = ResetTextAreaEnableHapticFeedback,
1972 .getTextAreaLetterSpacing = GetTextAreaLetterSpacing,
1973 .getTextAreaEnablePreviewText = GetTextAreaEnablePreviewText,
1974 .setEllipsisMode = SetEllipsisMode,
1975 .resetEllipsisMode = ResetEllipsisMode,
1976 .setTextAreaBorderDash = SetTextAreaBorderDash,
1977 .setTextAreaMinFontScale = SetTextAreaMinFontScale,
1978 .resetTextAreaMinFontScale = ResetTextAreaMinFontScale,
1979 .setTextAreaMaxFontScale = SetTextAreaMaxFontScale,
1980 .resetTextAreaMaxFontScale = ResetTextAreaMaxFontScale,
1981 .setStopBackPress = SetStopBackPress,
1982 .resetStopBackPress = ResetStopBackPress,
1983 .setTextAreaKeyboardAppearance = SetTextAreaKeyboardAppearance,
1984 .resetTextAreaKeyboardAppearance = ResetTextAreaKeyboardAppearance,
1985 };
1986 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1987 return &modifier;
1988 }
1989
GetCJUITextAreaModifier()1990 const CJUITextAreaModifier* GetCJUITextAreaModifier()
1991 {
1992 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1993 static const CJUITextAreaModifier modifier = {
1994 .setTextAreaStyle = SetTextAreaStyle,
1995 .resetTextAreaStyle = ResetTextAreaStyle,
1996 .setTextAreaSelectionMenuHidden = SetTextAreaSelectionMenuHidden,
1997 .resetTextAreaSelectionMenuHidden = ResetTextAreaSelectionMenuHidden,
1998 .setTextAreaMaxLines = SetTextAreaMaxLines,
1999 .resetTextAreaMaxLines = ResetTextAreaMaxLines,
2000 .setTextAreaCopyOption = SetTextAreaCopyOption,
2001 .resetTextAreaCopyOption = ResetTextAreaCopyOption,
2002 .setTextAreaPlaceholderColor = SetTextAreaPlaceholderColor,
2003 .resetTextAreaPlaceholderColor = ResetTextAreaPlaceholderColor,
2004 .setTextAreaTextAlign = SetTextAreaTextAlign,
2005 .resetTextAreaTextAlign = ResetTextAreaTextAlign,
2006 .setTextAreaPlaceholderFont = SetTextAreaPlaceholderFont,
2007 .resetTextAreaPlaceholderFont = ResetTextAreaPlaceholderFont,
2008 .setTextAreaBarState = SetTextAreaBarState,
2009 .resetTextAreaBarState = ResetTextAreaBarState,
2010 .setTextAreaEnableKeyboardOnFocus = SetTextAreaEnableKeyboardOnFocus,
2011 .resetTextAreaEnableKeyboardOnFocus = ResetTextAreaEnableKeyboardOnFocus,
2012 .setTextAreaFontFamily = SetTextAreaFontFamily,
2013 .resetTextAreaFontFamily = ResetTextAreaFontFamily,
2014 .setTextAreaShowCounter = SetTextAreaShowCounter,
2015 .resetTextAreaShowCounter = ResetTextAreaShowCounter,
2016 .setTextAreaCaretColor = SetTextAreaCaretColor,
2017 .resetTextAreaCaretColor = ResetTextAreaCaretColor,
2018 .setTextAreaMaxLength = SetTextAreaMaxLength,
2019 .resetTextAreaMaxLength = ResetTextAreaMaxLength,
2020 .setTextAreaFontColor = SetTextAreaFontColor,
2021 .resetTextAreaFontColor = ResetTextAreaFontColor,
2022 .setTextAreaFontStyle = SetTextAreaFontStyle,
2023 .resetTextAreaFontStyle = ResetTextAreaFontStyle,
2024 .setTextAreaFontWeight = SetTextAreaFontWeight,
2025 .resetTextAreaFontWeight = ResetTextAreaFontWeight,
2026 .setTextAreaFontSize = SetTextAreaFontSize,
2027 .resetTextAreaFontSize = ResetTextAreaFontSize,
2028 .setCounterType = SetCounterType,
2029 .setTextAreaPlaceholderString = SetTextAreaPlaceholderString,
2030 .setTextAreaTextString = SetTextAreaTextString,
2031 .stopTextAreaTextEditing = StopTextAreaTextEditing,
2032 .setTextAreaFontWeightStr = SetTextAreaFontWeightStr,
2033 .setTextAreaPlaceholderFontEnum = SetTextAreaPlaceholderFontEnum,
2034 .getTextAreaPlaceholder = GetTextAreaPlaceholder,
2035 .getTextAreaText = GetTextAreaText,
2036 .getTextAreaCaretColor = GetTextAreaCaretColor,
2037 .getTextAreaMaxLength = GetTextAreaMaxLength,
2038 .getTextAreaPlaceholderColor = GetTextAreaPlaceholderColor,
2039 .getTextAreaPlaceholderFont = GetTextAreaPlaceholderFont,
2040 .getTextAreaEditing = GetTextAreaEditing,
2041 .setTextAreaBackgroundColor = SetTextAreaBackgroundColor,
2042 .resetTextAreaBackgroundColor = ResetTextAreaBackgroundColor,
2043 .setTextAreaType = SetTextAreaType,
2044 .resetTextAreaType = ResetTextAreaType,
2045 .getTextAreaType = GetTextAreaType,
2046 .getTextAreaTextAlign = GetTextAreaTextAlign,
2047 .setTextAreaShowCounterOptions = SetTextAreaShowCounterOptions,
2048 .resetTextAreaShowCounterOptions = ResetTextAreaShowCounterOptions,
2049 .getTextAreaShowCounterOptions = GetTextAreaShowCounterOptions,
2050 .setTextAreaDecoration = SetTextAreaDecoration,
2051 .resetTextAreaDecoration = ResetTextAreaDecoration,
2052 .setTextAreaLetterSpacing = SetTextAreaLetterSpacing,
2053 .resetTextAreaLetterSpacing = ResetTextAreaLetterSpacing,
2054 .setTextAreaLineHeight = SetTextAreaLineHeight,
2055 .resetTextAreaLineHeight = ResetTextAreaLineHeight,
2056 .setTextAreaFontFeature = SetTextAreaFontFeature,
2057 .resetTextAreaFontFeature = ResetTextAreaFontFeature,
2058 .setTextAreaWordBreak = SetTextAreaWordBreak,
2059 .resetTextAreaWordBreak = ResetTextAreaWordBreak,
2060 .setTextAreaAdaptMinFontSize = SetTextAreaAdaptMinFontSize,
2061 .resetTextAreaAdaptMinFontSize = ResetTextAreaAdaptMinFontSize,
2062 .setTextAreaAdaptMaxFontSize = SetTextAreaAdaptMaxFontSize,
2063 .resetTextAreaAdaptMaxFontSize = ResetTextAreaAdaptMaxFontSize,
2064 .setTextAreaHeightAdaptivePolicy = SetTextAreaHeightAdaptivePolicy,
2065 .resetTextAreaHeightAdaptivePolicy = ResetTextAreaHeightAdaptivePolicy,
2066 .setTextAreaSelectedBackgroundColor = SetTextAreaSelectedBackgroundColor,
2067 .resetTextAreaSelectedBackgroundColor = ResetTextAreaSelectedBackgroundColor,
2068 .setTextAreaCaretStyle = SetTextAreaCaretStyle,
2069 .resetTextAreaCaretStyle = ResetTextAreaCaretStyle,
2070 .setTextAreaTextOverflow = SetTextAreaTextOverflow,
2071 .resetTextAreaTextOverflow = ResetTextAreaTextOverflow,
2072 .setTextAreaTextIndent = SetTextAreaTextIndent,
2073 .resetTextAreaTextIndent = ResetTextAreaTextIndent,
2074 .setTextAreaLineSpacing = SetTextAreaLineSpacing,
2075 .resetTextAreaLineSpacing = ResetTextAreaLineSpacing,
2076 .getTextAreaSelectionMenuHidden = GetTextAreaSelectionMenuHidden,
2077 .getTextAreaAdaptMinFontSize = GetTextAreaAdaptMinFontSize,
2078 .getTextAreaAdaptMaxFontSize = GetTextAreaAdaptMaxFontSize,
2079 .getTextAreaLineHeight = GetTextAreaLineHeight,
2080 .getTextAreaMaxLines = GetgetTextAreaMaxLines,
2081 .setTextAreaPadding = SetTextAreaPadding,
2082 .resetTextAreaPadding = ResetTextAreaPadding,
2083 .getTextAreaFontFeature = GetTextAreaFontFeature,
2084 .setTextAreaOnChange = SetTextAreaOnChange,
2085 .resetTextAreaOnChange = ResetTextAreaOnChange,
2086 .setTextAreaEnterKeyType = SetTextAreaEnterKeyType,
2087 .resetTextAreaEnterKeyType = ResetTextAreaEnterKeyType,
2088 .setTextAreaInputFilter = SetTextAreaInputFilter,
2089 .resetTextAreaInputFilter = ResetTextAreaInputFilter,
2090 .setTextAreaOnTextSelectionChange = SetTextAreaOnTextSelectionChange,
2091 .resetTextAreaOnTextSelectionChange = ResetTextAreaOnTextSelectionChange,
2092 .setTextAreaOnContentScroll = SetTextAreaOnContentScroll,
2093 .resetTextAreaOnContentScroll = ResetTextAreaOnContentScroll,
2094 .setTextAreaOnEditChange = SetTextAreaOnEditChange,
2095 .resetTextAreaOnEditChange = ResetTextAreaOnEditChange,
2096 .setTextAreaOnCopy = SetTextAreaOnCopy,
2097 .resetTextAreaOnCopy = ResetTextAreaOnCopy,
2098 .setTextAreaOnCut = SetTextAreaOnCut,
2099 .resetTextAreaOnCut = ResetTextAreaOnCut,
2100 .setTextAreaOnPaste = SetTextAreaOnPaste,
2101 .resetTextAreaOnPaste = ResetTextAreaOnPaste,
2102 .setTextAreaLineBreakStrategy = SetTextAreaLineBreakStrategy,
2103 .resetTextAreaLineBreakStrategy = ResetTextAreaLineBreakStrategy,
2104 .setTextAreaOnSubmitWithEvent = SetTextAreaOnSubmitWithEvent,
2105 .resetTextAreaOnSubmitWithEvent = ResetTextAreaOnSubmitWithEvent,
2106 .setTextAreaContentType = SetTextAreaContentType,
2107 .resetTextAreaContentType = ResetTextAreaContentType,
2108 .setTextAreaEnableAutoFill = SetTextAreaEnableAutoFill,
2109 .resetTextAreaEnableAutoFill = ResetTextAreaEnableAutoFill,
2110 .setTextAreaBorder = SetTextAreaBorder,
2111 .resetTextAreaBorder = ResetTextAreaBorder,
2112 .setTextAreaBorderWidth = SetTextAreaBorderWidth,
2113 .resetTextAreaBorderWidth = ResetTextAreaBorderWidth,
2114 .setTextAreaBorderColor = SetTextAreaBorderColor,
2115 .resetTextAreaBorderColor = ResetTextAreaBorderColor,
2116 .setTextAreaBorderStyle = SetTextAreaBorderStyle,
2117 .resetTextAreaBorderStyle = ResetTextAreaBorderStyle,
2118 .setTextAreaBorderRadius = SetTextAreaBorderRadius,
2119 .resetTextAreaBorderRadius = ResetTextAreaBorderRadius,
2120 .setTextAreaMargin = SetTextAreaMargin,
2121 .resetTextAreaMargin = ResetTextAreaMargin,
2122 .getTextAreaMargin = GetTextAreaMargin,
2123 .setTextAreaCaret = SetTextAreaCaret,
2124 .setTextAreaOnWillInsert = SetTextAreaOnWillInsert,
2125 .resetTextAreaOnWillInsert = ResetTextAreaOnWillInsert,
2126 .setTextAreaOnDidInsert = SetTextAreaOnDidInsert,
2127 .resetTextAreaOnDidInsert = ResetTextAreaOnDidInsert,
2128 .setTextAreaOnWillDelete = SetTextAreaOnWillDelete,
2129 .resetTextAreaOnWillDelete = ResetTextAreaOnWillDelete,
2130 .setTextAreaOnDidDelete = SetTextAreaOnDidDelete,
2131 .resetTextAreaOnDidDelete = ResetTextAreaOnDidDelete,
2132 .setTextAreaEnablePreviewText = SetTextAreaEnablePreviewText,
2133 .resetTextAreaEnablePreviewText = ResetTextAreaEnablePreviewText,
2134 .getTextAreaPadding = GetTextAreaPadding,
2135 };
2136 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
2137 return &modifier;
2138 }
2139
SetOnTextAreaChange(ArkUINodeHandle node,void * extraParam)2140 void SetOnTextAreaChange(ArkUINodeHandle node, void* extraParam)
2141 {
2142 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2143 CHECK_NULL_VOID(frameNode);
2144 auto onChange = [node, extraParam](const ChangeValueInfo& info) {
2145 ArkUINodeEvent event;
2146 std::string utf8Str = UtfUtils::Str16DebugToStr8(info.value);
2147 event.kind = TEXT_INPUT;
2148 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2149 event.textInputEvent.subKind = ON_TEXTAREA_CHANGE;
2150 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(utf8Str.c_str());
2151 SendArkUISyncEvent(&event);
2152 };
2153 TextFieldModelNG::SetOnChange(frameNode, std::move(onChange));
2154 }
2155
SetOnTextAreaChangeWithPreviewText(ArkUINodeHandle node,void * extraParam)2156 void SetOnTextAreaChangeWithPreviewText(ArkUINodeHandle node, void* extraParam)
2157 {
2158 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2159 CHECK_NULL_VOID(frameNode);
2160 auto onChange = [node, extraParam](const ChangeValueInfo& info) {
2161 ArkUINodeEvent eventWithPreview;
2162 eventWithPreview.kind = TEXT_INPUT_CHANGE;
2163 std::string utf8StrValue = UtfUtils::Str16DebugToStr8(info.value);
2164 std::string utf8Str = UtfUtils::Str16DebugToStr8(info.previewText.value);
2165 eventWithPreview.extraParam = reinterpret_cast<intptr_t>(extraParam);
2166 eventWithPreview.textChangeEvent.subKind = ON_TEXT_AREA_CHANGE_WITH_PREVIEW_TEXT;
2167 eventWithPreview.textChangeEvent.nativeStringPtr = const_cast<char*>(utf8StrValue.c_str());
2168 eventWithPreview.textChangeEvent.extendStringPtr = const_cast<char*>(utf8Str.c_str());
2169 eventWithPreview.textChangeEvent.numArgs = info.previewText.offset;
2170 SendArkUISyncEvent(&eventWithPreview);
2171 };
2172 TextFieldModelNG::SetOnChange(frameNode, std::move(onChange));
2173 }
2174
SetOnTextAreaPaste(ArkUINodeHandle node,void * extraParam)2175 void SetOnTextAreaPaste(ArkUINodeHandle node, void* extraParam)
2176 {
2177 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2178 CHECK_NULL_VOID(frameNode);
2179 auto onPaste = [node, extraParam](const std::u16string& str, NG::TextCommonEvent& commonEvent) {
2180 ArkUINodeEvent event;
2181 std::string utf8Str = UtfUtils::Str16DebugToStr8(str);
2182 event.kind = TEXT_INPUT;
2183 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2184 event.textInputEvent.subKind = ON_TEXTAREA_PASTE;
2185 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(utf8Str.c_str());
2186 SendArkUISyncEvent(&event);
2187 };
2188 TextFieldModelNG::SetOnPasteWithEvent(frameNode, std::move(onPaste));
2189 }
2190
SetOnTextAreaSelectionChange(ArkUINodeHandle node,void * extraParam)2191 void SetOnTextAreaSelectionChange(ArkUINodeHandle node, void* extraParam)
2192 {
2193 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2194 CHECK_NULL_VOID(frameNode);
2195 auto onSelectionChange = [node, extraParam](int start, int end) {
2196 ArkUINodeEvent event;
2197 event.kind = COMPONENT_ASYNC_EVENT;
2198 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2199 event.componentAsyncEvent.subKind = ON_TEXTAREA_TEXT_SELECTION_CHANGE;
2200 event.componentAsyncEvent.data[0].i32 = static_cast<int>(start);
2201 event.componentAsyncEvent.data[1].i32 = static_cast<int>(end);
2202 SendArkUISyncEvent(&event);
2203 };
2204 TextFieldModelNG::SetOnTextSelectionChange(frameNode, std::move(onSelectionChange));
2205 }
2206
SetOnTextAreaEditChange(ArkUINodeHandle node,void * extraParam)2207 void SetOnTextAreaEditChange(ArkUINodeHandle node, void* extraParam)
2208 {
2209 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2210 CHECK_NULL_VOID(frameNode);
2211 auto onChange = [node, extraParam](bool isEditing) {
2212 ArkUINodeEvent event;
2213 event.kind = COMPONENT_ASYNC_EVENT;
2214 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2215 event.componentAsyncEvent.subKind = ON_TEXTAREA_EDIT_CHANGE;
2216 event.componentAsyncEvent.data[0].i32 = static_cast<int32_t>(isEditing);
2217 SendArkUISyncEvent(&event);
2218 };
2219 TextFieldModelNG::SetOnEditChanged(frameNode, std::move(onChange));
2220 }
2221
SetOnTextAreaContentSizeChange(ArkUINodeHandle node,void * extraParam)2222 void SetOnTextAreaContentSizeChange(ArkUINodeHandle node, void* extraParam)
2223 {
2224 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2225 CHECK_NULL_VOID(frameNode);
2226 auto onChange = [node, extraParam](float width, float height) {
2227 ArkUINodeEvent event;
2228 event.kind = COMPONENT_ASYNC_EVENT;
2229 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2230 event.componentAsyncEvent.subKind = ON_TEXTAREA_CONTENT_SIZE_CHANGE;
2231 bool usePx = NodeModel::UsePXUnit(reinterpret_cast<ArkUI_Node*>(extraParam));
2232 double density = usePx ? 1 : PipelineBase::GetCurrentDensity();
2233 //0 width
2234 event.componentAsyncEvent.data[0].f32 = NearEqual(density, 0.0) ? 0.0f : width / density;
2235 //1 height
2236 event.componentAsyncEvent.data[1].f32 = NearEqual(density, 0.0) ? 0.0f : height / density;
2237 SendArkUISyncEvent(&event);
2238 };
2239 TextFieldModelNG::SetOnContentSizeChange(frameNode, std::move(onChange));
2240 }
2241
SetOnTextAreaInputFilterError(ArkUINodeHandle node,void * extraParam)2242 void SetOnTextAreaInputFilterError(ArkUINodeHandle node, void* extraParam)
2243 {
2244 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2245 CHECK_NULL_VOID(frameNode);
2246 auto onInputFilterError = [node, extraParam](const std::u16string& str) {
2247 ArkUINodeEvent event;
2248 std::string utf8Str = UtfUtils::Str16DebugToStr8(str);
2249 event.kind = TEXT_INPUT;
2250 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2251 event.textInputEvent.subKind = ON_TEXT_AREA_INPUT_FILTER_ERROR;
2252 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(utf8Str.c_str());
2253 SendArkUISyncEvent(&event);
2254 };
2255 TextFieldModelNG::SetInputFilterError(frameNode, std::move(onInputFilterError));
2256 }
2257
SetTextAreaOnTextContentScroll(ArkUINodeHandle node,void * extraParam)2258 void SetTextAreaOnTextContentScroll(ArkUINodeHandle node, void* extraParam)
2259 {
2260 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2261 CHECK_NULL_VOID(frameNode);
2262 auto onScroll = [node, extraParam](float totalOffsetX, float totalOffsetY) {
2263 ArkUINodeEvent event;
2264 event.kind = COMPONENT_ASYNC_EVENT;
2265 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2266 event.componentAsyncEvent.subKind = ON_TEXT_AREA_CONTENT_SCROLL;
2267 event.componentAsyncEvent.data[0].f32 = totalOffsetX;
2268 event.componentAsyncEvent.data[1].f32 = totalOffsetY;
2269 SendArkUISyncEvent(&event);
2270 };
2271 TextFieldModelNG::SetOnContentScroll(frameNode, std::move(onScroll));
2272 }
2273
SetTextAreaOnSubmit(ArkUINodeHandle node,void * extraParam)2274 void SetTextAreaOnSubmit(ArkUINodeHandle node, void* extraParam)
2275 {
2276 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2277 CHECK_NULL_VOID(frameNode);
2278 auto onEvent = [node, extraParam](int32_t value, NG::TextFieldCommonEvent& commonEvent) {
2279 ArkUINodeEvent event;
2280 event.kind = COMPONENT_ASYNC_EVENT;
2281 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2282 event.componentAsyncEvent.subKind = ON_TEXTAREA_ON_SUBMIT;
2283 event.componentAsyncEvent.data[0].i32 = value;
2284 SendArkUISyncEvent(&event);
2285 };
2286 TextFieldModelNG::SetOnSubmit(frameNode, std::move(onEvent));
2287 }
2288
SetTextAreaOnWillInsertValue(ArkUINodeHandle node,void * extraParam)2289 void SetTextAreaOnWillInsertValue(ArkUINodeHandle node, void* extraParam)
2290 {
2291 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2292 CHECK_NULL_VOID(frameNode);
2293 std::function<bool(const InsertValueInfo&)> onWillInsert = [node, extraParam](
2294 const InsertValueInfo& Info) -> bool {
2295 ArkUINodeEvent event;
2296 std::string insertValueUtf8 = UtfUtils::Str16DebugToStr8(Info.insertValue);
2297 event.kind = MIXED_EVENT;
2298 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2299 event.mixedEvent.subKind = ON_TEXT_AREA_WILL_INSERT;
2300 event.mixedEvent.numberData[0].f32 = Info.insertOffset;
2301 event.mixedEvent.numberDataLength = 1;
2302 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(insertValueUtf8.c_str());
2303 event.mixedEvent.stringPtrDataLength = 1;
2304 SendArkUISyncEvent(&event);
2305 return event.mixedEvent.numberReturnData[0].i32;
2306 };
2307 TextFieldModelNG::SetOnWillInsertValueEvent(frameNode, std::move(onWillInsert));
2308 }
2309
SetTextAreaOnDidInsertValue(ArkUINodeHandle node,void * extraParam)2310 void SetTextAreaOnDidInsertValue(ArkUINodeHandle node, void* extraParam)
2311 {
2312 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2313 CHECK_NULL_VOID(frameNode);
2314 auto onDidInsert = [node, extraParam](const InsertValueInfo& Info) {
2315 ArkUINodeEvent event;
2316 std::string insertValueUtf8 = UtfUtils::Str16DebugToStr8(Info.insertValue);
2317 event.kind = MIXED_EVENT;
2318 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2319 event.mixedEvent.subKind = ON_TEXT_AREA_DID_INSERT;
2320 event.mixedEvent.numberData[0].f32 = Info.insertOffset;
2321 event.mixedEvent.numberDataLength = 1;
2322 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(insertValueUtf8.c_str());
2323 event.mixedEvent.stringPtrDataLength = 1;
2324 SendArkUISyncEvent(&event);
2325 };
2326 TextFieldModelNG::SetOnDidInsertValueEvent(frameNode, std::move(onDidInsert));
2327 }
2328
SetTextAreaOnWillDeleteValue(ArkUINodeHandle node,void * extraParam)2329 void SetTextAreaOnWillDeleteValue(ArkUINodeHandle node, void* extraParam)
2330 {
2331 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2332 CHECK_NULL_VOID(frameNode);
2333 auto onWillDelete = [node, extraParam](const DeleteValueInfo& Info) -> bool {
2334 ArkUINodeEvent event;
2335 std::string deleteValueUtf8 = UtfUtils::Str16DebugToStr8(Info.deleteValue);
2336 event.kind = MIXED_EVENT;
2337 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2338 event.mixedEvent.subKind = ON_TEXT_AREA_WILL_DELETE;
2339 event.mixedEvent.numberData[0].f32 = Info.deleteOffset;
2340 event.mixedEvent.numberData[1].i32 = static_cast<int32_t>(Info.direction);
2341 event.mixedEvent.numberDataLength = 2;
2342 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(deleteValueUtf8.c_str());
2343 event.mixedEvent.stringPtrDataLength = 1;
2344 SendArkUISyncEvent(&event);
2345 return event.mixedEvent.numberReturnData[0].i32;
2346 };
2347 TextFieldModelNG::SetOnWillDeleteEvent(frameNode, std::move(onWillDelete));
2348 }
2349
SetTextAreaOnDidDeleteValue(ArkUINodeHandle node,void * extraParam)2350 void SetTextAreaOnDidDeleteValue(ArkUINodeHandle node, void* extraParam)
2351 {
2352 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2353 CHECK_NULL_VOID(frameNode);
2354 auto onDidDelete = [node, extraParam](const DeleteValueInfo& Info) {
2355 ArkUINodeEvent event;
2356 std::string deleteValueUtf8 = UtfUtils::Str16DebugToStr8(Info.deleteValue);
2357 event.kind = MIXED_EVENT;
2358 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2359 event.mixedEvent.subKind = ON_TEXT_AREA_DID_DELETE;
2360 event.mixedEvent.numberData[0].f32 = Info.deleteOffset;
2361 event.mixedEvent.numberData[1].i32 = static_cast<int32_t>(Info.direction);
2362 event.mixedEvent.numberDataLength = 2;
2363 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(deleteValueUtf8.c_str());
2364 event.mixedEvent.stringPtrDataLength = 1;
2365 SendArkUISyncEvent(&event);
2366 };
2367 TextFieldModelNG::SetOnDidDeleteEvent(frameNode, std::move(onDidDelete));
2368 }
2369
ResetOnTextAreaChange(ArkUINodeHandle node)2370 void ResetOnTextAreaChange(ArkUINodeHandle node)
2371 {
2372 GetTextAreaModifier()->resetTextAreaOnChange(node);
2373 }
ResetOnTextAreaChangeWithPreviewText(ArkUINodeHandle node)2374 void ResetOnTextAreaChangeWithPreviewText(ArkUINodeHandle node)
2375 {
2376 GetTextAreaModifier()->resetTextAreaOnChange(node);
2377 }
ResetOnTextAreaPaste(ArkUINodeHandle node)2378 void ResetOnTextAreaPaste(ArkUINodeHandle node)
2379 {
2380 GetTextAreaModifier()->resetTextAreaOnPaste(node);
2381 }
ResetOnTextAreaSelectionChange(ArkUINodeHandle node)2382 void ResetOnTextAreaSelectionChange(ArkUINodeHandle node)
2383 {
2384 GetTextAreaModifier()->resetTextAreaOnTextSelectionChange(node);
2385 }
ResetOnTextAreaEditChange(ArkUINodeHandle node)2386 void ResetOnTextAreaEditChange(ArkUINodeHandle node)
2387 {
2388 GetTextAreaModifier()->resetTextAreaOnEditChange(node);
2389 }
ResetOnTextAreaContentSizeChange(ArkUINodeHandle node)2390 void ResetOnTextAreaContentSizeChange(ArkUINodeHandle node)
2391 {
2392 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2393 CHECK_NULL_VOID(frameNode);
2394 TextFieldModelNG::SetOnContentSizeChange(frameNode, nullptr);
2395 }
ResetOnTextAreaInputFilterError(ArkUINodeHandle node)2396 void ResetOnTextAreaInputFilterError(ArkUINodeHandle node)
2397 {
2398 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2399 CHECK_NULL_VOID(frameNode);
2400 TextFieldModelNG::SetInputFilterError(frameNode, nullptr);
2401 }
ResetTextAreaOnTextContentScroll(ArkUINodeHandle node)2402 void ResetTextAreaOnTextContentScroll(ArkUINodeHandle node)
2403 {
2404 GetTextAreaModifier()->resetTextAreaOnContentScroll(node);
2405 }
ResetTextAreaOnSubmit(ArkUINodeHandle node)2406 void ResetTextAreaOnSubmit(ArkUINodeHandle node)
2407 {
2408 GetTextAreaModifier()->resetTextAreaOnSubmitWithEvent(node);
2409 }
2410 } // namespace NodeModifier
2411 } // namespace OHOS::Ace::NG
2412