1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "core/interfaces/native/node/node_text_input_modifier.h"
16 #include <functional>
17
18 #include "base/geometry/dimension.h"
19 #include "core/components/common/layout/constants.h"
20 #include "core/components/text_field/textfield_theme.h"
21 #include "core/components_ng/base/frame_node.h"
22 #include "core/components_ng/pattern/text_field/text_field_model_ng.h"
23 #include "core/pipeline/base/element_register.h"
24 #include "bridge/common/utils/utils.h"
25 #include "core/components_ng/base/view_abstract.h"
26 #include "core/components/common/properties/alignment.h"
27 #include "core/components/text_field/textfield_theme.h"
28 #include "core/interfaces/native/node/node_api.h"
29 #include "core/components_ng/pattern/text_field/text_field_event_hub.h"
30 #include "core/components/common/properties/text_style_parser.h"
31 #include "interfaces/native/node/node_model.h"
32
33 namespace OHOS::Ace::NG {
34 namespace {
35 const uint32_t MAX_LINES = 3;
36 constexpr uint32_t DEFAULT_CARET_COLOR = 0xFF007DFF;
37 constexpr uint32_t DEFAULT_CARE_POSITION = 0;
38 constexpr CopyOptions DEFAULT_TEXT_INPUT_COPY_OPTION = CopyOptions::Local;
39 constexpr bool DEFAULT_SHOW_PASSWORD_ICON_VALUE = true;
40 constexpr TextAlign DEFAULT_TEXT_ALIGN_VALUE = TextAlign::START;
41 constexpr InputStyle DEFAULT_INPUT_STYLE = InputStyle::DEFAULT;
42 constexpr bool DEFAULT_SELECTION_MENU_HIDDEN = false;
43 constexpr bool DEFAULT_SHOW_UNDER_LINE = false;
44 constexpr bool DEFAULT_ENABLE_AUTO_FILL = true;
45 constexpr bool DEFAULT_REQUEST_KEYBOARD_ON_FOCUS = true;
46 constexpr DisplayMode DEFAULT_BAR_STATE = DisplayMode::AUTO;
47 constexpr FontWeight DEFAULT_FONT_WEIGHT = FontWeight::NORMAL;
48 constexpr Ace::FontStyle DEFAULT_FONT_STYLE = Ace::FontStyle::NORMAL;
49 constexpr int16_t DEFAULT_ALPHA = 255;
50 constexpr double DEFAULT_OPACITY = 0.2;
51 const std::vector<std::string> DEFAULT_FONT_FAMILY = { "HarmonyOS Sans" };
52 const std::vector<TextAlign> TEXT_ALIGNS = { TextAlign::START, TextAlign::CENTER, TextAlign::END, TextAlign::JUSTIFY };
53 const uint32_t ERROR_UINT_CODE = -1;
54 const float ERROR_FLOAT_CODE = -1.0f;
55 const int32_t ERROR_INT_CODE = -1;
56 constexpr TextDecoration DEFAULT_TEXT_DECORATION = TextDecoration::NONE;
57 constexpr Color DEFAULT_DECORATION_COLOR = Color(0xff000000);
58 constexpr TextDecorationStyle DEFAULT_DECORATION_STYLE = TextDecorationStyle::SOLID;
59 constexpr int CALL_ARG_0 = 0;
60 constexpr int CALL_ARG_1 = 1;
61 constexpr int CALL_ARG_2 = 2;
62 constexpr int CALL_ARG_3 = 3;
63 constexpr int32_t DEFAULT_GROUP_UNDERLINE_COLOR_VALUES_COUNT = 4;
64 constexpr int32_t DEFAULT_MARGIN_VALUES_COUNT = 4;
65 constexpr bool DEFAULT_SELECT_ALL = false;
66 constexpr bool DEFAULT_ENABLE_PREVIEW_TEXT_VALUE = true;
67 constexpr bool DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE = true;
68 std::string g_strValue;
69
SetTextInputCaretColor(ArkUINodeHandle node,ArkUI_Uint32 color)70 void SetTextInputCaretColor(ArkUINodeHandle node, ArkUI_Uint32 color)
71 {
72 auto *frameNode = reinterpret_cast<FrameNode *>(node);
73 CHECK_NULL_VOID(frameNode);
74 TextFieldModelNG::SetCaretColor(frameNode, Color(color));
75 }
76
ResetTextInputCaretColor(ArkUINodeHandle node)77 void ResetTextInputCaretColor(ArkUINodeHandle node)
78 {
79 auto *frameNode = reinterpret_cast<FrameNode *>(node);
80 CHECK_NULL_VOID(frameNode);
81 TextFieldModelNG::SetCaretColor(frameNode, Color(DEFAULT_CARET_COLOR));
82 }
83
SetTextInputType(ArkUINodeHandle node,ArkUI_Int32 value)84 void SetTextInputType(ArkUINodeHandle node, ArkUI_Int32 value)
85 {
86 auto *frameNode = reinterpret_cast<FrameNode *>(node);
87 CHECK_NULL_VOID(frameNode);
88 TextFieldModelNG::SetType(frameNode, CastToTextInputType(value));
89 }
90
ResetTextInputType(ArkUINodeHandle node)91 void ResetTextInputType(ArkUINodeHandle node)
92 {
93 auto *frameNode = reinterpret_cast<FrameNode *>(node);
94 CHECK_NULL_VOID(frameNode);
95 TextFieldModelNG::SetType(frameNode, TextInputType::UNSPECIFIED);
96 return;
97 }
98
SetTextInputMaxLines(ArkUINodeHandle node,ArkUI_Int32 value)99 void SetTextInputMaxLines(ArkUINodeHandle node, ArkUI_Int32 value)
100 {
101 auto *frameNode = reinterpret_cast<FrameNode *>(node);
102 CHECK_NULL_VOID(frameNode);
103 if (value <= 0) {
104 TextFieldModelNG::SetMaxViewLines(frameNode, MAX_LINES);
105 return;
106 }
107
108 TextFieldModelNG::SetMaxViewLines(frameNode, value);
109 }
110
ResetTextInputMaxLines(ArkUINodeHandle node)111 void ResetTextInputMaxLines(ArkUINodeHandle node)
112 {
113 auto *frameNode = reinterpret_cast<FrameNode *>(node);
114 CHECK_NULL_VOID(frameNode);
115 TextFieldModelNG::SetMaxViewLines(frameNode, MAX_LINES);
116 }
117
SetTextInputPlaceholderColor(ArkUINodeHandle node,ArkUI_Uint32 color)118 void SetTextInputPlaceholderColor(ArkUINodeHandle node, ArkUI_Uint32 color)
119 {
120 auto *frameNode = reinterpret_cast<FrameNode *>(node);
121 CHECK_NULL_VOID(frameNode);
122 TextFieldModelNG::SetPlaceholderColor(frameNode, Color(color));
123 }
124
ResetTextInputPlaceholderColor(ArkUINodeHandle node)125 void ResetTextInputPlaceholderColor(ArkUINodeHandle node)
126 {
127 auto *frameNode = reinterpret_cast<FrameNode *>(node);
128 CHECK_NULL_VOID(frameNode);
129 auto pipeline = frameNode->GetContext();
130 CHECK_NULL_VOID(pipeline);
131 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
132 CHECK_NULL_VOID(theme);
133 TextFieldModelNG::SetPlaceholderColor(frameNode, theme->GetPlaceholderColor());
134 }
135
SetTextInputCaretPosition(ArkUINodeHandle node,ArkUI_Int32 caretPosition)136 void SetTextInputCaretPosition(ArkUINodeHandle node, ArkUI_Int32 caretPosition)
137 {
138 auto *frameNode = reinterpret_cast<FrameNode *>(node);
139 CHECK_NULL_VOID(frameNode);
140 TextFieldModelNG::SetCaretPosition(frameNode, caretPosition);
141 }
142
ResetTextInputCaretPosition(ArkUINodeHandle node)143 void ResetTextInputCaretPosition(ArkUINodeHandle node)
144 {
145 auto *frameNode = reinterpret_cast<FrameNode *>(node);
146 CHECK_NULL_VOID(frameNode);
147 TextFieldModelNG::SetCaretPosition(frameNode, DEFAULT_CARE_POSITION);
148 }
149
SetTextInputCopyOption(ArkUINodeHandle node,ArkUI_Int32 copyOption)150 void SetTextInputCopyOption(ArkUINodeHandle node, ArkUI_Int32 copyOption)
151 {
152 auto *frameNode = reinterpret_cast<FrameNode *>(node);
153 CHECK_NULL_VOID(frameNode);
154 TextFieldModelNG::SetCopyOption(frameNode, static_cast<CopyOptions>(copyOption));
155 }
156
ResetTextInputCopyOption(ArkUINodeHandle node)157 void ResetTextInputCopyOption(ArkUINodeHandle node)
158 {
159 auto *frameNode = reinterpret_cast<FrameNode *>(node);
160 CHECK_NULL_VOID(frameNode);
161 TextFieldModelNG::SetCopyOption(frameNode, DEFAULT_TEXT_INPUT_COPY_OPTION);
162 }
163
SetTextInputShowPasswordIcon(ArkUINodeHandle node,ArkUI_Uint32 value)164 void SetTextInputShowPasswordIcon(ArkUINodeHandle node, ArkUI_Uint32 value)
165 {
166 auto *frameNode = reinterpret_cast<FrameNode *>(node);
167 CHECK_NULL_VOID(frameNode);
168 TextFieldModelNG::SetShowPasswordIcon(frameNode, static_cast<bool>(value));
169 }
170
ResetTextInputShowPasswordIcon(ArkUINodeHandle node)171 void ResetTextInputShowPasswordIcon(ArkUINodeHandle node)
172 {
173 auto *frameNode = reinterpret_cast<FrameNode *>(node);
174 CHECK_NULL_VOID(frameNode);
175 TextFieldModelNG::SetShowPasswordIcon(frameNode, DEFAULT_SHOW_PASSWORD_ICON_VALUE);
176 }
177
SetTextInputPasswordIcon(ArkUINodeHandle node,const struct ArkUIPasswordIconType * value)178 void SetTextInputPasswordIcon(ArkUINodeHandle node, const struct ArkUIPasswordIconType* value)
179 {
180 auto *frameNode = reinterpret_cast<FrameNode *>(node);
181 CHECK_NULL_VOID(frameNode);
182 PasswordIcon passwordIcon;
183 if (value->showResult != nullptr && std::string(value->showResult) != "") {
184 passwordIcon.showResult = value->showResult;
185 } else {
186 if (value->showBundleName != nullptr && std::string(value->showBundleName) != "") {
187 passwordIcon.showBundleName = value->showBundleName;
188 }
189 if (value->showModuleName != nullptr && std::string(value->showModuleName) != "") {
190 passwordIcon.showModuleName = value->showModuleName;
191 }
192 }
193 if (value->hideResult != nullptr && std::string(value->hideResult) != "") {
194 passwordIcon.hideResult = value->hideResult;
195 } else {
196 if (value->hideBundleName != nullptr && std::string(value->hideBundleName) != "") {
197 passwordIcon.hideBundleName = value->hideBundleName;
198 }
199 if (value->hideModuleName != nullptr && std::string(value->hideModuleName) != "") {
200 passwordIcon.hideModuleName = value->hideModuleName;
201 }
202 }
203 TextFieldModelNG::SetPasswordIcon(frameNode, passwordIcon);
204 }
205
ResetTextInputPasswordIcon(ArkUINodeHandle node)206 void ResetTextInputPasswordIcon(ArkUINodeHandle node)
207 {
208 auto *frameNode = reinterpret_cast<FrameNode *>(node);
209 CHECK_NULL_VOID(frameNode);
210 PasswordIcon passwordIcon;
211 passwordIcon.showResult = "";
212 passwordIcon.hideResult = "";
213 TextFieldModelNG::SetPasswordIcon(frameNode, passwordIcon);
214 }
215
SetTextInputTextAlign(ArkUINodeHandle node,ArkUI_Int32 value)216 void SetTextInputTextAlign(ArkUINodeHandle node, ArkUI_Int32 value)
217 {
218 auto *frameNode = reinterpret_cast<FrameNode *>(node);
219 CHECK_NULL_VOID(frameNode);
220 if (value >= 0 && value < static_cast<int32_t>(TEXT_ALIGNS.size())) {
221 TextFieldModelNG::SetTextAlign(frameNode, TEXT_ALIGNS[value]);
222 } else {
223 TextFieldModelNG::SetTextAlign(frameNode, DEFAULT_TEXT_ALIGN_VALUE);
224 }
225 }
226
ResetTextInputTextAlign(ArkUINodeHandle node)227 void ResetTextInputTextAlign(ArkUINodeHandle node)
228 {
229 auto *frameNode = reinterpret_cast<FrameNode *>(node);
230 CHECK_NULL_VOID(frameNode);
231 TextFieldModelNG::SetTextAlign(frameNode, DEFAULT_TEXT_ALIGN_VALUE);
232 }
233
SetTextInputStyle(ArkUINodeHandle node,ArkUI_Int32 style)234 void SetTextInputStyle(ArkUINodeHandle node, ArkUI_Int32 style)
235 {
236 auto *frameNode = reinterpret_cast<FrameNode *>(node);
237 CHECK_NULL_VOID(frameNode);
238 TextFieldModelNG::SetInputStyle(frameNode, static_cast<InputStyle>(style));
239 }
240
GetTextInputStyle(ArkUINodeHandle node)241 ArkUI_Int32 GetTextInputStyle(ArkUINodeHandle node)
242 {
243 auto *frameNode = reinterpret_cast<FrameNode *>(node);
244 CHECK_NULL_RETURN(frameNode, 0);
245 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetInputStyle(frameNode));
246 }
247
ResetTextInputStyle(ArkUINodeHandle node)248 void ResetTextInputStyle(ArkUINodeHandle node)
249 {
250 auto *frameNode = reinterpret_cast<FrameNode *>(node);
251 CHECK_NULL_VOID(frameNode);
252 TextFieldModelNG::SetInputStyle(frameNode, DEFAULT_INPUT_STYLE);
253 }
254
GetTextInputContentRect(ArkUINodeHandle node,ArkUI_Float32 (* values)[4])255 void GetTextInputContentRect(ArkUINodeHandle node, ArkUI_Float32 (*values)[4])
256 {
257 auto *frameNode = reinterpret_cast<FrameNode *>(node);
258 CHECK_NULL_VOID(frameNode);
259 auto textFieldController = TextFieldModelNG::GetOrCreateController(frameNode);
260 auto rect = textFieldController->GetTextContentRect();
261 (*values)[CALL_ARG_0] = rect.Left();
262 (*values)[CALL_ARG_1] = rect.Top();
263 (*values)[CALL_ARG_2] = rect.Width();
264 (*values)[CALL_ARG_3] = rect.Height();
265 }
266
GetTextInputContentLinesNum(ArkUINodeHandle node)267 ArkUI_Int32 GetTextInputContentLinesNum(ArkUINodeHandle node)
268 {
269 auto *frameNode = reinterpret_cast<FrameNode *>(node);
270 CHECK_NULL_RETURN(frameNode, 0);
271 auto textFieldController = TextFieldModelNG::GetOrCreateController(frameNode);
272 return static_cast<ArkUI_Int32>(textFieldController->GetTextContentLinesNum());
273 }
274
SetTextInputSelectionMenuHidden(ArkUINodeHandle node,ArkUI_Uint32 menuHiddenValue)275 void SetTextInputSelectionMenuHidden(ArkUINodeHandle node, ArkUI_Uint32 menuHiddenValue)
276 {
277 auto *frameNode = reinterpret_cast<FrameNode *>(node);
278 CHECK_NULL_VOID(frameNode);
279 TextFieldModelNG::SetSelectionMenuHidden(frameNode, static_cast<bool>(menuHiddenValue));
280 }
281
ResetTextInputSelectionMenuHidden(ArkUINodeHandle node)282 void ResetTextInputSelectionMenuHidden(ArkUINodeHandle node)
283 {
284 auto *frameNode = reinterpret_cast<FrameNode *>(node);
285 CHECK_NULL_VOID(frameNode);
286 TextFieldModelNG::SetSelectionMenuHidden(frameNode, DEFAULT_SELECTION_MENU_HIDDEN);
287 }
288
SetTextInputShowUnderline(ArkUINodeHandle node,ArkUI_Uint32 showUnderLine)289 void SetTextInputShowUnderline(ArkUINodeHandle node, ArkUI_Uint32 showUnderLine)
290 {
291 auto *frameNode = reinterpret_cast<FrameNode *>(node);
292 CHECK_NULL_VOID(frameNode);
293 TextFieldModelNG::SetShowUnderline(frameNode, static_cast<bool>(showUnderLine));
294 }
295
ResetTextInputShowUnderline(ArkUINodeHandle node)296 void ResetTextInputShowUnderline(ArkUINodeHandle node)
297 {
298 auto *frameNode = reinterpret_cast<FrameNode *>(node);
299 CHECK_NULL_VOID(frameNode);
300 TextFieldModelNG::SetShowUnderline(frameNode, DEFAULT_SHOW_UNDER_LINE);
301 }
302
SetTextInputPasswordRules(ArkUINodeHandle node,ArkUI_CharPtr passwordRules)303 void SetTextInputPasswordRules(ArkUINodeHandle node, ArkUI_CharPtr passwordRules)
304 {
305 auto *frameNode = reinterpret_cast<FrameNode *>(node);
306 CHECK_NULL_VOID(frameNode);
307 std::string strValue = passwordRules;
308 TextFieldModelNG::SetPasswordRules(frameNode, strValue);
309 }
310
GetTextInputPasswordRules(ArkUINodeHandle node)311 ArkUI_CharPtr GetTextInputPasswordRules(ArkUINodeHandle node)
312 {
313 auto *frameNode = reinterpret_cast<FrameNode *>(node);
314 CHECK_NULL_RETURN(frameNode, "");
315 g_strValue = TextFieldModelNG::GetPasswordRules(frameNode);
316 return g_strValue.c_str();
317 }
318
ResetTextInputPasswordRules(ArkUINodeHandle node)319 void ResetTextInputPasswordRules(ArkUINodeHandle node)
320 {
321 auto *frameNode = reinterpret_cast<FrameNode *>(node);
322 CHECK_NULL_VOID(frameNode);
323 TextFieldModelNG::SetPasswordRules(frameNode, "");
324 }
325
SetTextInputEnableAutoFill(ArkUINodeHandle node,ArkUI_Uint32 enableAutoFill)326 void SetTextInputEnableAutoFill(ArkUINodeHandle node, ArkUI_Uint32 enableAutoFill)
327 {
328 auto *frameNode = reinterpret_cast<FrameNode *>(node);
329 CHECK_NULL_VOID(frameNode);
330 TextFieldModelNG::SetEnableAutoFill(frameNode, static_cast<bool>(enableAutoFill));
331 }
332
GetTextInputEnableAutoFill(ArkUINodeHandle node)333 ArkUI_Int32 GetTextInputEnableAutoFill(ArkUINodeHandle node)
334 {
335 auto *frameNode = reinterpret_cast<FrameNode *>(node);
336 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
337 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetEnableAutoFill(frameNode));
338 }
339
ResetTextInputEnableAutoFill(ArkUINodeHandle node)340 void ResetTextInputEnableAutoFill(ArkUINodeHandle node)
341 {
342 auto *frameNode = reinterpret_cast<FrameNode *>(node);
343 CHECK_NULL_VOID(frameNode);
344 TextFieldModelNG::SetEnableAutoFill(frameNode, DEFAULT_ENABLE_AUTO_FILL);
345 }
346
GetTextInputSelectAll(ArkUINodeHandle node)347 ArkUI_Int32 GetTextInputSelectAll(ArkUINodeHandle node)
348 {
349 auto *frameNode = reinterpret_cast<FrameNode *>(node);
350 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
351 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetSelectAllValue(frameNode));
352 }
353
SetTextInputInputFilter(ArkUINodeHandle node,ArkUI_CharPtr inputFilter)354 void SetTextInputInputFilter(ArkUINodeHandle node, ArkUI_CharPtr inputFilter)
355 {
356 auto *frameNode = reinterpret_cast<FrameNode *>(node);
357 CHECK_NULL_VOID(frameNode);
358 TextFieldModelNG::SetInputFilter(frameNode, inputFilter);
359 }
360
GetTextInputInputFilter(ArkUINodeHandle node)361 ArkUI_CharPtr GetTextInputInputFilter(ArkUINodeHandle node)
362 {
363 auto *frameNode = reinterpret_cast<FrameNode *>(node);
364 CHECK_NULL_RETURN(frameNode, "");
365 g_strValue = TextFieldModelNG::GetInputFilter(frameNode);
366 return g_strValue.c_str();
367 }
368
ResetTextInputInputFilter(ArkUINodeHandle node)369 void ResetTextInputInputFilter(ArkUINodeHandle node)
370 {
371 auto *frameNode = reinterpret_cast<FrameNode *>(node);
372 CHECK_NULL_VOID(frameNode);
373 TextFieldModelNG::SetInputFilter(frameNode, "");
374 }
375
GetTextInputCaretIndex(ArkUINodeHandle node)376 ArkUI_Int32 GetTextInputCaretIndex(ArkUINodeHandle node)
377 {
378 auto *frameNode = reinterpret_cast<FrameNode *>(node);
379 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
380 auto textFieldController = TextFieldModelNG::GetOrCreateController(frameNode);
381 return textFieldController->GetCaretIndex();
382 }
383
GetTextInputCaretOffset(ArkUINodeHandle node,ArkUI_Float32 (* values)[2])384 void GetTextInputCaretOffset(ArkUINodeHandle node, ArkUI_Float32 (*values)[2])
385 {
386 auto *frameNode = reinterpret_cast<FrameNode *>(node);
387 CHECK_NULL_VOID(frameNode);
388 auto textFieldController = TextFieldModelNG::GetOrCreateController(frameNode);
389 auto offset = textFieldController->GetCaretPosition();
390 (*values)[0] = offset.GetX();
391 (*values)[1] = offset.GetY();
392 }
393
SetTextInputContentType(ArkUINodeHandle node,ArkUI_Uint32 contentType)394 void SetTextInputContentType(ArkUINodeHandle node, ArkUI_Uint32 contentType)
395 {
396 auto *frameNode = reinterpret_cast<FrameNode *>(node);
397 CHECK_NULL_VOID(frameNode);
398 if (contentType < 0 || contentType > static_cast<ArkUI_Uint32>(TextContentType::END)) {
399 contentType = -1;
400 }
401 TextFieldModelNG::SetContentType(frameNode, static_cast<NG::TextContentType>(contentType));
402 }
403
GetTextInputContentType(ArkUINodeHandle node)404 ArkUI_Int32 GetTextInputContentType(ArkUINodeHandle node)
405 {
406 auto *frameNode = reinterpret_cast<FrameNode *>(node);
407 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
408 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetContentType(frameNode));
409 }
410
ResetTextInputContentType(ArkUINodeHandle node)411 void ResetTextInputContentType(ArkUINodeHandle node)
412 {
413 auto *frameNode = reinterpret_cast<FrameNode *>(node);
414 CHECK_NULL_VOID(frameNode);
415 TextFieldModelNG::SetContentType(frameNode, static_cast<NG::TextContentType>(TextContentType::UNSPECIFIED));
416 }
417
SetTextInputCaretStyle(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit,ArkUI_Uint32 caretColor)418 void SetTextInputCaretStyle(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit, ArkUI_Uint32 caretColor)
419 {
420 auto *frameNode = reinterpret_cast<FrameNode *>(node);
421 CHECK_NULL_VOID(frameNode);
422 CaretStyle caretStyle;
423 caretStyle.caretWidth = CalcDimension(value, (DimensionUnit)unit);
424 TextFieldModelNG::SetCaretStyle(frameNode, caretStyle);
425 TextFieldModelNG::SetCaretColor(frameNode, Color(caretColor));
426 }
427
ResetTextInputCaretStyle(ArkUINodeHandle node)428 void ResetTextInputCaretStyle(ArkUINodeHandle node)
429 {
430 auto *frameNode = reinterpret_cast<FrameNode *>(node);
431 CHECK_NULL_VOID(frameNode);
432
433 auto pipeline = frameNode->GetContext();
434 CHECK_NULL_VOID(pipeline);
435 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
436 CHECK_NULL_VOID(theme);
437
438 CaretStyle caretStyle;
439 caretStyle.caretWidth = theme->GetCursorWidth();
440 uint32_t caretColor = theme->GetCursorColor().GetValue();
441 TextFieldModelNG::SetCaretStyle(frameNode, caretStyle);
442 TextFieldModelNG::SetCaretColor(frameNode, Color(caretColor));
443 }
444
SetTextInputEnableKeyboardOnFocus(ArkUINodeHandle node,ArkUI_Uint32 value)445 void SetTextInputEnableKeyboardOnFocus(ArkUINodeHandle node, ArkUI_Uint32 value)
446 {
447 auto *frameNode = reinterpret_cast<FrameNode *>(node);
448 CHECK_NULL_VOID(frameNode);
449 TextFieldModelNG::RequestKeyboardOnFocus(frameNode, static_cast<bool>(value));
450 }
451
ResetTextInputEnableKeyboardOnFocus(ArkUINodeHandle node)452 void ResetTextInputEnableKeyboardOnFocus(ArkUINodeHandle node)
453 {
454 auto *frameNode = reinterpret_cast<FrameNode *>(node);
455 CHECK_NULL_VOID(frameNode);
456 TextFieldModelNG::RequestKeyboardOnFocus(frameNode, DEFAULT_REQUEST_KEYBOARD_ON_FOCUS);
457 }
458
SetTextInputBarState(ArkUINodeHandle node,ArkUI_Int32 value)459 void SetTextInputBarState(ArkUINodeHandle node, ArkUI_Int32 value)
460 {
461 auto *frameNode = reinterpret_cast<FrameNode *>(node);
462 CHECK_NULL_VOID(frameNode);
463 TextFieldModelNG::SetBarState(frameNode, static_cast<DisplayMode>(value));
464 }
465
ResetTextInputBarState(ArkUINodeHandle node)466 void ResetTextInputBarState(ArkUINodeHandle node)
467 {
468 auto *frameNode = reinterpret_cast<FrameNode *>(node);
469 CHECK_NULL_VOID(frameNode);
470 TextFieldModelNG::SetBarState(frameNode, DEFAULT_BAR_STATE);
471 }
472
SetTextInputEnterKeyType(ArkUINodeHandle node,ArkUI_Int32 value)473 void SetTextInputEnterKeyType(ArkUINodeHandle node, ArkUI_Int32 value)
474 {
475 auto *frameNode = reinterpret_cast<FrameNode *>(node);
476 CHECK_NULL_VOID(frameNode);
477 TextFieldModelNG::SetEnterKeyType(frameNode, static_cast<TextInputAction>(value));
478 }
479
ResetTextInputEnterKeyType(ArkUINodeHandle node)480 void ResetTextInputEnterKeyType(ArkUINodeHandle node)
481 {
482 auto *frameNode = reinterpret_cast<FrameNode *>(node);
483 CHECK_NULL_VOID(frameNode);
484 TextFieldModelNG::SetEnterKeyType(frameNode, TextInputAction::DONE);
485 }
486
SetTextInputFontWeightStr(ArkUINodeHandle node,ArkUI_CharPtr fontWeight)487 void SetTextInputFontWeightStr(ArkUINodeHandle node, ArkUI_CharPtr fontWeight)
488 {
489 auto *frameNode = reinterpret_cast<FrameNode *>(node);
490 CHECK_NULL_VOID(frameNode);
491 TextFieldModelNG::SetFontWeight(frameNode, Framework::ConvertStrToFontWeight(fontWeight));
492 }
493
SetTextInputFontWeight(ArkUINodeHandle node,ArkUI_Int32 fontWeight)494 void SetTextInputFontWeight(ArkUINodeHandle node, ArkUI_Int32 fontWeight)
495 {
496 auto *frameNode = reinterpret_cast<FrameNode *>(node);
497 CHECK_NULL_VOID(frameNode);
498 TextFieldModelNG::SetFontWeight(frameNode, static_cast<FontWeight>(fontWeight));
499 }
500
ResetTextInputFontWeight(ArkUINodeHandle node)501 void ResetTextInputFontWeight(ArkUINodeHandle node)
502 {
503 auto *frameNode = reinterpret_cast<FrameNode *>(node);
504 CHECK_NULL_VOID(frameNode);
505 TextFieldModelNG::SetFontWeight(frameNode, FontWeight::NORMAL);
506 }
507
SetTextInputFontSize(ArkUINodeHandle node,const struct ArkUILengthType * value)508 void SetTextInputFontSize(ArkUINodeHandle node, const struct ArkUILengthType *value)
509 {
510 auto *frameNode = reinterpret_cast<FrameNode *>(node);
511 CHECK_NULL_VOID(frameNode);
512 CalcDimension fontSize;
513 if (value->string != nullptr) {
514 fontSize.SetCalcValue(value->string);
515 } else {
516 fontSize.SetValue(value->number);
517 }
518 fontSize.SetUnit(static_cast<DimensionUnit>(value->unit));
519 TextFieldModelNG::SetFontSize(frameNode, fontSize);
520 }
521
ResetTextInputFontSize(ArkUINodeHandle node)522 void ResetTextInputFontSize(ArkUINodeHandle node)
523 {
524 auto *frameNode = reinterpret_cast<FrameNode *>(node);
525 CHECK_NULL_VOID(frameNode);
526 auto pipeline = frameNode->GetContext();
527 CHECK_NULL_VOID(pipeline);
528 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
529 CHECK_NULL_VOID(theme);
530 TextFieldModelNG::SetFontSize(frameNode, theme->GetFontSize());
531 }
532
SetTextInputMaxLength(ArkUINodeHandle node,ArkUI_Uint32 value)533 void SetTextInputMaxLength(ArkUINodeHandle node, ArkUI_Uint32 value)
534 {
535 auto *frameNode = reinterpret_cast<FrameNode *>(node);
536 CHECK_NULL_VOID(frameNode);
537 TextFieldModelNG::SetMaxLength(frameNode, value);
538 }
539
ResetTextInputMaxLength(ArkUINodeHandle node)540 void ResetTextInputMaxLength(ArkUINodeHandle node)
541 {
542 auto *frameNode = reinterpret_cast<FrameNode *>(node);
543 CHECK_NULL_VOID(frameNode);
544 TextFieldModelNG::ResetMaxLength(frameNode);
545 }
546
SetTextInputSelectedBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)547 void SetTextInputSelectedBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
548 {
549 auto *frameNode = reinterpret_cast<FrameNode *>(node);
550 CHECK_NULL_VOID(frameNode);
551 TextFieldModelNG::SetSelectedBackgroundColor(frameNode, Color(color));
552 }
553
ResetTextInputSelectedBackgroundColor(ArkUINodeHandle node)554 void ResetTextInputSelectedBackgroundColor(ArkUINodeHandle node)
555 {
556 auto *frameNode = reinterpret_cast<FrameNode *>(node);
557 CHECK_NULL_VOID(frameNode);
558 Color selectedColor;
559 auto pipeline = frameNode->GetContext();
560 CHECK_NULL_VOID(pipeline);
561 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
562 CHECK_NULL_VOID(theme);
563 selectedColor = theme->GetSelectedColor();
564 if (selectedColor.GetAlpha() == DEFAULT_ALPHA) {
565 // Default setting of 20% opacity
566 selectedColor = selectedColor.ChangeOpacity(DEFAULT_OPACITY);
567 }
568 TextFieldModelNG::SetSelectedBackgroundColor(frameNode, selectedColor);
569 }
570
SetTextInputShowError(ArkUINodeHandle node,ArkUI_CharPtr error,ArkUI_Uint32 visible)571 void SetTextInputShowError(ArkUINodeHandle node, ArkUI_CharPtr error, ArkUI_Uint32 visible)
572 {
573 auto *frameNode = reinterpret_cast<FrameNode *>(node);
574 CHECK_NULL_VOID(frameNode);
575 TextFieldModelNG::SetShowError(frameNode, std::string(error), static_cast<bool>(visible));
576 }
577
ResetTextInputShowError(ArkUINodeHandle node)578 void ResetTextInputShowError(ArkUINodeHandle node)
579 {
580 auto *frameNode = reinterpret_cast<FrameNode *>(node);
581 CHECK_NULL_VOID(frameNode);
582 TextFieldModelNG::SetShowError(frameNode, std::string(""), false);
583 }
584
SetTextInputPlaceholderFont(ArkUINodeHandle node,const struct ArkUIPlaceholderFontType * placeholderFont)585 void SetTextInputPlaceholderFont(ArkUINodeHandle node, const struct ArkUIPlaceholderFontType* placeholderFont)
586 {
587 auto *frameNode = reinterpret_cast<FrameNode *>(node);
588 CHECK_NULL_VOID(frameNode);
589 Font font;
590 CalcDimension fontSize;
591 if (placeholderFont->size != nullptr) {
592 if (placeholderFont->size->string != nullptr) {
593 fontSize.SetCalcValue(placeholderFont->size->string);
594 } else {
595 fontSize.SetValue(placeholderFont->size->number);
596 }
597 fontSize.SetUnit(static_cast<DimensionUnit>(placeholderFont->size->unit));
598 }
599 font.fontSize = fontSize;
600 if (placeholderFont->weight != nullptr && !std::string(placeholderFont->weight).empty()) {
601 font.fontWeight = Framework::ConvertStrToFontWeight(placeholderFont->weight);
602 } else if (placeholderFont->weightEnum > -1) {
603 font.fontWeight = static_cast<FontWeight>(placeholderFont->weightEnum);
604 }
605 if (placeholderFont->fontFamilies != nullptr && placeholderFont->length > 0) {
606 for (uint32_t i = 0; i < placeholderFont->length; i++) {
607 const char* family = *(placeholderFont->fontFamilies + i);
608 if (family != nullptr) {
609 font.fontFamilies.emplace_back(std::string(family));
610 }
611 }
612 }
613 if (placeholderFont->style >= 0) {
614 font.fontStyle = static_cast<Ace::FontStyle>(placeholderFont->style);
615 }
616 TextFieldModelNG::SetPlaceholderFont(frameNode, font);
617 }
618
ResetTextInputPlaceholderFont(ArkUINodeHandle node)619 void ResetTextInputPlaceholderFont(ArkUINodeHandle node)
620 {
621 auto *frameNode = reinterpret_cast<FrameNode *>(node);
622 CHECK_NULL_VOID(frameNode);
623 Font font;
624 auto pipeline = frameNode->GetContext();
625 CHECK_NULL_VOID(pipeline);
626 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
627 CHECK_NULL_VOID(theme);
628 font.fontSize = theme->GetFontSize();
629 font.fontWeight = DEFAULT_FONT_WEIGHT;
630 font.fontStyle = DEFAULT_FONT_STYLE;
631 TextFieldModelNG::SetPlaceholderFont(frameNode, font);
632 }
633
SetTextInputFontColor(ArkUINodeHandle node,ArkUI_Uint32 color)634 void SetTextInputFontColor(ArkUINodeHandle node, ArkUI_Uint32 color)
635 {
636 auto *frameNode = reinterpret_cast<FrameNode *>(node);
637 CHECK_NULL_VOID(frameNode);
638 TextFieldModelNG::SetTextColor(frameNode, Color(color));
639 }
640
ResetTextInputFontColor(ArkUINodeHandle node)641 void ResetTextInputFontColor(ArkUINodeHandle node)
642 {
643 auto *frameNode = reinterpret_cast<FrameNode *>(node);
644 CHECK_NULL_VOID(frameNode);
645 auto pipeline = frameNode->GetContext();
646 CHECK_NULL_VOID(pipeline);
647 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
648 CHECK_NULL_VOID(theme);
649 TextFieldModelNG::SetTextColor(frameNode, theme->GetTextColor());
650 }
651
SetTextInputFontStyle(ArkUINodeHandle node,ArkUI_Uint32 value)652 void SetTextInputFontStyle(ArkUINodeHandle node, ArkUI_Uint32 value)
653 {
654 auto *frameNode = reinterpret_cast<FrameNode *>(node);
655 CHECK_NULL_VOID(frameNode);
656 TextFieldModelNG::SetFontStyle(frameNode, static_cast<Ace::FontStyle>(value));
657 }
658
ResetTextInputFontStyle(ArkUINodeHandle node)659 void ResetTextInputFontStyle(ArkUINodeHandle node)
660 {
661 auto *frameNode = reinterpret_cast<FrameNode *>(node);
662 CHECK_NULL_VOID(frameNode);
663 TextFieldModelNG::SetFontStyle(frameNode, DEFAULT_FONT_STYLE);
664 }
665
SetTextInputFontFamily(ArkUINodeHandle node,ArkUI_CharPtr * fontFamilies,ArkUI_Uint32 length)666 void SetTextInputFontFamily(ArkUINodeHandle node, ArkUI_CharPtr* fontFamilies, ArkUI_Uint32 length)
667 {
668 CHECK_NULL_VOID(fontFamilies);
669 if (length <= 0) {
670 return;
671 }
672 auto *frameNode = reinterpret_cast<FrameNode *>(node);
673 CHECK_NULL_VOID(frameNode);
674 std::vector<std::string> families;
675 for (uint32_t i = 0; i < length; i++) {
676 const char* family = *(fontFamilies + i);
677 if (family != nullptr) {
678 families.emplace_back(std::string(family));
679 }
680 }
681 TextFieldModelNG::SetFontFamily(frameNode, families);
682 }
683
ResetTextInputFontFamily(ArkUINodeHandle node)684 void ResetTextInputFontFamily(ArkUINodeHandle node)
685 {
686 auto *frameNode = reinterpret_cast<FrameNode *>(node);
687 CHECK_NULL_VOID(frameNode);
688 TextFieldModelNG::SetFontFamily(frameNode, DEFAULT_FONT_FAMILY);
689 }
690
SetTextInputPlaceholderString(ArkUINodeHandle node,ArkUI_CharPtr value)691 void SetTextInputPlaceholderString(ArkUINodeHandle node, ArkUI_CharPtr value)
692 {
693 auto *frameNode = reinterpret_cast<FrameNode *>(node);
694 CHECK_NULL_VOID(frameNode);
695 std::string placeholderStr(value);
696 TextFieldModelNG::SetTextFieldPlaceHolder(frameNode, placeholderStr);
697 }
698
SetTextInputTextString(ArkUINodeHandle node,ArkUI_CharPtr value)699 void SetTextInputTextString(ArkUINodeHandle node, ArkUI_CharPtr value)
700 {
701 auto *frameNode = reinterpret_cast<FrameNode *>(node);
702 CHECK_NULL_VOID(frameNode);
703 std::string textStr(value);
704 TextFieldModelNG::SetTextFieldText(frameNode, textStr);
705 }
706
StopTextInputTextEditing(ArkUINodeHandle node)707 void StopTextInputTextEditing(ArkUINodeHandle node)
708 {
709 auto *frameNode = reinterpret_cast<FrameNode *>(node);
710 CHECK_NULL_VOID(frameNode);
711 TextFieldModelNG::StopTextFieldEditing(frameNode);
712 }
713
SetTextInputCancelButton(ArkUINodeHandle node,ArkUI_Int32 style,const struct ArkUISizeType * size,ArkUI_Uint32 color,ArkUI_CharPtr src)714 void SetTextInputCancelButton(ArkUINodeHandle node, ArkUI_Int32 style, const struct ArkUISizeType* size,
715 ArkUI_Uint32 color, ArkUI_CharPtr src)
716 {
717 auto *frameNode = reinterpret_cast<FrameNode *>(node);
718 CHECK_NULL_VOID(frameNode);
719 TextFieldModelNG::SetCleanNodeStyle(frameNode, static_cast<CleanNodeStyle>(style));
720 TextFieldModelNG::SetIsShowCancelButton(frameNode, true);
721 // set icon size
722 CalcDimension iconSize = CalcDimension(size->value, static_cast<DimensionUnit>(size->unit));
723 if (LessNotEqual(iconSize.Value(), 0.0)) {
724 auto pipeline = frameNode->GetContext();
725 CHECK_NULL_VOID(pipeline);
726 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
727 iconSize = theme->GetIconSize();
728 }
729 TextFieldModelNG::SetCancelIconSize(frameNode, iconSize);
730 // set icon src
731 std::string iconSrc(src);
732 TextFieldModelNG::SetCanacelIconSrc(frameNode, iconSrc);
733 // set icon color
734 Color iconColor(color);
735 TextFieldModelNG::SetCancelIconColor(frameNode, iconColor);
736 }
737
resetTextInputCancelButton(ArkUINodeHandle node)738 void resetTextInputCancelButton(ArkUINodeHandle node)
739 {
740 auto *frameNode = reinterpret_cast<FrameNode *>(node);
741 CHECK_NULL_VOID(frameNode);
742 TextFieldModelNG::SetCleanNodeStyle(frameNode, CleanNodeStyle::INPUT);
743 TextFieldModelNG::SetIsShowCancelButton(frameNode, false);
744 }
745
GetTextInputPlaceholder(ArkUINodeHandle node)746 ArkUI_CharPtr GetTextInputPlaceholder(ArkUINodeHandle node)
747 {
748 auto *frameNode = reinterpret_cast<FrameNode *>(node);
749 CHECK_NULL_RETURN(frameNode, "");
750 g_strValue = TextFieldModelNG::GetPlaceholderText(frameNode);
751 return g_strValue.c_str();
752 }
753
GetTextInputText(ArkUINodeHandle node)754 ArkUI_CharPtr GetTextInputText(ArkUINodeHandle node)
755 {
756 auto *frameNode = reinterpret_cast<FrameNode *>(node);
757 CHECK_NULL_RETURN(frameNode, "");
758 g_strValue = TextFieldModelNG::GetTextFieldText(frameNode);
759 return g_strValue.c_str();
760 }
761
GetTextInputCaretColor(ArkUINodeHandle node)762 ArkUI_Uint32 GetTextInputCaretColor(ArkUINodeHandle node)
763 {
764 auto *frameNode = reinterpret_cast<FrameNode *>(node);
765 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
766 return TextFieldModelNG::GetCaretColor(frameNode).GetValue();
767 }
768
GetTextInputCaretStyle(ArkUINodeHandle node,ArkUI_Int32 unit)769 ArkUI_Float32 GetTextInputCaretStyle(ArkUINodeHandle node, ArkUI_Int32 unit)
770 {
771 auto *frameNode = reinterpret_cast<FrameNode *>(node);
772 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
773 return TextFieldModelNG::GetCaretStyle(frameNode).GetNativeValue(static_cast<DimensionUnit>(unit));
774 }
775
GetTextInputShowUnderline(ArkUINodeHandle node)776 ArkUI_Bool GetTextInputShowUnderline(ArkUINodeHandle node)
777 {
778 auto *frameNode = reinterpret_cast<FrameNode *>(node);
779 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
780 return static_cast<ArkUI_Bool>(TextFieldModelNG::GetShowUnderline(frameNode));
781 }
782
GetTextInputMaxLength(ArkUINodeHandle node)783 ArkUI_Uint32 GetTextInputMaxLength(ArkUINodeHandle node)
784 {
785 auto *frameNode = reinterpret_cast<FrameNode *>(node);
786 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
787 return TextFieldModelNG::GetMaxLength(frameNode);
788 }
789
GetTextInputEnterKeyType(ArkUINodeHandle node)790 ArkUI_Int32 GetTextInputEnterKeyType(ArkUINodeHandle node)
791 {
792 auto *frameNode = reinterpret_cast<FrameNode *>(node);
793 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
794 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetEnterKeyType(frameNode));
795 }
796
GetTextInputPlaceholderColor(ArkUINodeHandle node)797 ArkUI_Uint32 GetTextInputPlaceholderColor(ArkUINodeHandle node)
798 {
799 auto *frameNode = reinterpret_cast<FrameNode *>(node);
800 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
801 return TextFieldModelNG::GetPlaceholderColor(frameNode).GetValue();
802 }
803
GetTextInputPlaceholderFont(ArkUINodeHandle node,ArkUITextFont * font)804 void GetTextInputPlaceholderFont(ArkUINodeHandle node, ArkUITextFont* font)
805 {
806 auto* frameNode = reinterpret_cast<FrameNode*>(node);
807 CHECK_NULL_VOID(frameNode);
808 Font value = TextFieldModelNG::GetPlaceholderFont(frameNode);
809 if (value.fontSize.has_value()) {
810 font->fontSize = value.fontSize.value().GetNativeValue(static_cast<DimensionUnit>(font->fontSizeUnit));
811 }
812 if (value.fontWeight.has_value()) {
813 font->fontWeight = static_cast<ArkUI_Int32>(value.fontWeight.value());
814 }
815 if (!value.fontFamilies.empty()) {
816 std::string families;
817 uint32_t index = 0;
818 for (auto& family : value.fontFamilies) {
819 families += family;
820 if (index != value.fontFamilies.size() - 1) {
821 families += ",";
822 }
823 index ++;
824 }
825 g_strValue = families;
826 font->fontFamilies = g_strValue.c_str();
827 }
828 if (value.fontStyle.has_value()) {
829 font->fontStyle = static_cast<ArkUI_Int32>(value.fontStyle.value());
830 }
831 }
832
GetTextInputRequestKeyboardOnFocus(ArkUINodeHandle node)833 ArkUI_Bool GetTextInputRequestKeyboardOnFocus(ArkUINodeHandle node)
834 {
835 auto *frameNode = reinterpret_cast<FrameNode *>(node);
836 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
837 return static_cast<ArkUI_Bool>(TextFieldModelNG::GetRequestKeyboardOnFocus(frameNode));
838 }
839
GetTextInputType(ArkUINodeHandle node)840 ArkUI_Int32 GetTextInputType(ArkUINodeHandle node)
841 {
842 auto *frameNode = reinterpret_cast<FrameNode *>(node);
843 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
844 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetType(frameNode));
845 }
846
GetTextInputSelectedBackgroundColor(ArkUINodeHandle node)847 ArkUI_Uint32 GetTextInputSelectedBackgroundColor(ArkUINodeHandle node)
848 {
849 auto *frameNode = reinterpret_cast<FrameNode *>(node);
850 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
851 return TextFieldModelNG::GetSelectedBackgroundColor(frameNode).GetValue();
852 }
853
GetTextInputShowPasswordIcon(ArkUINodeHandle node)854 ArkUI_Bool GetTextInputShowPasswordIcon(ArkUINodeHandle node)
855 {
856 auto *frameNode = reinterpret_cast<FrameNode *>(node);
857 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
858 return TextFieldModelNG::GetShowPasswordIcon(frameNode);
859 }
860
GetTextInputEditing(ArkUINodeHandle node)861 ArkUI_Bool GetTextInputEditing(ArkUINodeHandle node)
862 {
863 auto *frameNode = reinterpret_cast<FrameNode *>(node);
864 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
865 return TextFieldModelNG::GetTextFieldEditing(frameNode);
866 }
867
GetTextInputShowCancelButton(ArkUINodeHandle node)868 ArkUI_Bool GetTextInputShowCancelButton(ArkUINodeHandle node)
869 {
870 auto *frameNode = reinterpret_cast<FrameNode *>(node);
871 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
872 return TextFieldModelNG::GetShowCancelButton(frameNode);
873 }
874
GetTextInputCancelButtonStyle(ArkUINodeHandle node)875 ArkUI_Int32 GetTextInputCancelButtonStyle(ArkUINodeHandle node)
876 {
877 auto *frameNode = reinterpret_cast<FrameNode *>(node);
878 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
879 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetCleanNodeStyle(frameNode));
880 }
881
GetTextInputCancelIconSize(ArkUINodeHandle node,ArkUI_Int32 unit)882 ArkUI_Float32 GetTextInputCancelIconSize(ArkUINodeHandle node, ArkUI_Int32 unit)
883 {
884 auto *frameNode = reinterpret_cast<FrameNode *>(node);
885 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
886 return TextFieldModelNG::GetCancelIconSize(frameNode).GetNativeValue(static_cast<DimensionUnit>(unit));
887 }
888
getTextInputTextCancelIconSrc(ArkUINodeHandle node)889 ArkUI_CharPtr getTextInputTextCancelIconSrc(ArkUINodeHandle node)
890 {
891 auto *frameNode = reinterpret_cast<FrameNode *>(node);
892 CHECK_NULL_RETURN(frameNode, "");
893 g_strValue = TextFieldModelNG::GetCanacelIconSrc(frameNode);
894 return g_strValue.c_str();
895 }
896
getTextInputTextCancelIconColor(ArkUINodeHandle node)897 ArkUI_Uint32 getTextInputTextCancelIconColor(ArkUINodeHandle node)
898 {
899 auto *frameNode = reinterpret_cast<FrameNode *>(node);
900 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
901 return TextFieldModelNG::GetCancelIconColor(frameNode).GetValue();
902 }
903
GetTextInputTextAlign(ArkUINodeHandle node)904 ArkUI_Int32 GetTextInputTextAlign(ArkUINodeHandle node)
905 {
906 auto *frameNode = reinterpret_cast<FrameNode *>(node);
907 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
908 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetTextAlign(frameNode));
909 }
910
GetTextInputFontColor(ArkUINodeHandle node)911 ArkUI_Uint32 GetTextInputFontColor(ArkUINodeHandle node)
912 {
913 auto *frameNode = reinterpret_cast<FrameNode *>(node);
914 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
915 return TextFieldModelNG::GetTextColor(frameNode).GetValue();
916 }
917
GetTextInputFontStyle(ArkUINodeHandle node)918 ArkUI_Int32 GetTextInputFontStyle(ArkUINodeHandle node)
919 {
920 auto *frameNode = reinterpret_cast<FrameNode *>(node);
921 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
922 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetFontStyle(frameNode));
923 }
924
GetTextInputFontWeight(ArkUINodeHandle node)925 ArkUI_Int32 GetTextInputFontWeight(ArkUINodeHandle node)
926 {
927 auto *frameNode = reinterpret_cast<FrameNode *>(node);
928 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
929 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetFontWeight(frameNode));
930 }
931
GetTextInputFontSize(ArkUINodeHandle node,ArkUI_Int32 unit)932 ArkUI_Float32 GetTextInputFontSize(ArkUINodeHandle node, ArkUI_Int32 unit)
933 {
934 auto *frameNode = reinterpret_cast<FrameNode *>(node);
935 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
936 return TextFieldModelNG::GetFontSize(frameNode).GetNativeValue(static_cast<DimensionUnit>(unit));
937 }
938
SetTextInputBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)939 void SetTextInputBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
940 {
941 auto* frameNode = reinterpret_cast<FrameNode*>(node);
942 CHECK_NULL_VOID(frameNode);
943 TextFieldModelNG::SetBackgroundColor(frameNode, Color(color));
944 }
945
ResetTextInputBackgroundColor(ArkUINodeHandle node)946 void ResetTextInputBackgroundColor(ArkUINodeHandle node)
947 {
948 auto* frameNode = reinterpret_cast<FrameNode*>(node);
949 CHECK_NULL_VOID(frameNode);
950 Color backgroundColor;
951 auto pipeline = frameNode->GetContext();
952 CHECK_NULL_VOID(pipeline);
953 auto buttonTheme = pipeline->GetTheme<TextFieldTheme>();
954 CHECK_NULL_VOID(buttonTheme);
955 backgroundColor = buttonTheme->GetBgColor();
956 TextFieldModelNG::SetBackgroundColor(frameNode, backgroundColor);
957 }
958
SetTextInputTextSelection(ArkUINodeHandle node,ArkUI_Int32 start,ArkUI_Int32 end)959 void SetTextInputTextSelection(ArkUINodeHandle node, ArkUI_Int32 start, ArkUI_Int32 end)
960 {
961 auto* frameNode = reinterpret_cast<FrameNode*>(node);
962 CHECK_NULL_VOID(frameNode);
963 TextFieldModelNG::SetTextSelection(frameNode, start, end);
964 }
965
GetTextInputTextSelectionIndex(ArkUINodeHandle node,ArkUI_Bool isEnd)966 ArkUI_Int32 GetTextInputTextSelectionIndex(ArkUINodeHandle node, ArkUI_Bool isEnd)
967 {
968 auto* frameNode = reinterpret_cast<FrameNode*>(node);
969 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
970 return TextFieldModelNG::GetTextSelectionIndex(frameNode, isEnd);
971 }
972
SetTextInputPadding(ArkUINodeHandle node,const struct ArkUISizeType * top,const struct ArkUISizeType * right,const struct ArkUISizeType * bottom,const struct ArkUISizeType * left)973 void SetTextInputPadding(ArkUINodeHandle node, const struct ArkUISizeType* top, const struct ArkUISizeType* right,
974 const struct ArkUISizeType* bottom, const struct ArkUISizeType* left)
975 {
976 auto* frameNode = reinterpret_cast<FrameNode*>(node);
977 CHECK_NULL_VOID(frameNode);
978 CalcLength topDimen;
979 CalcLength rightDimen;
980 CalcLength bottomDimen;
981 CalcLength leftDimen;
982 if (top->string != nullptr) {
983 topDimen = CalcLength(top->string);
984 } else {
985 topDimen = CalcLength(top->value, static_cast<DimensionUnit>(top->unit));
986 }
987 if (right->string != nullptr) {
988 rightDimen = CalcLength(right->string);
989 } else {
990 rightDimen = CalcLength(right->value, static_cast<DimensionUnit>(right->unit));
991 }
992 if (bottom->string != nullptr) {
993 bottomDimen = CalcLength(bottom->string);
994 } else {
995 bottomDimen = CalcLength(bottom->value, static_cast<DimensionUnit>(bottom->unit));
996 }
997 if (left->string != nullptr) {
998 leftDimen = CalcLength(left->string);
999 } else {
1000 leftDimen = CalcLength(left->value, static_cast<DimensionUnit>(left->unit));
1001 }
1002 NG::PaddingProperty paddings;
1003 paddings.top = std::optional<CalcLength>(topDimen);
1004 paddings.bottom = std::optional<CalcLength>(bottomDimen);
1005 paddings.left = std::optional<CalcLength>(leftDimen);
1006 paddings.right = std::optional<CalcLength>(rightDimen);
1007 TextFieldModelNG::SetPadding(frameNode, paddings);
1008 }
1009
ResetTextInputPadding(ArkUINodeHandle node)1010 void ResetTextInputPadding(ArkUINodeHandle node)
1011 {
1012 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1013 TextFieldModelNG::ResetTextInputPadding(frameNode);
1014 }
1015
SetTextInputFontFeature(ArkUINodeHandle node,ArkUI_CharPtr value)1016 void SetTextInputFontFeature(ArkUINodeHandle node, ArkUI_CharPtr value)
1017 {
1018 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1019 CHECK_NULL_VOID(frameNode);
1020 std::string strValue = value;
1021 TextFieldModelNG::SetFontFeature(frameNode, ParseFontFeatureSettings(strValue));
1022 }
1023
ResetTextInputFontFeature(ArkUINodeHandle node)1024 void ResetTextInputFontFeature(ArkUINodeHandle node)
1025 {
1026 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1027 std::string strValue = "";
1028 TextFieldModelNG::SetFontFeature(frameNode, ParseFontFeatureSettings(strValue));
1029 }
1030
SetTextInputDecoration(ArkUINodeHandle node,ArkUI_Int32 decoration,ArkUI_Uint32 color,ArkUI_Int32 style)1031 void SetTextInputDecoration(ArkUINodeHandle node, ArkUI_Int32 decoration, ArkUI_Uint32 color, ArkUI_Int32 style)
1032 {
1033 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1034 CHECK_NULL_VOID(frameNode);
1035 TextFieldModelNG::SetTextDecoration(frameNode, static_cast<TextDecoration>(decoration));
1036 TextFieldModelNG::SetTextDecorationColor(frameNode, Color(color));
1037 TextFieldModelNG::SetTextDecorationStyle(frameNode, static_cast<TextDecorationStyle>(style));
1038 }
1039
ResetTextInputDecoration(ArkUINodeHandle node)1040 void ResetTextInputDecoration(ArkUINodeHandle node)
1041 {
1042 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1043 CHECK_NULL_VOID(frameNode);
1044 TextFieldModelNG::SetTextDecoration(frameNode, DEFAULT_TEXT_DECORATION);
1045 TextFieldModelNG::SetTextDecorationColor(frameNode, DEFAULT_DECORATION_COLOR);
1046 TextFieldModelNG::SetTextDecorationStyle(frameNode, DEFAULT_DECORATION_STYLE);
1047 }
1048
SetTextInputLetterSpacing(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1049 void SetTextInputLetterSpacing(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1050 {
1051 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1052 CHECK_NULL_VOID(frameNode);
1053 TextFieldModelNG::SetLetterSpacing(frameNode, CalcDimension(value, (DimensionUnit)unit));
1054 }
1055
ResetTextInputLetterSpacing(ArkUINodeHandle node)1056 void ResetTextInputLetterSpacing(ArkUINodeHandle node)
1057 {
1058 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1059 CHECK_NULL_VOID(frameNode);
1060 CalcDimension value;
1061 value.Reset();
1062 TextFieldModelNG::SetLetterSpacing(frameNode, value);
1063 }
1064
SetTextInputLineHeight(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1065 void SetTextInputLineHeight(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1066 {
1067 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1068 CHECK_NULL_VOID(frameNode);
1069 TextFieldModelNG::SetLineHeight(frameNode, CalcDimension(value, (DimensionUnit)unit));
1070 }
1071
ResetTextInputLineHeight(ArkUINodeHandle node)1072 void ResetTextInputLineHeight(ArkUINodeHandle node)
1073 {
1074 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1075 CHECK_NULL_VOID(frameNode);
1076 CalcDimension value;
1077 value.Reset();
1078 TextFieldModelNG::SetLineHeight(frameNode, value);
1079 }
1080
SetTextInputNormalUnderlineColor(ArkUINodeHandle node,ArkUI_Uint32 normalColor)1081 void SetTextInputNormalUnderlineColor(ArkUINodeHandle node, ArkUI_Uint32 normalColor)
1082 {
1083 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1084 CHECK_NULL_VOID(frameNode);
1085 TextFieldModelNG::SetNormalUnderlineColor(frameNode, Color(normalColor));
1086 }
1087
SetTextInputUserUnderlineColor(ArkUINodeHandle node,const ArkUI_Uint32 * values,const ArkUI_Bool * hasValues,ArkUI_Int32 length)1088 void SetTextInputUserUnderlineColor(ArkUINodeHandle node, const ArkUI_Uint32* values,
1089 const ArkUI_Bool* hasValues, ArkUI_Int32 length)
1090 {
1091 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1092 CHECK_NULL_VOID(frameNode);
1093 UserUnderlineColor userColor = UserUnderlineColor();
1094 if (length != DEFAULT_GROUP_UNDERLINE_COLOR_VALUES_COUNT) {
1095 return;
1096 }
1097 if (hasValues[CALL_ARG_0]) {
1098 userColor.typing = Color(values[CALL_ARG_0]);
1099 }
1100 if (hasValues[CALL_ARG_1]) {
1101 userColor.normal = Color(values[CALL_ARG_1]);
1102 }
1103 if (hasValues[CALL_ARG_2]) {
1104 userColor.error = Color(values[CALL_ARG_2]);
1105 }
1106 if (hasValues[CALL_ARG_3]) {
1107 userColor.disable = Color(values[CALL_ARG_3]);
1108 }
1109 TextFieldModelNG::SetUserUnderlineColor(frameNode, userColor);
1110 }
1111
GetTextInputUserUnderlineColor(ArkUINodeHandle node,ArkUI_Uint32 (* values)[4])1112 void GetTextInputUserUnderlineColor(ArkUINodeHandle node, ArkUI_Uint32 (*values)[4])
1113 {
1114 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1115 CHECK_NULL_VOID(frameNode);
1116 UserUnderlineColor userColor = TextFieldModelNG::GetUnderLineColor(frameNode);
1117 (*values)[CALL_ARG_0] = userColor.typing->GetValue();
1118 (*values)[CALL_ARG_1] = userColor.normal->GetValue();
1119 (*values)[CALL_ARG_2] = userColor.error->GetValue();
1120 (*values)[CALL_ARG_3] = userColor.disable->GetValue();
1121 }
1122
ResetTextInputUserUnderlineColor(ArkUINodeHandle node)1123 void ResetTextInputUserUnderlineColor(ArkUINodeHandle node)
1124 {
1125 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1126 CHECK_NULL_VOID(frameNode);
1127 UserUnderlineColor userColor = UserUnderlineColor();
1128 TextFieldModelNG::SetUserUnderlineColor(frameNode, userColor);
1129 }
1130
SetTextInputWordBreak(ArkUINodeHandle node,ArkUI_Uint32 wordBreak)1131 void SetTextInputWordBreak(ArkUINodeHandle node, ArkUI_Uint32 wordBreak)
1132 {
1133 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1134 CHECK_NULL_VOID(frameNode);
1135 if (wordBreak < 0 || wordBreak >= WORD_BREAK_TYPES.size()) {
1136 wordBreak = 2; // 2 is the default value of WordBreak::BREAK_WORD
1137 }
1138 TextFieldModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[wordBreak]);
1139 }
1140
GetTextInputWordBreak(ArkUINodeHandle node)1141 ArkUI_Int32 GetTextInputWordBreak(ArkUINodeHandle node)
1142 {
1143 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1144 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1145 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetWordBreak(frameNode));
1146 }
1147
ResetTextInputWordBreak(ArkUINodeHandle node)1148 void ResetTextInputWordBreak(ArkUINodeHandle node)
1149 {
1150 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1151 CHECK_NULL_VOID(frameNode);
1152 TextFieldModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[2]); // 2 is the default value of WordBreak::BREAK_WORD
1153 }
1154
SetTextInputPlaceholderFontEnum(ArkUINodeHandle node,const struct ArkUIResourceLength * size,ArkUI_Int32 weight,ArkUI_CharPtr family,ArkUI_Int32 style)1155 void SetTextInputPlaceholderFontEnum(ArkUINodeHandle node, const struct ArkUIResourceLength* size, ArkUI_Int32 weight,
1156 ArkUI_CharPtr family, ArkUI_Int32 style)
1157 {
1158 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1159 CHECK_NULL_VOID(frameNode);
1160 Font font;
1161 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(size->unit);
1162 if (size->unit >= 0) {
1163 if (unitEnum == DimensionUnit::CALC) {
1164 font.fontSize = CalcDimension(size->string, DimensionUnit::CALC);
1165 } else {
1166 font.fontSize = CalcDimension(size->value, unitEnum);
1167 }
1168 } else {
1169 auto pipeline = frameNode->GetContext();
1170 CHECK_NULL_VOID(pipeline);
1171 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
1172 CHECK_NULL_VOID(theme);
1173 font.fontSize = theme->GetFontSize();
1174 }
1175
1176 if (weight > -1) {
1177 font.fontWeight = static_cast<FontWeight>(weight);
1178 } else {
1179 font.fontWeight = DEFAULT_FONT_WEIGHT;
1180 }
1181
1182 if (family != nullptr) {
1183 font.fontFamilies = Framework::ConvertStrToFontFamilies(std::string(family));
1184 } else {
1185 std::vector<std::string> fontFamilies;
1186 fontFamilies.emplace_back(DEFAULT_FONT_FAMILY[0]);
1187 font.fontFamilies = fontFamilies;
1188 }
1189
1190 if (style >= 0) {
1191 font.fontStyle = static_cast<Ace::FontStyle>(style);
1192 } else {
1193 font.fontStyle = DEFAULT_FONT_STYLE;
1194 }
1195 TextFieldModelNG::SetPlaceholderFont(frameNode, font);
1196 }
1197
SetTextInputAdaptMinFontSize(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1198 void SetTextInputAdaptMinFontSize(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1199 {
1200 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1201 CHECK_NULL_VOID(frameNode);
1202 TextFieldModelNG::SetAdaptMinFontSize(frameNode, CalcDimension(value, (DimensionUnit)unit));
1203 }
1204
ResetTextInputAdaptMinFontSize(ArkUINodeHandle node)1205 void ResetTextInputAdaptMinFontSize(ArkUINodeHandle node)
1206 {
1207 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1208 CHECK_NULL_VOID(frameNode);
1209 auto pipelineContext = frameNode->GetContext();
1210 CHECK_NULL_VOID(pipelineContext);
1211 auto theme = pipelineContext->GetTheme<TextFieldTheme>();
1212 CHECK_NULL_VOID(theme);
1213 CalcDimension minFontSize = theme->GetTextStyle().GetAdaptMinFontSize();
1214 TextFieldModelNG::SetAdaptMinFontSize(frameNode, minFontSize);
1215 }
1216
SetTextInputAdaptMaxFontSize(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1217 void SetTextInputAdaptMaxFontSize(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1218 {
1219 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1220 CHECK_NULL_VOID(frameNode);
1221 TextFieldModelNG::SetAdaptMaxFontSize(frameNode, CalcDimension(value, (DimensionUnit)unit));
1222 }
1223
ResetTextInputAdaptMaxFontSize(ArkUINodeHandle node)1224 void ResetTextInputAdaptMaxFontSize(ArkUINodeHandle node)
1225 {
1226 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1227 CHECK_NULL_VOID(frameNode);
1228 auto pipelineContext = frameNode->GetContext();
1229 CHECK_NULL_VOID(pipelineContext);
1230 auto theme = pipelineContext->GetTheme<TextFieldTheme>();
1231 CHECK_NULL_VOID(theme);
1232 CalcDimension maxFontSize = theme->GetTextStyle().GetAdaptMaxFontSize();
1233 TextFieldModelNG::SetAdaptMaxFontSize(frameNode, maxFontSize);
1234 }
1235
SetTextInputHeightAdaptivePolicy(ArkUINodeHandle node,ArkUI_Int32 value)1236 void SetTextInputHeightAdaptivePolicy(ArkUINodeHandle node, ArkUI_Int32 value)
1237 {
1238 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1239 CHECK_NULL_VOID(frameNode);
1240 TextFieldModelNG::SetHeightAdaptivePolicy(frameNode, static_cast<Ace::TextHeightAdaptivePolicy>(value));
1241 }
1242
ResetTextInputHeightAdaptivePolicy(ArkUINodeHandle node)1243 void ResetTextInputHeightAdaptivePolicy(ArkUINodeHandle node)
1244 {
1245 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1246 CHECK_NULL_VOID(frameNode);
1247 TextFieldModelNG::SetHeightAdaptivePolicy(frameNode, TextHeightAdaptivePolicy::MAX_LINES_FIRST);
1248 }
1249
GetTextInputSelectionMenuHidden(ArkUINodeHandle node)1250 ArkUI_Bool GetTextInputSelectionMenuHidden(ArkUINodeHandle node)
1251 {
1252 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1253 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1254 return TextFieldModelNG::GetSelectionMenuHidden(frameNode);
1255 }
1256
SetTextInputTextOverflow(ArkUINodeHandle node,ArkUI_Int32 value)1257 void SetTextInputTextOverflow(ArkUINodeHandle node, ArkUI_Int32 value)
1258 {
1259 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1260 CHECK_NULL_VOID(frameNode);
1261 TextOverflow valueTextOverflow = static_cast<TextOverflow>(value);
1262 TextFieldModelNG::SetTextOverflow(frameNode, valueTextOverflow);
1263 }
1264
ResetTextInputTextOverflow(ArkUINodeHandle node)1265 void ResetTextInputTextOverflow(ArkUINodeHandle node)
1266 {
1267 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1268 CHECK_NULL_VOID(frameNode);
1269 TextFieldModelNG::SetTextOverflow(frameNode, TextOverflow::DEFAULT);
1270 }
1271
SetTextInputTextIndent(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)1272 void SetTextInputTextIndent(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
1273 {
1274 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1275 CHECK_NULL_VOID(frameNode);
1276 TextFieldModelNG::SetTextIndent(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
1277 }
1278
ResetTextInputTextIndent(ArkUINodeHandle node)1279 void ResetTextInputTextIndent(ArkUINodeHandle node)
1280 {
1281 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1282 CHECK_NULL_VOID(frameNode);
1283 TextFieldModelNG::SetTextIndent(frameNode, CalcDimension(0, DimensionUnit::VP));
1284 }
1285
GetTextInputFontFeature(ArkUINodeHandle node)1286 ArkUI_CharPtr GetTextInputFontFeature(ArkUINodeHandle node)
1287 {
1288 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1289 CHECK_NULL_RETURN(frameNode, nullptr);
1290 g_strValue = UnParseFontFeatureSetting(TextFieldModelNG::GetFontFeature(frameNode));
1291 return g_strValue.c_str();
1292 }
1293
GetTextInputController(ArkUINodeHandle node)1294 ArkUINodeHandle GetTextInputController(ArkUINodeHandle node)
1295 {
1296 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1297 CHECK_NULL_RETURN(frameNode, nullptr);
1298 auto controller = TextFieldModelNG::GetOrCreateController(frameNode);
1299 CHECK_NULL_RETURN(controller, nullptr);
1300 auto nodecontroller = reinterpret_cast<ArkUINodeHandle>(OHOS::Ace::AceType::RawPtr(controller));
1301 return nodecontroller;
1302 }
1303
GetTextInputAdaptMinFontSize(ArkUINodeHandle node)1304 ArkUI_Float32 GetTextInputAdaptMinFontSize(ArkUINodeHandle node)
1305 {
1306 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1307 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
1308 return TextFieldModelNG::GetAdaptMinFontSize(frameNode).Value();
1309 }
1310
GetTextInputAdaptMaxFontSize(ArkUINodeHandle node)1311 ArkUI_Float32 GetTextInputAdaptMaxFontSize(ArkUINodeHandle node)
1312 {
1313 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1314 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
1315 return TextFieldModelNG::GetAdaptMaxFontSize(frameNode).Value();
1316 }
1317
GetTextInputLineHeight(ArkUINodeHandle node)1318 ArkUI_Float32 GetTextInputLineHeight(ArkUINodeHandle node)
1319 {
1320 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1321 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
1322 return TextFieldModelNG::GetLineHeight(frameNode).Value();
1323 }
1324
GetTextInputMaxLines(ArkUINodeHandle node)1325 ArkUI_Int32 GetTextInputMaxLines(ArkUINodeHandle node)
1326 {
1327 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1328 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
1329 return TextFieldModelNG::GetMaxLines(frameNode);
1330 }
1331
SetTextInputSelectAll(ArkUINodeHandle node,ArkUI_Uint32 enableSelectAll)1332 void SetTextInputSelectAll(ArkUINodeHandle node, ArkUI_Uint32 enableSelectAll)
1333 {
1334 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1335 CHECK_NULL_VOID(frameNode);
1336 TextFieldModelNG::SetSelectAllValue(frameNode, static_cast<bool>(enableSelectAll));
1337 }
1338
ResetTextInputSelectAll(ArkUINodeHandle node)1339 void ResetTextInputSelectAll(ArkUINodeHandle node)
1340 {
1341 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1342 CHECK_NULL_VOID(frameNode);
1343 TextFieldModelNG::SetSelectAllValue(frameNode, DEFAULT_SELECT_ALL);
1344 }
1345
SetTextInputShowCounter(ArkUINodeHandle node,ArkUI_Uint32 open,ArkUI_Int32 thresholdPercentage,ArkUI_Uint32 highlightBorder)1346 void SetTextInputShowCounter(
1347 ArkUINodeHandle node, ArkUI_Uint32 open, ArkUI_Int32 thresholdPercentage, ArkUI_Uint32 highlightBorder)
1348 {
1349 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1350 CHECK_NULL_VOID(frameNode);
1351 TextFieldModelNG::SetShowCounter(frameNode, static_cast<bool>(open));
1352 TextFieldModelNG::SetCounterType(frameNode, thresholdPercentage);
1353 TextFieldModelNG::SetShowCounterBorder(frameNode, static_cast<bool>(highlightBorder));
1354 }
1355
ResetTextInputShowCounter(ArkUINodeHandle node)1356 void ResetTextInputShowCounter(ArkUINodeHandle node)
1357 {
1358 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1359 CHECK_NULL_VOID(frameNode);
1360 TextFieldModelNG::SetShowCounter(frameNode, false);
1361 TextFieldModelNG::SetCounterType(frameNode, -1);
1362 TextFieldModelNG::SetShowCounterBorder(frameNode, true);
1363 }
1364
SetTextInputOnEditChange(ArkUINodeHandle node,void * callback)1365 void SetTextInputOnEditChange(ArkUINodeHandle node, void* callback)
1366 {
1367 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1368 CHECK_NULL_VOID(frameNode);
1369 if (callback) {
1370 auto onEditChange = reinterpret_cast<std::function<void(bool)>*>(callback);
1371 TextFieldModelNG::SetOnEditChange(frameNode, std::move(*onEditChange));
1372 } else {
1373 TextFieldModelNG::SetOnEditChange(frameNode, nullptr);
1374 }
1375 }
1376
ResetTextInputOnEditChange(ArkUINodeHandle node)1377 void ResetTextInputOnEditChange(ArkUINodeHandle node)
1378 {
1379 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1380 CHECK_NULL_VOID(frameNode);
1381 TextFieldModelNG::SetOnEditChange(frameNode, nullptr);
1382 }
1383
SetTextInputFilter(ArkUINodeHandle node,ArkUI_CharPtr value,void * callback)1384 void SetTextInputFilter(ArkUINodeHandle node, ArkUI_CharPtr value, void* callback)
1385 {
1386 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1387 CHECK_NULL_VOID(frameNode);
1388 std::string inputFilter(value);
1389 if (callback) {
1390 auto onError = reinterpret_cast<std::function<void(const std::string&)>*>(callback);
1391 TextFieldModelNG::SetInputFilter(frameNode, inputFilter, *onError);
1392 } else {
1393 TextFieldModelNG::SetInputFilter(frameNode, inputFilter, nullptr);
1394 }
1395 }
1396
ResetTextInputFilter(ArkUINodeHandle node)1397 void ResetTextInputFilter(ArkUINodeHandle node)
1398 {
1399 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1400 CHECK_NULL_VOID(frameNode);
1401 TextFieldModelNG::SetInputFilter(frameNode, "", nullptr);
1402 }
1403
SetTextInputOnSubmitWithEvent(ArkUINodeHandle node,void * callback)1404 void SetTextInputOnSubmitWithEvent(ArkUINodeHandle node, void* callback)
1405 {
1406 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1407 CHECK_NULL_VOID(frameNode);
1408 if (callback) {
1409 auto onSubmit = reinterpret_cast<std::function<void(int32_t, NG::TextFieldCommonEvent&)>*>(callback);
1410 TextFieldModelNG::SetOnSubmit(frameNode, std::move(*onSubmit));
1411 } else {
1412 TextFieldModelNG::SetOnSubmit(frameNode, nullptr);
1413 }
1414 }
1415
ResetTextInputOnSubmitWithEvent(ArkUINodeHandle node)1416 void ResetTextInputOnSubmitWithEvent(ArkUINodeHandle node)
1417 {
1418 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1419 CHECK_NULL_VOID(frameNode);
1420 TextFieldModelNG::SetOnSubmit(frameNode, nullptr);
1421 }
1422
SetTextInputOnChange(ArkUINodeHandle node,void * callback)1423 void SetTextInputOnChange(ArkUINodeHandle node, void* callback)
1424 {
1425 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1426 CHECK_NULL_VOID(frameNode);
1427 if (callback) {
1428 auto onChange = reinterpret_cast<std::function<void(const std::string&, PreviewText&)>*>(callback);
1429 TextFieldModelNG::SetOnChange(frameNode, std::move(*onChange));
1430 } else {
1431 TextFieldModelNG::SetOnChange(frameNode, nullptr);
1432 }
1433 }
1434
ResetTextInputOnChange(ArkUINodeHandle node)1435 void ResetTextInputOnChange(ArkUINodeHandle node)
1436 {
1437 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1438 CHECK_NULL_VOID(frameNode);
1439 TextFieldModelNG::SetOnChange(frameNode, nullptr);
1440 }
1441
SetTextInputOnTextSelectionChange(ArkUINodeHandle node,void * callback)1442 void SetTextInputOnTextSelectionChange(ArkUINodeHandle node, void* callback)
1443 {
1444 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1445 CHECK_NULL_VOID(frameNode);
1446 if (callback) {
1447 auto onChange = reinterpret_cast<std::function<void(int32_t, int32_t)>*>(callback);
1448 TextFieldModelNG::SetOnTextSelectionChange(frameNode, std::move(*onChange));
1449 } else {
1450 TextFieldModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1451 }
1452 }
1453
ResetTextInputOnTextSelectionChange(ArkUINodeHandle node)1454 void ResetTextInputOnTextSelectionChange(ArkUINodeHandle node)
1455 {
1456 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1457 CHECK_NULL_VOID(frameNode);
1458 TextFieldModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1459 }
1460
SetTextInputOnContentScroll(ArkUINodeHandle node,void * callback)1461 void SetTextInputOnContentScroll(ArkUINodeHandle node, void* callback)
1462 {
1463 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1464 CHECK_NULL_VOID(frameNode);
1465 if (callback) {
1466 auto onScroll = reinterpret_cast<std::function<void(float, float)>*>(callback);
1467 TextFieldModelNG::SetOnContentScroll(frameNode, std::move(*onScroll));
1468 } else {
1469 TextFieldModelNG::SetOnContentScroll(frameNode, nullptr);
1470 }
1471 }
1472
ResetTextInputOnContentScroll(ArkUINodeHandle node)1473 void ResetTextInputOnContentScroll(ArkUINodeHandle node)
1474 {
1475 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1476 CHECK_NULL_VOID(frameNode);
1477 TextFieldModelNG::SetOnContentScroll(frameNode, nullptr);
1478 }
1479
SetTextInputOnCopy(ArkUINodeHandle node,void * callback)1480 void SetTextInputOnCopy(ArkUINodeHandle node, void* callback)
1481 {
1482 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1483 CHECK_NULL_VOID(frameNode);
1484 if (callback) {
1485 auto onCopy = reinterpret_cast<std::function<void(const std::string&)>*>(callback);
1486 TextFieldModelNG::SetOnCopy(frameNode, std::move(*onCopy));
1487 } else {
1488 TextFieldModelNG::SetOnCopy(frameNode, nullptr);
1489 }
1490 }
1491
ResetTextInputOnCopy(ArkUINodeHandle node)1492 void ResetTextInputOnCopy(ArkUINodeHandle node)
1493 {
1494 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1495 CHECK_NULL_VOID(frameNode);
1496 TextFieldModelNG::SetOnCopy(frameNode, nullptr);
1497 }
1498
SetTextInputOnCut(ArkUINodeHandle node,void * callback)1499 void SetTextInputOnCut(ArkUINodeHandle node, void* callback)
1500 {
1501 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1502 CHECK_NULL_VOID(frameNode);
1503 if (callback) {
1504 auto onCut = reinterpret_cast<std::function<void(const std::string&)>*>(callback);
1505 TextFieldModelNG::SetOnCut(frameNode, std::move(*onCut));
1506 } else {
1507 TextFieldModelNG::SetOnCut(frameNode, nullptr);
1508 }
1509 }
1510
ResetTextInputOnCut(ArkUINodeHandle node)1511 void ResetTextInputOnCut(ArkUINodeHandle node)
1512 {
1513 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1514 CHECK_NULL_VOID(frameNode);
1515 TextFieldModelNG::SetOnCut(frameNode, nullptr);
1516 }
1517
SetTextInputOnPaste(ArkUINodeHandle node,void * callback)1518 void SetTextInputOnPaste(ArkUINodeHandle node, void* callback)
1519 {
1520 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1521 CHECK_NULL_VOID(frameNode);
1522 if (callback) {
1523 auto onPasteWithEvent = reinterpret_cast<std::function<void(
1524 const std::string&, NG::TextCommonEvent&)>*>(callback);
1525 TextFieldModelNG::SetOnPasteWithEvent(frameNode, std::move(*onPasteWithEvent));
1526 } else {
1527 TextFieldModelNG::SetOnPasteWithEvent(frameNode, nullptr);
1528 }
1529 }
1530
ResetTextInputOnPaste(ArkUINodeHandle node)1531 void ResetTextInputOnPaste(ArkUINodeHandle node)
1532 {
1533 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1534 CHECK_NULL_VOID(frameNode);
1535 TextFieldModelNG::SetOnPasteWithEvent(frameNode, nullptr);
1536 }
1537
SetBlurOnSubmit(ArkUINodeHandle node,ArkUI_Bool blurOnSubmit)1538 void SetBlurOnSubmit(ArkUINodeHandle node, ArkUI_Bool blurOnSubmit)
1539 {
1540 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1541 CHECK_NULL_VOID(frameNode);
1542 TextFieldModelNG::SetBlurOnSubmit(frameNode, blurOnSubmit);
1543 }
1544
GetBlurOnSubmit(ArkUINodeHandle node)1545 ArkUI_Bool GetBlurOnSubmit(ArkUINodeHandle node)
1546 {
1547 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1548 CHECK_NULL_RETURN(frameNode, true);
1549 return TextFieldModelNG::GetBlurOnSubmit(frameNode);
1550 }
1551
SetTextInputCustomKeyboard(ArkUINodeHandle node,ArkUINodeHandle customKeyboard,bool supportAvoidance)1552 void SetTextInputCustomKeyboard(ArkUINodeHandle node, ArkUINodeHandle customKeyboard, bool supportAvoidance)
1553 {
1554 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1555 CHECK_NULL_VOID(frameNode);
1556 auto *customKeyboardNode = reinterpret_cast<FrameNode*>(customKeyboard);
1557 CHECK_NULL_VOID(customKeyboardNode);
1558 TextFieldModelNG::SetCustomKeyboard(frameNode, customKeyboardNode, supportAvoidance);
1559 }
1560
GetTextInputCustomKeyboard(ArkUINodeHandle node)1561 ArkUINodeHandle GetTextInputCustomKeyboard(ArkUINodeHandle node)
1562 {
1563 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1564 CHECK_NULL_RETURN(frameNode, nullptr);
1565 auto customKeyboard = TextFieldModelNG::GetCustomKeyboard(frameNode);
1566 CHECK_NULL_RETURN(customKeyboard, nullptr);
1567 return reinterpret_cast<ArkUINodeHandle>(OHOS::Ace::AceType::RawPtr(customKeyboard));
1568 }
1569
GetTextInputCustomKeyboardOption(ArkUINodeHandle node)1570 ArkUI_Int32 GetTextInputCustomKeyboardOption(ArkUINodeHandle node)
1571 {
1572 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1573 CHECK_NULL_RETURN(frameNode, 0);
1574 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetCustomKeyboardOption(frameNode));
1575 }
1576
ResetTextInputCustomKeyboard(ArkUINodeHandle node)1577 void ResetTextInputCustomKeyboard(ArkUINodeHandle node)
1578 {
1579 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1580 CHECK_NULL_VOID(frameNode);
1581 TextFieldModelNG::SetCustomKeyboard(frameNode, nullptr, false);
1582 }
1583
1584
SetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node,ArkUI_Bool value)1585 void SetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node, ArkUI_Bool value)
1586 {
1587 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1588 CHECK_NULL_VOID(frameNode);
1589 TextFieldModelNG::SetShowKeyBoardOnFocus(frameNode, value);
1590 }
1591
GetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node)1592 ArkUI_Bool GetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node)
1593 {
1594 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1595 CHECK_NULL_RETURN(frameNode, true);
1596 return static_cast<ArkUI_Bool>(TextFieldModelNG::GetShowKeyBoardOnFocus(frameNode));
1597 }
1598
ResetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node)1599 void ResetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node)
1600 {
1601 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1602 CHECK_NULL_VOID(frameNode);
1603 TextFieldModelNG::SetShowKeyBoardOnFocus(frameNode, true);
1604 }
1605
SetTextInputNumberOfLines(ArkUINodeHandle node,ArkUI_Int32 value)1606 void SetTextInputNumberOfLines(ArkUINodeHandle node, ArkUI_Int32 value)
1607 {
1608 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1609 CHECK_NULL_VOID(frameNode);
1610 TextFieldModelNG::SetNumberOfLines(frameNode, value);
1611 }
1612
GetTextInputNumberOfLines(ArkUINodeHandle node)1613 ArkUI_Int32 GetTextInputNumberOfLines(ArkUINodeHandle node)
1614 {
1615 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1616 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1617 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetNumberOfLines(frameNode));
1618 }
1619
ResetTextInputNumberOfLines(ArkUINodeHandle node)1620 void ResetTextInputNumberOfLines(ArkUINodeHandle node)
1621 {
1622 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1623 CHECK_NULL_VOID(frameNode);
1624 TextFieldModelNG::ResetNumberOfLines(frameNode);
1625 }
1626
SetTextInputShowPassword(ArkUINodeHandle node,ArkUI_Uint32 value)1627 void SetTextInputShowPassword(ArkUINodeHandle node, ArkUI_Uint32 value)
1628 {
1629 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1630 CHECK_NULL_VOID(frameNode);
1631 TextFieldModelNG::SetShowPassword(frameNode, static_cast<bool>(value));
1632 }
1633
ResetTextInputShowPassword(ArkUINodeHandle node)1634 void ResetTextInputShowPassword(ArkUINodeHandle node)
1635 {
1636 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1637 CHECK_NULL_VOID(frameNode);
1638 TextFieldModelNG::SetShowPassword(frameNode, false);
1639 }
1640
GetTextInputShowPassword(ArkUINodeHandle node)1641 ArkUI_Bool GetTextInputShowPassword(ArkUINodeHandle node)
1642 {
1643 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1644 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1645 return TextFieldModelNG::GetShowPassword(frameNode);
1646 }
1647
SetTextInputLineBreakStrategy(ArkUINodeHandle node,ArkUI_Uint32 lineBreakStrategy)1648 void SetTextInputLineBreakStrategy(ArkUINodeHandle node, ArkUI_Uint32 lineBreakStrategy)
1649 {
1650 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1651 CHECK_NULL_VOID(frameNode);
1652 if (lineBreakStrategy < 0 || lineBreakStrategy >= LINE_BREAK_STRATEGY_TYPES.size()) {
1653 lineBreakStrategy = 0; // 0 is the default value of lineBreakStrategy::GREEDY
1654 }
1655 TextFieldModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[lineBreakStrategy]);
1656 }
1657
ResetTextInputLineBreakStrategy(ArkUINodeHandle node)1658 void ResetTextInputLineBreakStrategy(ArkUINodeHandle node)
1659 {
1660 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1661 CHECK_NULL_VOID(frameNode);
1662 // 0 is the default value of lineBreakStrategy::GREEDY
1663 TextFieldModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[0]);
1664 }
1665
SetTextInputMargin(ArkUINodeHandle node,const struct ArkUISizeType * top,const struct ArkUISizeType * right,const struct ArkUISizeType * bottom,const struct ArkUISizeType * left)1666 void SetTextInputMargin(ArkUINodeHandle node, const struct ArkUISizeType* top, const struct ArkUISizeType* right,
1667 const struct ArkUISizeType* bottom, const struct ArkUISizeType* left)
1668 {
1669 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1670 CHECK_NULL_VOID(frameNode);
1671 CalcLength topDimen;
1672 CalcLength rightDimen;
1673 CalcLength bottomDimen;
1674 CalcLength leftDimen;
1675 if (top->string != nullptr) {
1676 topDimen = CalcLength(top->string);
1677 } else {
1678 topDimen = CalcLength(top->value, static_cast<DimensionUnit>(top->unit));
1679 }
1680 if (right->string != nullptr) {
1681 rightDimen = CalcLength(right->string);
1682 } else {
1683 rightDimen = CalcLength(right->value, static_cast<DimensionUnit>(right->unit));
1684 }
1685 if (bottom->string != nullptr) {
1686 bottomDimen = CalcLength(bottom->string);
1687 } else {
1688 bottomDimen = CalcLength(bottom->value, static_cast<DimensionUnit>(bottom->unit));
1689 }
1690 if (left->string != nullptr) {
1691 leftDimen = CalcLength(left->string);
1692 } else {
1693 leftDimen = CalcLength(left->value, static_cast<DimensionUnit>(left->unit));
1694 }
1695 NG::PaddingProperty paddings;
1696 paddings.top = std::optional<CalcLength>(topDimen);
1697 paddings.bottom = std::optional<CalcLength>(bottomDimen);
1698 paddings.left = std::optional<CalcLength>(leftDimen);
1699 paddings.right = std::optional<CalcLength>(rightDimen);
1700 TextFieldModelNG::SetMargin(frameNode, paddings);
1701 }
1702
ResetTextInputMargin(ArkUINodeHandle node)1703 void ResetTextInputMargin(ArkUINodeHandle node)
1704 {
1705 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1706 CHECK_NULL_VOID(frameNode);
1707 NG::PaddingProperty paddings;
1708 paddings.top = NG::CalcLength(0.0);
1709 paddings.bottom = NG::CalcLength(0.0);
1710 paddings.left = NG::CalcLength(0.0);
1711 paddings.right = NG::CalcLength(0.0);
1712 TextFieldModelNG::SetMargin(frameNode, paddings);
1713 }
1714
GetTextInputMargin(ArkUINodeHandle node,ArkUI_Float32 (* values)[4],ArkUI_Int32 length,ArkUI_Int32 unit)1715 void GetTextInputMargin(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 margin = TextFieldModelNG::GetMargin(frameNode);
1720 (*values)[CALL_ARG_0] = margin.top->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1721 (*values)[CALL_ARG_1] = margin.right->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1722 (*values)[CALL_ARG_2] = margin.bottom->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1723 (*values)[CALL_ARG_3] = margin.left->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1724 length = DEFAULT_MARGIN_VALUES_COUNT;
1725 }
1726
SetTextInputCaret(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1727 void SetTextInputCaret(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1728 {
1729 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1730 CHECK_NULL_VOID(frameNode);
1731 CaretStyle caretStyle;
1732 caretStyle.caretWidth = CalcDimension(value, (DimensionUnit)unit);
1733 TextFieldModelNG::SetCaretStyle(frameNode, caretStyle);
1734 }
1735
SetTextInputEnablePreviewText(ArkUINodeHandle node,ArkUI_Uint32 value)1736 void SetTextInputEnablePreviewText(ArkUINodeHandle node, ArkUI_Uint32 value)
1737 {
1738 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1739 CHECK_NULL_VOID(frameNode);
1740 TextFieldModelNG::SetEnablePreviewText(frameNode, static_cast<bool>(value));
1741 }
1742
ResetTextInputEnablePreviewText(ArkUINodeHandle node)1743 void ResetTextInputEnablePreviewText(ArkUINodeHandle node)
1744 {
1745 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1746 CHECK_NULL_VOID(frameNode);
1747 TextFieldModelNG::SetEnablePreviewText(frameNode, DEFAULT_ENABLE_PREVIEW_TEXT_VALUE);
1748 }
1749
SetTextInputSelectionMenuOptions(ArkUINodeHandle node,void * onCreateMenuCallback,void * onMenuItemClickCallback)1750 void SetTextInputSelectionMenuOptions(ArkUINodeHandle node, void* onCreateMenuCallback, void* onMenuItemClickCallback)
1751 {
1752 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1753 CHECK_NULL_VOID(frameNode);
1754 NG::OnCreateMenuCallback* onCreateMenu = nullptr;
1755 NG::OnMenuItemClickCallback* onMenuItemClick = nullptr;
1756 if (onCreateMenuCallback) {
1757 onCreateMenu = reinterpret_cast<NG::OnCreateMenuCallback*>(onCreateMenuCallback);
1758 }
1759 if (onMenuItemClickCallback) {
1760 onMenuItemClick = reinterpret_cast<NG::OnMenuItemClickCallback*>(onMenuItemClickCallback);
1761 }
1762 if (onCreateMenu != nullptr && onMenuItemClick != nullptr) {
1763 TextFieldModelNG::SetSelectionMenuOptions(frameNode, std::move(*onCreateMenu), std::move(*onMenuItemClick));
1764 } else if (onCreateMenu != nullptr && onMenuItemClick == nullptr) {
1765 TextFieldModelNG::SetSelectionMenuOptions(frameNode, std::move(*onCreateMenu), nullptr);
1766 } else if (onCreateMenu == nullptr && onMenuItemClick != nullptr) {
1767 TextFieldModelNG::SetSelectionMenuOptions(frameNode, nullptr, std::move(*onMenuItemClick));
1768 } else {
1769 TextFieldModelNG::SetSelectionMenuOptions(frameNode, nullptr, nullptr);
1770 }
1771 }
1772
ResetTextInputSelectionMenuOptions(ArkUINodeHandle node)1773 void ResetTextInputSelectionMenuOptions(ArkUINodeHandle node)
1774 {
1775 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1776 CHECK_NULL_VOID(frameNode);
1777 NG::OnCreateMenuCallback onCreateMenuCallback;
1778 NG::OnMenuItemClickCallback onMenuItemClick;
1779 TextFieldModelNG::SetSelectionMenuOptions(frameNode, std::move(onCreateMenuCallback), std::move(onMenuItemClick));
1780 }
1781
SetTextInputWidth(ArkUINodeHandle node,ArkUI_CharPtr value)1782 void SetTextInputWidth(ArkUINodeHandle node, ArkUI_CharPtr value)
1783 {
1784 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1785 CHECK_NULL_VOID(frameNode);
1786 auto widthValue = std::string(value);
1787 TextFieldModelNG::SetWidth(frameNode, widthValue);
1788 }
1789
ResetTextInputWidth(ArkUINodeHandle node)1790 void ResetTextInputWidth(ArkUINodeHandle node)
1791 {
1792 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1793 CHECK_NULL_VOID(frameNode);
1794 TextFieldModelNG::ClearWidth(frameNode);
1795 }
1796
SetTextInputEnableHapticFeedback(ArkUINodeHandle node,ArkUI_Uint32 value)1797 void SetTextInputEnableHapticFeedback(ArkUINodeHandle node, ArkUI_Uint32 value)
1798 {
1799 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1800 CHECK_NULL_VOID(frameNode);
1801 TextFieldModelNG::SetEnableHapticFeedback(frameNode, static_cast<bool>(value));
1802 }
1803
ResetTextInputEnableHapticFeedback(ArkUINodeHandle node)1804 void ResetTextInputEnableHapticFeedback(ArkUINodeHandle node)
1805 {
1806 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1807 CHECK_NULL_VOID(frameNode);
1808 TextFieldModelNG::SetEnableHapticFeedback(frameNode, DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE);
1809 }
1810 } // namespace
1811
1812 namespace NodeModifier {
GetTextInputModifier()1813 const ArkUITextInputModifier* GetTextInputModifier()
1814 {
1815 static const ArkUITextInputModifier modifier = { SetTextInputCaretColor, ResetTextInputCaretColor, SetTextInputType,
1816 ResetTextInputType, SetTextInputMaxLines, ResetTextInputMaxLines, SetTextInputPlaceholderColor,
1817 ResetTextInputPlaceholderColor, SetTextInputCaretPosition, ResetTextInputCaretPosition, SetTextInputCopyOption,
1818 ResetTextInputCopyOption, SetTextInputShowPasswordIcon, ResetTextInputShowPasswordIcon,
1819 SetTextInputPasswordIcon, ResetTextInputPasswordIcon, SetTextInputTextAlign, ResetTextInputTextAlign,
1820 SetTextInputStyle, ResetTextInputStyle, SetTextInputSelectionMenuHidden, ResetTextInputSelectionMenuHidden,
1821 SetTextInputShowUnderline, ResetTextInputShowUnderline, SetTextInputCaretStyle, ResetTextInputCaretStyle,
1822 SetTextInputEnableKeyboardOnFocus, ResetTextInputEnableKeyboardOnFocus, SetTextInputBarState,
1823 ResetTextInputBarState, SetTextInputEnterKeyType, ResetTextInputEnterKeyType, SetTextInputFontWeight,
1824 ResetTextInputFontWeight, SetTextInputFontSize, ResetTextInputFontSize, SetTextInputMaxLength,
1825 ResetTextInputMaxLength, SetTextInputSelectedBackgroundColor, ResetTextInputSelectedBackgroundColor,
1826 SetTextInputShowError, ResetTextInputShowError, SetTextInputPlaceholderFont, ResetTextInputPlaceholderFont,
1827 SetTextInputFontColor, ResetTextInputFontColor, SetTextInputFontStyle, ResetTextInputFontStyle,
1828 SetTextInputFontFamily, ResetTextInputFontFamily, SetTextInputPlaceholderString, SetTextInputTextString,
1829 SetTextInputFontWeightStr, StopTextInputTextEditing, SetTextInputCancelButton, resetTextInputCancelButton,
1830 GetTextInputPlaceholder, GetTextInputText, GetTextInputCaretColor, GetTextInputCaretStyle,
1831 GetTextInputShowUnderline, GetTextInputMaxLength, GetTextInputEnterKeyType, GetTextInputPlaceholderColor,
1832 GetTextInputPlaceholderFont, GetTextInputRequestKeyboardOnFocus, GetTextInputType,
1833 GetTextInputSelectedBackgroundColor, GetTextInputShowPasswordIcon, GetTextInputEditing,
1834 GetTextInputShowCancelButton, GetTextInputCancelIconSize, getTextInputTextCancelIconSrc,
1835 getTextInputTextCancelIconColor, GetTextInputTextAlign, GetTextInputFontColor, GetTextInputFontStyle,
1836 GetTextInputFontWeight, GetTextInputFontSize, GetTextInputCancelButtonStyle, SetTextInputBackgroundColor,
1837 ResetTextInputBackgroundColor, SetTextInputTextSelection, GetTextInputTextSelectionIndex,
1838 SetTextInputPasswordRules, ResetTextInputPasswordRules, SetTextInputEnableAutoFill,
1839 ResetTextInputEnableAutoFill, SetTextInputPadding, ResetTextInputPadding,
1840 SetTextInputFontFeature, ResetTextInputFontFeature,
1841 SetTextInputDecoration, ResetTextInputDecoration, SetTextInputLetterSpacing, ResetTextInputLetterSpacing,
1842 SetTextInputLineHeight, ResetTextInputLineHeight,
1843 SetTextInputNormalUnderlineColor, SetTextInputUserUnderlineColor, ResetTextInputUserUnderlineColor,
1844 SetTextInputWordBreak, ResetTextInputWordBreak, SetTextInputPlaceholderFontEnum,
1845 SetTextInputAdaptMinFontSize, ResetTextInputAdaptMinFontSize, SetTextInputAdaptMaxFontSize,
1846 ResetTextInputAdaptMaxFontSize, SetTextInputHeightAdaptivePolicy, ResetTextInputHeightAdaptivePolicy,
1847 SetTextInputTextOverflow, ResetTextInputTextOverflow, SetTextInputTextIndent, ResetTextInputTextIndent,
1848 GetTextInputSelectionMenuHidden, GetTextInputWordBreak, GetTextInputEnableAutoFill,
1849 SetTextInputContentType, ResetTextInputContentType, GetTextInputContentType,
1850 GetTextInputUserUnderlineColor, GetTextInputPasswordRules, GetTextInputSelectAll,
1851 SetTextInputInputFilter, GetTextInputInputFilter, ResetTextInputInputFilter, GetTextInputCaretIndex,
1852 GetTextInputCaretOffset, GetTextInputStyle, GetTextInputContentRect, GetTextInputContentLinesNum,
1853 SetBlurOnSubmit, GetBlurOnSubmit, GetTextInputAdaptMinFontSize, GetTextInputAdaptMaxFontSize,
1854 GetTextInputLineHeight, GetTextInputMaxLines, GetTextInputFontFeature,
1855 SetTextInputCustomKeyboard, GetTextInputCustomKeyboard, GetTextInputCustomKeyboardOption,
1856 ResetTextInputCustomKeyboard, SetTextInputSelectAll, ResetTextInputSelectAll, SetTextInputShowCounter,
1857 ResetTextInputShowCounter, SetTextInputOnEditChange, ResetTextInputOnEditChange, SetTextInputFilter,
1858 ResetTextInputFilter, SetTextInputOnSubmitWithEvent, ResetTextInputOnSubmitWithEvent, SetTextInputOnChange,
1859 ResetTextInputOnChange, SetTextInputOnTextSelectionChange, ResetTextInputOnTextSelectionChange,
1860 SetTextInputOnContentScroll, ResetTextInputOnContentScroll, SetTextInputOnCopy, ResetTextInputOnCopy,
1861 SetTextInputOnCut, ResetTextInputOnCut, SetTextInputOnPaste, ResetTextInputOnPaste,
1862 SetTextInputShowKeyBoardOnFocus, GetTextInputShowKeyBoardOnFocus, ResetTextInputShowKeyBoardOnFocus,
1863 SetTextInputNumberOfLines, GetTextInputNumberOfLines, ResetTextInputNumberOfLines,
1864 SetTextInputShowPassword, ResetTextInputShowPassword, GetTextInputShowPassword, SetTextInputLineBreakStrategy,
1865 ResetTextInputLineBreakStrategy, SetTextInputMargin, ResetTextInputMargin,
1866 GetTextInputMargin, SetTextInputCaret, GetTextInputController,
1867 SetTextInputEnablePreviewText, ResetTextInputEnablePreviewText,
1868 SetTextInputSelectionMenuOptions, ResetTextInputSelectionMenuOptions,
1869 SetTextInputWidth, ResetTextInputWidth, SetTextInputEnableHapticFeedback, ResetTextInputEnableHapticFeedback };
1870 return &modifier;
1871 }
1872
GetCJUITextInputModifier()1873 const CJUITextInputModifier* GetCJUITextInputModifier()
1874 {
1875 static const CJUITextInputModifier modifier = { SetTextInputCaretColor, ResetTextInputCaretColor, SetTextInputType,
1876 ResetTextInputType, SetTextInputMaxLines, ResetTextInputMaxLines, SetTextInputPlaceholderColor,
1877 ResetTextInputPlaceholderColor, SetTextInputCaretPosition, ResetTextInputCaretPosition, SetTextInputCopyOption,
1878 ResetTextInputCopyOption, SetTextInputShowPasswordIcon, ResetTextInputShowPasswordIcon,
1879 SetTextInputPasswordIcon, ResetTextInputPasswordIcon, SetTextInputTextAlign, ResetTextInputTextAlign,
1880 SetTextInputStyle, ResetTextInputStyle, SetTextInputSelectionMenuHidden, ResetTextInputSelectionMenuHidden,
1881 SetTextInputShowUnderline, ResetTextInputShowUnderline, SetTextInputCaretStyle, ResetTextInputCaretStyle,
1882 SetTextInputEnableKeyboardOnFocus, ResetTextInputEnableKeyboardOnFocus, SetTextInputBarState,
1883 ResetTextInputBarState, SetTextInputEnterKeyType, ResetTextInputEnterKeyType, SetTextInputFontWeight,
1884 ResetTextInputFontWeight, SetTextInputFontSize, ResetTextInputFontSize, SetTextInputMaxLength,
1885 ResetTextInputMaxLength, SetTextInputSelectedBackgroundColor, ResetTextInputSelectedBackgroundColor,
1886 SetTextInputShowError, ResetTextInputShowError, SetTextInputPlaceholderFont, ResetTextInputPlaceholderFont,
1887 SetTextInputFontColor, ResetTextInputFontColor, SetTextInputFontStyle, ResetTextInputFontStyle,
1888 SetTextInputFontFamily, ResetTextInputFontFamily, SetTextInputPlaceholderString, SetTextInputTextString,
1889 SetTextInputFontWeightStr, StopTextInputTextEditing, SetTextInputCancelButton, resetTextInputCancelButton,
1890 GetTextInputPlaceholder, GetTextInputText, GetTextInputCaretColor, GetTextInputCaretStyle,
1891 GetTextInputShowUnderline, GetTextInputMaxLength, GetTextInputEnterKeyType, GetTextInputPlaceholderColor,
1892 GetTextInputPlaceholderFont, GetTextInputRequestKeyboardOnFocus, GetTextInputType,
1893 GetTextInputSelectedBackgroundColor, GetTextInputShowPasswordIcon, GetTextInputEditing,
1894 GetTextInputShowCancelButton, GetTextInputCancelIconSize, getTextInputTextCancelIconSrc,
1895 getTextInputTextCancelIconColor, GetTextInputTextAlign, GetTextInputFontColor, GetTextInputFontStyle,
1896 GetTextInputFontWeight, GetTextInputFontSize, GetTextInputCancelButtonStyle, SetTextInputBackgroundColor,
1897 ResetTextInputBackgroundColor, SetTextInputTextSelection, GetTextInputTextSelectionIndex,
1898 SetTextInputPasswordRules, ResetTextInputPasswordRules, SetTextInputEnableAutoFill,
1899 ResetTextInputEnableAutoFill, SetTextInputPadding, ResetTextInputPadding,
1900 SetTextInputFontFeature, ResetTextInputFontFeature,
1901 SetTextInputDecoration, ResetTextInputDecoration, SetTextInputLetterSpacing, ResetTextInputLetterSpacing,
1902 SetTextInputLineHeight, ResetTextInputLineHeight,
1903 SetTextInputNormalUnderlineColor, SetTextInputUserUnderlineColor, ResetTextInputUserUnderlineColor,
1904 SetTextInputWordBreak, ResetTextInputWordBreak, SetTextInputPlaceholderFontEnum,
1905 SetTextInputAdaptMinFontSize, ResetTextInputAdaptMinFontSize, SetTextInputAdaptMaxFontSize,
1906 ResetTextInputAdaptMaxFontSize, SetTextInputHeightAdaptivePolicy, ResetTextInputHeightAdaptivePolicy,
1907 SetTextInputTextOverflow, ResetTextInputTextOverflow, SetTextInputTextIndent, ResetTextInputTextIndent,
1908 GetTextInputSelectionMenuHidden, GetTextInputWordBreak, GetTextInputEnableAutoFill,
1909 SetTextInputContentType, ResetTextInputContentType, GetTextInputContentType,
1910 GetTextInputUserUnderlineColor, GetTextInputPasswordRules, GetTextInputSelectAll,
1911 SetTextInputInputFilter, GetTextInputInputFilter, ResetTextInputInputFilter, GetTextInputCaretIndex,
1912 GetTextInputCaretOffset, GetTextInputStyle, GetTextInputContentRect, GetTextInputContentLinesNum,
1913 SetBlurOnSubmit, GetBlurOnSubmit, GetTextInputAdaptMinFontSize, GetTextInputAdaptMaxFontSize,
1914 GetTextInputLineHeight, GetTextInputMaxLines, GetTextInputFontFeature,
1915 SetTextInputCustomKeyboard, GetTextInputCustomKeyboard, GetTextInputCustomKeyboardOption,
1916 ResetTextInputCustomKeyboard, SetTextInputSelectAll, ResetTextInputSelectAll, SetTextInputShowCounter,
1917 ResetTextInputShowCounter, SetTextInputOnEditChange, ResetTextInputOnEditChange, SetTextInputFilter,
1918 ResetTextInputFilter, SetTextInputOnSubmitWithEvent, ResetTextInputOnSubmitWithEvent, SetTextInputOnChange,
1919 ResetTextInputOnChange, SetTextInputOnTextSelectionChange, ResetTextInputOnTextSelectionChange,
1920 SetTextInputOnContentScroll, ResetTextInputOnContentScroll, SetTextInputOnCopy, ResetTextInputOnCopy,
1921 SetTextInputOnCut, ResetTextInputOnCut, SetTextInputOnPaste, ResetTextInputOnPaste,
1922 SetTextInputShowKeyBoardOnFocus, GetTextInputShowKeyBoardOnFocus, ResetTextInputShowKeyBoardOnFocus,
1923 SetTextInputNumberOfLines, GetTextInputNumberOfLines, ResetTextInputNumberOfLines,
1924 SetTextInputShowPassword, ResetTextInputShowPassword, GetTextInputShowPassword, SetTextInputLineBreakStrategy,
1925 ResetTextInputLineBreakStrategy, SetTextInputMargin, ResetTextInputMargin,
1926 GetTextInputMargin, SetTextInputCaret, GetTextInputController,
1927 SetTextInputEnablePreviewText, ResetTextInputEnablePreviewText };
1928
1929 return &modifier;
1930 }
1931
SetOnTextInputChange(ArkUINodeHandle node,void * extraParam)1932 void SetOnTextInputChange(ArkUINodeHandle node, void* extraParam)
1933 {
1934 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1935 CHECK_NULL_VOID(frameNode);
1936 auto onChange = [node, extraParam](const std::string& str, PreviewText&) {
1937 ArkUINodeEvent event;
1938 event.kind = TEXT_INPUT;
1939 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1940 event.textInputEvent.subKind = ON_TEXT_INPUT_CHANGE;
1941 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
1942 SendArkUIAsyncEvent(&event);
1943 };
1944 TextFieldModelNG::SetOnChange(frameNode, std::move(onChange));
1945 }
1946
SetTextInputOnSubmit(ArkUINodeHandle node,void * extraParam)1947 void SetTextInputOnSubmit(ArkUINodeHandle node, void* extraParam)
1948 {
1949 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1950 CHECK_NULL_VOID(frameNode);
1951 auto onEvent = [node, extraParam](int32_t value, NG::TextFieldCommonEvent& commonEvent) {
1952 ArkUINodeEvent event;
1953 event.kind = COMPONENT_ASYNC_EVENT;
1954 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1955 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_SUBMIT;
1956 event.componentAsyncEvent.data[0].i32 = value;
1957 SendArkUIAsyncEvent(&event);
1958 };
1959 TextFieldModelNG::SetOnSubmit(frameNode, std::move(onEvent));
1960 }
1961
SetOnTextInputCut(ArkUINodeHandle node,void * extraParam)1962 void SetOnTextInputCut(ArkUINodeHandle node, void* extraParam)
1963 {
1964 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1965 CHECK_NULL_VOID(frameNode);
1966 auto onCut = [node, extraParam](const std::string& str) {
1967 ArkUINodeEvent event;
1968 event.kind = TEXT_INPUT;
1969 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1970 event.textInputEvent.subKind = ON_TEXT_INPUT_CUT;
1971 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
1972 SendArkUIAsyncEvent(&event);
1973 };
1974 TextFieldModelNG::SetOnCut(frameNode, std::move(onCut));
1975 }
1976
SetOnTextInputPaste(ArkUINodeHandle node,void * extraParam)1977 void SetOnTextInputPaste(ArkUINodeHandle node, void* extraParam)
1978 {
1979 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1980 CHECK_NULL_VOID(frameNode);
1981 auto onPaste = [node, extraParam](const std::string& str, NG::TextCommonEvent& commonEvent) {
1982 ArkUINodeEvent event;
1983 event.kind = TEXT_INPUT;
1984 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1985 event.textInputEvent.subKind = ON_TEXT_INPUT_PASTE;
1986 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
1987 SendArkUIAsyncEvent(&event);
1988 };
1989 TextFieldModelNG::SetOnPasteWithEvent(frameNode, std::move(onPaste));
1990 }
1991
SetOnTextInputSelectionChange(ArkUINodeHandle node,void * extraParam)1992 void SetOnTextInputSelectionChange(ArkUINodeHandle node, void* extraParam)
1993 {
1994 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1995 CHECK_NULL_VOID(frameNode);
1996 auto onSelectionChange = [node, extraParam](int32_t start, int32_t end) {
1997 ArkUINodeEvent event;
1998 event.kind = COMPONENT_ASYNC_EVENT;
1999 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2000 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_TEXT_SELECTION_CHANGE;
2001 event.componentAsyncEvent.data[0].i32 = static_cast<int>(start);
2002 event.componentAsyncEvent.data[1].i32 = static_cast<int>(end);
2003 SendArkUIAsyncEvent(&event);
2004 };
2005 TextFieldModelNG::SetOnTextSelectionChange(frameNode, std::move(onSelectionChange));
2006 }
2007
SetOnTextInputEditChange(ArkUINodeHandle node,void * extraParam)2008 void SetOnTextInputEditChange(ArkUINodeHandle node, void* extraParam)
2009 {
2010 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2011 CHECK_NULL_VOID(frameNode);
2012 auto onChange = [node, extraParam](bool isEditing) {
2013 ArkUINodeEvent event;
2014 event.kind = COMPONENT_ASYNC_EVENT;
2015 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2016 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_EDIT_CHANGE;
2017 event.componentAsyncEvent.data[0].i32 = static_cast<int>(isEditing);
2018 SendArkUIAsyncEvent(&event);
2019 };
2020 TextFieldModelNG::SetOnEditChanged(frameNode, std::move(onChange));
2021 }
2022
SetOnTextInputContentSizeChange(ArkUINodeHandle node,void * extraParam)2023 void SetOnTextInputContentSizeChange(ArkUINodeHandle node, void* extraParam)
2024 {
2025 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2026 CHECK_NULL_VOID(frameNode);
2027 auto onChange = [node, extraParam](float width, float height) {
2028 ArkUINodeEvent event;
2029 event.kind = COMPONENT_ASYNC_EVENT;
2030 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2031 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_CONTENT_SIZE_CHANGE;
2032 bool usePx = NodeModel::UsePXUnit(reinterpret_cast<ArkUI_Node*>(extraParam));
2033 double density = usePx ? 1 : PipelineBase::GetCurrentDensity();
2034 //0 width
2035 event.componentAsyncEvent.data[0].f32 = NearEqual(density, 0.0) ? 0.0f : width / density;
2036 //1 height
2037 event.componentAsyncEvent.data[1].f32 = NearEqual(density, 0.0) ? 0.0f : height / density;
2038 SendArkUIAsyncEvent(&event);
2039 };
2040 TextFieldModelNG::SetOnContentSizeChange(frameNode, std::move(onChange));
2041 }
2042
SetOnTextInputInputFilterError(ArkUINodeHandle node,void * extraParam)2043 void SetOnTextInputInputFilterError(ArkUINodeHandle node, void* extraParam)
2044 {
2045 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2046 CHECK_NULL_VOID(frameNode);
2047 auto onInputFilterError = [node, extraParam](const std::string& str) {
2048 ArkUINodeEvent event;
2049 event.kind = TEXT_INPUT;
2050 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2051 event.textInputEvent.subKind = ON_TEXT_INPUT_INPUT_FILTER_ERROR;
2052 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
2053 SendArkUIAsyncEvent(&event);
2054 };
2055 TextFieldModelNG::SetInputFilterError(frameNode, std::move(onInputFilterError));
2056 }
2057
SetTextInputOnTextContentScroll(ArkUINodeHandle node,void * extraParam)2058 void SetTextInputOnTextContentScroll(ArkUINodeHandle node, void* extraParam)
2059 {
2060 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2061 CHECK_NULL_VOID(frameNode);
2062 auto onScroll = [node, extraParam](float totalOffsetX, float totalOffsetY) {
2063 ArkUINodeEvent event;
2064 event.kind = COMPONENT_ASYNC_EVENT;
2065 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2066 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_CONTENT_SCROLL;
2067 event.componentAsyncEvent.data[0].f32 = totalOffsetX;
2068 event.componentAsyncEvent.data[1].f32 = totalOffsetY;
2069 SendArkUIAsyncEvent(&event);
2070 };
2071 TextFieldModelNG::SetOnContentScroll(frameNode, std::move(onScroll));
2072 }
2073
ResetOnTextInputChange(ArkUINodeHandle node)2074 void ResetOnTextInputChange(ArkUINodeHandle node)
2075 {
2076 GetTextInputModifier()->resetTextInputOnChange(node);
2077 }
ResetTextInputOnSubmit(ArkUINodeHandle node)2078 void ResetTextInputOnSubmit(ArkUINodeHandle node)
2079 {
2080 GetTextInputModifier()->resetTextInputOnSubmitWithEvent(node);
2081 }
ResetOnTextInputCut(ArkUINodeHandle node)2082 void ResetOnTextInputCut(ArkUINodeHandle node)
2083 {
2084 GetTextInputModifier()->resetTextInputOnCut(node);
2085 }
ResetOnTextInputPaste(ArkUINodeHandle node)2086 void ResetOnTextInputPaste(ArkUINodeHandle node)
2087 {
2088 GetTextInputModifier()->resetTextInputOnPaste(node);
2089 }
ResetOnTextInputSelectionChange(ArkUINodeHandle node)2090 void ResetOnTextInputSelectionChange(ArkUINodeHandle node)
2091 {
2092 GetTextInputModifier()->resetTextInputOnTextSelectionChange(node);
2093 }
ResetOnTextInputEditChange(ArkUINodeHandle node)2094 void ResetOnTextInputEditChange(ArkUINodeHandle node)
2095 {
2096 GetTextInputModifier()->resetTextInputOnEditChange(node);
2097 }
ResetOnTextInputContentSizeChange(ArkUINodeHandle node)2098 void ResetOnTextInputContentSizeChange(ArkUINodeHandle node)
2099 {
2100 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2101 CHECK_NULL_VOID(frameNode);
2102 TextFieldModelNG::SetOnContentSizeChange(frameNode, nullptr);
2103 }
ResetOnTextInputInputFilterError(ArkUINodeHandle node)2104 void ResetOnTextInputInputFilterError(ArkUINodeHandle node)
2105 {
2106 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2107 CHECK_NULL_VOID(frameNode);
2108 TextFieldModelNG::SetInputFilterError(frameNode, nullptr);
2109 }
ResetTextInputOnTextContentScroll(ArkUINodeHandle node)2110 void ResetTextInputOnTextContentScroll(ArkUINodeHandle node)
2111 {
2112 GetTextInputModifier()->resetTextInputOnContentScroll(node);
2113 }
2114
SetTextInputOnWillInsert(ArkUINodeHandle node,void * extraParam)2115 void SetTextInputOnWillInsert(ArkUINodeHandle node, void* extraParam)
2116 {
2117 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2118 CHECK_NULL_VOID(frameNode);
2119 auto onWillInsert = [node, extraParam](const InsertValueInfo& Info) -> bool {
2120 ArkUINodeEvent event;
2121 event.kind = MIXED_EVENT;
2122 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2123 event.mixedEvent.subKind = ON_TEXT_INPUT_WILL_INSERT;
2124 event.mixedEvent.numberData[0].f32 = Info.insertOffset;
2125 event.mixedEvent.numberDataLength = 1;
2126 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(Info.insertValue.c_str());
2127 event.mixedEvent.stringPtrDataLength = 1;
2128 SendArkUIAsyncEvent(&event);
2129 return event.mixedEvent.numberReturnData[0].i32;
2130 };
2131 TextFieldModelNG::SetOnWillInsertValueEvent(frameNode, std::move(onWillInsert));
2132 }
2133
SetTextInputOnDidInsert(ArkUINodeHandle node,void * extraParam)2134 void SetTextInputOnDidInsert(ArkUINodeHandle node, void* extraParam)
2135 {
2136 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2137 CHECK_NULL_VOID(frameNode);
2138 auto onDidInsert = [node, extraParam](const InsertValueInfo& Info) {
2139 ArkUINodeEvent event;
2140 event.kind = MIXED_EVENT;
2141 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2142 event.mixedEvent.subKind = ON_TEXT_INPUT_DID_INSERT;
2143 event.mixedEvent.numberData[0].f32 = Info.insertOffset;
2144 event.mixedEvent.numberDataLength = 1;
2145 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(Info.insertValue.c_str());
2146 event.mixedEvent.stringPtrDataLength = 1;
2147 SendArkUIAsyncEvent(&event);
2148 };
2149 TextFieldModelNG::SetOnDidInsertValueEvent(frameNode, std::move(onDidInsert));
2150 }
2151
SetTextInputOnWillDelete(ArkUINodeHandle node,void * extraParam)2152 void SetTextInputOnWillDelete(ArkUINodeHandle node, void* extraParam)
2153 {
2154 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2155 CHECK_NULL_VOID(frameNode);
2156 auto onWillDelete = [node, extraParam](const DeleteValueInfo& Info) -> bool {
2157 ArkUINodeEvent event;
2158 event.kind = MIXED_EVENT;
2159 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2160 event.mixedEvent.subKind = ON_TEXT_INPUT_WILL_DELETE;
2161 event.mixedEvent.numberData[0].f32 = Info.deleteOffset;
2162 event.mixedEvent.numberData[1].i32 = static_cast<int32_t>(Info.direction);
2163 event.mixedEvent.numberDataLength = 2;
2164 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(Info.deleteValue.c_str());
2165 event.mixedEvent.stringPtrDataLength = 1;
2166 SendArkUIAsyncEvent(&event);
2167 return event.mixedEvent.numberReturnData[0].i32;
2168 };
2169 TextFieldModelNG::SetOnWillDeleteEvent(frameNode, std::move(onWillDelete));
2170 }
2171
SetTextInputOnDidDelete(ArkUINodeHandle node,void * extraParam)2172 void SetTextInputOnDidDelete(ArkUINodeHandle node, void* extraParam)
2173 {
2174 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2175 CHECK_NULL_VOID(frameNode);
2176 auto onDidDelete = [node, extraParam](const DeleteValueInfo& Info) {
2177 ArkUINodeEvent event;
2178 event.kind = MIXED_EVENT;
2179 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2180 event.mixedEvent.subKind = ON_TEXT_INPUT_DID_DELETE;
2181 event.mixedEvent.numberData[0].f32 = Info.deleteOffset;
2182 event.mixedEvent.numberData[1].i32 = static_cast<int32_t>(Info.direction);
2183 event.mixedEvent.numberDataLength = 2;
2184 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(Info.deleteValue.c_str());
2185 event.mixedEvent.stringPtrDataLength = 1;
2186 SendArkUIAsyncEvent(&event);
2187 };
2188 TextFieldModelNG::SetOnDidDeleteEvent(frameNode, std::move(onDidDelete));
2189 }
2190 } // namespace NodeModifier
2191 } // namespace OHOS::Ace::NG
2192