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
GetTextInputLetterSpacing(ArkUINodeHandle node)1065 ArkUI_Float32 GetTextInputLetterSpacing(ArkUINodeHandle node)
1066 {
1067 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1068 CHECK_NULL_RETURN(frameNode, 0.0f);
1069 return TextFieldModelNG::GetLetterSpacing(frameNode).ConvertToFp();
1070 }
1071
SetTextInputLineHeight(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1072 void SetTextInputLineHeight(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1073 {
1074 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1075 CHECK_NULL_VOID(frameNode);
1076 TextFieldModelNG::SetLineHeight(frameNode, CalcDimension(value, (DimensionUnit)unit));
1077 }
1078
ResetTextInputLineHeight(ArkUINodeHandle node)1079 void ResetTextInputLineHeight(ArkUINodeHandle node)
1080 {
1081 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1082 CHECK_NULL_VOID(frameNode);
1083 CalcDimension value;
1084 value.Reset();
1085 TextFieldModelNG::SetLineHeight(frameNode, value);
1086 }
1087
SetTextInputKeyboardAppearance(ArkUINodeHandle node,ArkUI_Uint32 keyboardAppearance)1088 void SetTextInputKeyboardAppearance(ArkUINodeHandle node, ArkUI_Uint32 keyboardAppearance)
1089 {
1090 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1091 CHECK_NULL_VOID(frameNode);
1092 auto value = static_cast<KeyboardAppearance>(keyboardAppearance);
1093 TextFieldModelNG::SetKeyboardAppearance(frameNode, value);
1094 }
1095
GetTextInputKeyboardAppearance(ArkUINodeHandle node)1096 ArkUI_Int32 GetTextInputKeyboardAppearance(ArkUINodeHandle node)
1097 {
1098 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1099 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1100 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetKeyboardAppearance(frameNode));
1101 }
1102
ResetTextInputKeyboardAppearance(ArkUINodeHandle node)1103 void ResetTextInputKeyboardAppearance(ArkUINodeHandle node)
1104 {
1105 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1106 CHECK_NULL_VOID(frameNode);
1107 auto value = KeyboardAppearance::NONE_IMMERSIVE;
1108 TextFieldModelNG::SetKeyboardAppearance(frameNode, value);
1109 }
1110
SetTextInputNormalUnderlineColor(ArkUINodeHandle node,ArkUI_Uint32 normalColor)1111 void SetTextInputNormalUnderlineColor(ArkUINodeHandle node, ArkUI_Uint32 normalColor)
1112 {
1113 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1114 CHECK_NULL_VOID(frameNode);
1115 TextFieldModelNG::SetNormalUnderlineColor(frameNode, Color(normalColor));
1116 }
1117
SetTextInputUserUnderlineColor(ArkUINodeHandle node,const ArkUI_Uint32 * values,const ArkUI_Bool * hasValues,ArkUI_Int32 length)1118 void SetTextInputUserUnderlineColor(ArkUINodeHandle node, const ArkUI_Uint32* values,
1119 const ArkUI_Bool* hasValues, ArkUI_Int32 length)
1120 {
1121 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1122 CHECK_NULL_VOID(frameNode);
1123 UserUnderlineColor userColor = UserUnderlineColor();
1124 if (length != DEFAULT_GROUP_UNDERLINE_COLOR_VALUES_COUNT) {
1125 return;
1126 }
1127 if (hasValues[CALL_ARG_0]) {
1128 userColor.typing = Color(values[CALL_ARG_0]);
1129 }
1130 if (hasValues[CALL_ARG_1]) {
1131 userColor.normal = Color(values[CALL_ARG_1]);
1132 }
1133 if (hasValues[CALL_ARG_2]) {
1134 userColor.error = Color(values[CALL_ARG_2]);
1135 }
1136 if (hasValues[CALL_ARG_3]) {
1137 userColor.disable = Color(values[CALL_ARG_3]);
1138 }
1139 TextFieldModelNG::SetUserUnderlineColor(frameNode, userColor);
1140 }
1141
GetTextInputUserUnderlineColor(ArkUINodeHandle node,ArkUI_Uint32 (* values)[4])1142 void GetTextInputUserUnderlineColor(ArkUINodeHandle node, ArkUI_Uint32 (*values)[4])
1143 {
1144 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1145 CHECK_NULL_VOID(frameNode);
1146 UserUnderlineColor userColor = TextFieldModelNG::GetUnderLineColor(frameNode);
1147 (*values)[CALL_ARG_0] = userColor.typing->GetValue();
1148 (*values)[CALL_ARG_1] = userColor.normal->GetValue();
1149 (*values)[CALL_ARG_2] = userColor.error->GetValue();
1150 (*values)[CALL_ARG_3] = userColor.disable->GetValue();
1151 }
1152
ResetTextInputUserUnderlineColor(ArkUINodeHandle node)1153 void ResetTextInputUserUnderlineColor(ArkUINodeHandle node)
1154 {
1155 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1156 CHECK_NULL_VOID(frameNode);
1157 UserUnderlineColor userColor = UserUnderlineColor();
1158 TextFieldModelNG::SetUserUnderlineColor(frameNode, userColor);
1159 }
1160
SetTextInputWordBreak(ArkUINodeHandle node,ArkUI_Uint32 wordBreak)1161 void SetTextInputWordBreak(ArkUINodeHandle node, ArkUI_Uint32 wordBreak)
1162 {
1163 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1164 CHECK_NULL_VOID(frameNode);
1165 if (wordBreak < 0 || wordBreak >= WORD_BREAK_TYPES.size()) {
1166 wordBreak = 2; // 2 is the default value of WordBreak::BREAK_WORD
1167 }
1168 TextFieldModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[wordBreak]);
1169 }
1170
GetTextInputWordBreak(ArkUINodeHandle node)1171 ArkUI_Int32 GetTextInputWordBreak(ArkUINodeHandle node)
1172 {
1173 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1174 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1175 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetWordBreak(frameNode));
1176 }
1177
ResetTextInputWordBreak(ArkUINodeHandle node)1178 void ResetTextInputWordBreak(ArkUINodeHandle node)
1179 {
1180 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1181 CHECK_NULL_VOID(frameNode);
1182 TextFieldModelNG::SetWordBreak(frameNode, WORD_BREAK_TYPES[2]); // 2 is the default value of WordBreak::BREAK_WORD
1183 }
1184
SetTextInputPlaceholderFontEnum(ArkUINodeHandle node,const struct ArkUIResourceLength * size,ArkUI_Int32 weight,ArkUI_CharPtr family,ArkUI_Int32 style)1185 void SetTextInputPlaceholderFontEnum(ArkUINodeHandle node, const struct ArkUIResourceLength* size, ArkUI_Int32 weight,
1186 ArkUI_CharPtr family, ArkUI_Int32 style)
1187 {
1188 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1189 CHECK_NULL_VOID(frameNode);
1190 Font font;
1191 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(size->unit);
1192 if (size->unit >= 0) {
1193 if (unitEnum == DimensionUnit::CALC) {
1194 font.fontSize = CalcDimension(size->string, DimensionUnit::CALC);
1195 } else {
1196 font.fontSize = CalcDimension(size->value, unitEnum);
1197 }
1198 } else {
1199 auto pipeline = frameNode->GetContext();
1200 CHECK_NULL_VOID(pipeline);
1201 auto theme = pipeline->GetThemeManager()->GetTheme<TextFieldTheme>();
1202 CHECK_NULL_VOID(theme);
1203 font.fontSize = theme->GetFontSize();
1204 }
1205
1206 if (weight > -1) {
1207 font.fontWeight = static_cast<FontWeight>(weight);
1208 } else {
1209 font.fontWeight = DEFAULT_FONT_WEIGHT;
1210 }
1211
1212 if (family != nullptr) {
1213 font.fontFamilies = Framework::ConvertStrToFontFamilies(std::string(family));
1214 } else {
1215 std::vector<std::string> fontFamilies;
1216 fontFamilies.emplace_back(DEFAULT_FONT_FAMILY[0]);
1217 font.fontFamilies = fontFamilies;
1218 }
1219
1220 if (style >= 0) {
1221 font.fontStyle = static_cast<Ace::FontStyle>(style);
1222 } else {
1223 font.fontStyle = DEFAULT_FONT_STYLE;
1224 }
1225 TextFieldModelNG::SetPlaceholderFont(frameNode, font);
1226 }
1227
SetTextInputAdaptMinFontSize(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1228 void SetTextInputAdaptMinFontSize(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1229 {
1230 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1231 CHECK_NULL_VOID(frameNode);
1232 TextFieldModelNG::SetAdaptMinFontSize(frameNode, CalcDimension(value, (DimensionUnit)unit));
1233 }
1234
ResetTextInputAdaptMinFontSize(ArkUINodeHandle node)1235 void ResetTextInputAdaptMinFontSize(ArkUINodeHandle node)
1236 {
1237 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1238 CHECK_NULL_VOID(frameNode);
1239 auto pipelineContext = frameNode->GetContext();
1240 CHECK_NULL_VOID(pipelineContext);
1241 auto theme = pipelineContext->GetTheme<TextFieldTheme>();
1242 CHECK_NULL_VOID(theme);
1243 CalcDimension minFontSize = theme->GetTextStyle().GetAdaptMinFontSize();
1244 TextFieldModelNG::SetAdaptMinFontSize(frameNode, minFontSize);
1245 }
1246
SetTextInputAdaptMaxFontSize(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1247 void SetTextInputAdaptMaxFontSize(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1248 {
1249 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1250 CHECK_NULL_VOID(frameNode);
1251 TextFieldModelNG::SetAdaptMaxFontSize(frameNode, CalcDimension(value, (DimensionUnit)unit));
1252 }
1253
ResetTextInputAdaptMaxFontSize(ArkUINodeHandle node)1254 void ResetTextInputAdaptMaxFontSize(ArkUINodeHandle node)
1255 {
1256 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1257 CHECK_NULL_VOID(frameNode);
1258 auto pipelineContext = frameNode->GetContext();
1259 CHECK_NULL_VOID(pipelineContext);
1260 auto theme = pipelineContext->GetTheme<TextFieldTheme>();
1261 CHECK_NULL_VOID(theme);
1262 CalcDimension maxFontSize = theme->GetTextStyle().GetAdaptMaxFontSize();
1263 TextFieldModelNG::SetAdaptMaxFontSize(frameNode, maxFontSize);
1264 }
1265
SetTextInputHeightAdaptivePolicy(ArkUINodeHandle node,ArkUI_Int32 value)1266 void SetTextInputHeightAdaptivePolicy(ArkUINodeHandle node, ArkUI_Int32 value)
1267 {
1268 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1269 CHECK_NULL_VOID(frameNode);
1270 TextFieldModelNG::SetHeightAdaptivePolicy(frameNode, static_cast<Ace::TextHeightAdaptivePolicy>(value));
1271 }
1272
ResetTextInputHeightAdaptivePolicy(ArkUINodeHandle node)1273 void ResetTextInputHeightAdaptivePolicy(ArkUINodeHandle node)
1274 {
1275 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1276 CHECK_NULL_VOID(frameNode);
1277 TextFieldModelNG::SetHeightAdaptivePolicy(frameNode, TextHeightAdaptivePolicy::MAX_LINES_FIRST);
1278 }
1279
GetTextInputSelectionMenuHidden(ArkUINodeHandle node)1280 ArkUI_Bool GetTextInputSelectionMenuHidden(ArkUINodeHandle node)
1281 {
1282 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1283 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1284 return TextFieldModelNG::GetSelectionMenuHidden(frameNode);
1285 }
1286
SetTextInputTextOverflow(ArkUINodeHandle node,ArkUI_Int32 value)1287 void SetTextInputTextOverflow(ArkUINodeHandle node, ArkUI_Int32 value)
1288 {
1289 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1290 CHECK_NULL_VOID(frameNode);
1291 TextOverflow valueTextOverflow = static_cast<TextOverflow>(value);
1292 TextFieldModelNG::SetTextOverflow(frameNode, valueTextOverflow);
1293 }
1294
ResetTextInputTextOverflow(ArkUINodeHandle node)1295 void ResetTextInputTextOverflow(ArkUINodeHandle node)
1296 {
1297 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1298 CHECK_NULL_VOID(frameNode);
1299 TextFieldModelNG::SetTextOverflow(frameNode, TextOverflow::DEFAULT);
1300 }
1301
SetTextInputTextIndent(ArkUINodeHandle node,ArkUI_Float32 number,ArkUI_Int32 unit)1302 void SetTextInputTextIndent(ArkUINodeHandle node, ArkUI_Float32 number, ArkUI_Int32 unit)
1303 {
1304 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1305 CHECK_NULL_VOID(frameNode);
1306 TextFieldModelNG::SetTextIndent(frameNode, Dimension(number, static_cast<DimensionUnit>(unit)));
1307 }
1308
ResetTextInputTextIndent(ArkUINodeHandle node)1309 void ResetTextInputTextIndent(ArkUINodeHandle node)
1310 {
1311 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1312 CHECK_NULL_VOID(frameNode);
1313 TextFieldModelNG::SetTextIndent(frameNode, CalcDimension(0, DimensionUnit::VP));
1314 }
1315
GetTextInputFontFeature(ArkUINodeHandle node)1316 ArkUI_CharPtr GetTextInputFontFeature(ArkUINodeHandle node)
1317 {
1318 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1319 CHECK_NULL_RETURN(frameNode, nullptr);
1320 g_strValue = UnParseFontFeatureSetting(TextFieldModelNG::GetFontFeature(frameNode));
1321 return g_strValue.c_str();
1322 }
1323
GetTextInputController(ArkUINodeHandle node)1324 ArkUINodeHandle GetTextInputController(ArkUINodeHandle node)
1325 {
1326 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1327 CHECK_NULL_RETURN(frameNode, nullptr);
1328 auto controller = TextFieldModelNG::GetOrCreateController(frameNode);
1329 CHECK_NULL_RETURN(controller, nullptr);
1330 auto nodecontroller = reinterpret_cast<ArkUINodeHandle>(OHOS::Ace::AceType::RawPtr(controller));
1331 return nodecontroller;
1332 }
1333
GetTextInputAdaptMinFontSize(ArkUINodeHandle node)1334 ArkUI_Float32 GetTextInputAdaptMinFontSize(ArkUINodeHandle node)
1335 {
1336 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1337 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
1338 return TextFieldModelNG::GetAdaptMinFontSize(frameNode).Value();
1339 }
1340
GetTextInputAdaptMaxFontSize(ArkUINodeHandle node)1341 ArkUI_Float32 GetTextInputAdaptMaxFontSize(ArkUINodeHandle node)
1342 {
1343 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1344 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
1345 return TextFieldModelNG::GetAdaptMaxFontSize(frameNode).Value();
1346 }
1347
GetTextInputLineHeight(ArkUINodeHandle node)1348 ArkUI_Float32 GetTextInputLineHeight(ArkUINodeHandle node)
1349 {
1350 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1351 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
1352 return TextFieldModelNG::GetLineHeight(frameNode).Value();
1353 }
1354
GetTextInputMaxLines(ArkUINodeHandle node)1355 ArkUI_Int32 GetTextInputMaxLines(ArkUINodeHandle node)
1356 {
1357 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1358 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
1359 return TextFieldModelNG::GetMaxLines(frameNode);
1360 }
1361
SetTextInputSelectAll(ArkUINodeHandle node,ArkUI_Uint32 enableSelectAll)1362 void SetTextInputSelectAll(ArkUINodeHandle node, ArkUI_Uint32 enableSelectAll)
1363 {
1364 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1365 CHECK_NULL_VOID(frameNode);
1366 TextFieldModelNG::SetSelectAllValue(frameNode, static_cast<bool>(enableSelectAll));
1367 }
1368
ResetTextInputSelectAll(ArkUINodeHandle node)1369 void ResetTextInputSelectAll(ArkUINodeHandle node)
1370 {
1371 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1372 CHECK_NULL_VOID(frameNode);
1373 TextFieldModelNG::SetSelectAllValue(frameNode, DEFAULT_SELECT_ALL);
1374 }
1375
SetTextInputShowCounter(ArkUINodeHandle node,ArkUI_Uint32 open,ArkUI_Int32 thresholdPercentage,ArkUI_Uint32 highlightBorder)1376 void SetTextInputShowCounter(
1377 ArkUINodeHandle node, ArkUI_Uint32 open, ArkUI_Int32 thresholdPercentage, ArkUI_Uint32 highlightBorder)
1378 {
1379 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1380 CHECK_NULL_VOID(frameNode);
1381 TextFieldModelNG::SetShowCounter(frameNode, static_cast<bool>(open));
1382 TextFieldModelNG::SetCounterType(frameNode, thresholdPercentage);
1383 TextFieldModelNG::SetShowCounterBorder(frameNode, static_cast<bool>(highlightBorder));
1384 }
1385
ResetTextInputShowCounter(ArkUINodeHandle node)1386 void ResetTextInputShowCounter(ArkUINodeHandle node)
1387 {
1388 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1389 CHECK_NULL_VOID(frameNode);
1390 TextFieldModelNG::SetShowCounter(frameNode, false);
1391 TextFieldModelNG::SetCounterType(frameNode, -1);
1392 TextFieldModelNG::SetShowCounterBorder(frameNode, true);
1393 }
1394
SetTextInputOnEditChange(ArkUINodeHandle node,void * callback)1395 void SetTextInputOnEditChange(ArkUINodeHandle node, void* callback)
1396 {
1397 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1398 CHECK_NULL_VOID(frameNode);
1399 if (callback) {
1400 auto onEditChange = reinterpret_cast<std::function<void(bool)>*>(callback);
1401 TextFieldModelNG::SetOnEditChange(frameNode, std::move(*onEditChange));
1402 } else {
1403 TextFieldModelNG::SetOnEditChange(frameNode, nullptr);
1404 }
1405 }
1406
ResetTextInputOnEditChange(ArkUINodeHandle node)1407 void ResetTextInputOnEditChange(ArkUINodeHandle node)
1408 {
1409 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1410 CHECK_NULL_VOID(frameNode);
1411 TextFieldModelNG::SetOnEditChange(frameNode, nullptr);
1412 }
1413
SetTextInputFilter(ArkUINodeHandle node,ArkUI_CharPtr value,void * callback)1414 void SetTextInputFilter(ArkUINodeHandle node, ArkUI_CharPtr value, void* callback)
1415 {
1416 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1417 CHECK_NULL_VOID(frameNode);
1418 std::string inputFilter(value);
1419 if (callback) {
1420 auto onError = reinterpret_cast<std::function<void(const std::string&)>*>(callback);
1421 TextFieldModelNG::SetInputFilter(frameNode, inputFilter, *onError);
1422 } else {
1423 TextFieldModelNG::SetInputFilter(frameNode, inputFilter, nullptr);
1424 }
1425 }
1426
ResetTextInputFilter(ArkUINodeHandle node)1427 void ResetTextInputFilter(ArkUINodeHandle node)
1428 {
1429 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1430 CHECK_NULL_VOID(frameNode);
1431 TextFieldModelNG::SetInputFilter(frameNode, "", nullptr);
1432 }
1433
SetTextInputOnSubmitWithEvent(ArkUINodeHandle node,void * callback)1434 void SetTextInputOnSubmitWithEvent(ArkUINodeHandle node, void* callback)
1435 {
1436 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1437 CHECK_NULL_VOID(frameNode);
1438 if (callback) {
1439 auto onSubmit = reinterpret_cast<std::function<void(int32_t, NG::TextFieldCommonEvent&)>*>(callback);
1440 TextFieldModelNG::SetOnSubmit(frameNode, std::move(*onSubmit));
1441 } else {
1442 TextFieldModelNG::SetOnSubmit(frameNode, nullptr);
1443 }
1444 }
1445
ResetTextInputOnSubmitWithEvent(ArkUINodeHandle node)1446 void ResetTextInputOnSubmitWithEvent(ArkUINodeHandle node)
1447 {
1448 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1449 CHECK_NULL_VOID(frameNode);
1450 TextFieldModelNG::SetOnSubmit(frameNode, nullptr);
1451 }
1452
SetTextInputOnChange(ArkUINodeHandle node,void * callback)1453 void SetTextInputOnChange(ArkUINodeHandle node, void* callback)
1454 {
1455 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1456 CHECK_NULL_VOID(frameNode);
1457 if (callback) {
1458 auto onChange = reinterpret_cast<std::function<void(const ChangeValueInfo&)>*>(callback);
1459 TextFieldModelNG::SetOnChange(frameNode, std::move(*onChange));
1460 } else {
1461 TextFieldModelNG::SetOnChange(frameNode, nullptr);
1462 }
1463 }
1464
ResetTextInputOnChange(ArkUINodeHandle node)1465 void ResetTextInputOnChange(ArkUINodeHandle node)
1466 {
1467 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1468 CHECK_NULL_VOID(frameNode);
1469 TextFieldModelNG::SetOnChange(frameNode, nullptr);
1470 }
1471
SetTextInputOnTextSelectionChange(ArkUINodeHandle node,void * callback)1472 void SetTextInputOnTextSelectionChange(ArkUINodeHandle node, void* callback)
1473 {
1474 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1475 CHECK_NULL_VOID(frameNode);
1476 if (callback) {
1477 auto onChange = reinterpret_cast<std::function<void(int32_t, int32_t)>*>(callback);
1478 TextFieldModelNG::SetOnTextSelectionChange(frameNode, std::move(*onChange));
1479 } else {
1480 TextFieldModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1481 }
1482 }
1483
ResetTextInputOnTextSelectionChange(ArkUINodeHandle node)1484 void ResetTextInputOnTextSelectionChange(ArkUINodeHandle node)
1485 {
1486 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1487 CHECK_NULL_VOID(frameNode);
1488 TextFieldModelNG::SetOnTextSelectionChange(frameNode, nullptr);
1489 }
1490
SetTextInputOnContentScroll(ArkUINodeHandle node,void * callback)1491 void SetTextInputOnContentScroll(ArkUINodeHandle node, void* callback)
1492 {
1493 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1494 CHECK_NULL_VOID(frameNode);
1495 if (callback) {
1496 auto onScroll = reinterpret_cast<std::function<void(float, float)>*>(callback);
1497 TextFieldModelNG::SetOnContentScroll(frameNode, std::move(*onScroll));
1498 } else {
1499 TextFieldModelNG::SetOnContentScroll(frameNode, nullptr);
1500 }
1501 }
1502
ResetTextInputOnContentScroll(ArkUINodeHandle node)1503 void ResetTextInputOnContentScroll(ArkUINodeHandle node)
1504 {
1505 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1506 CHECK_NULL_VOID(frameNode);
1507 TextFieldModelNG::SetOnContentScroll(frameNode, nullptr);
1508 }
1509
SetTextInputOnCopy(ArkUINodeHandle node,void * callback)1510 void SetTextInputOnCopy(ArkUINodeHandle node, void* callback)
1511 {
1512 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1513 CHECK_NULL_VOID(frameNode);
1514 if (callback) {
1515 auto onCopy = reinterpret_cast<std::function<void(const std::string&)>*>(callback);
1516 TextFieldModelNG::SetOnCopy(frameNode, std::move(*onCopy));
1517 } else {
1518 TextFieldModelNG::SetOnCopy(frameNode, nullptr);
1519 }
1520 }
1521
ResetTextInputOnCopy(ArkUINodeHandle node)1522 void ResetTextInputOnCopy(ArkUINodeHandle node)
1523 {
1524 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1525 CHECK_NULL_VOID(frameNode);
1526 TextFieldModelNG::SetOnCopy(frameNode, nullptr);
1527 }
1528
SetTextInputOnCut(ArkUINodeHandle node,void * callback)1529 void SetTextInputOnCut(ArkUINodeHandle node, void* callback)
1530 {
1531 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1532 CHECK_NULL_VOID(frameNode);
1533 if (callback) {
1534 auto onCut = reinterpret_cast<std::function<void(const std::string&)>*>(callback);
1535 TextFieldModelNG::SetOnCut(frameNode, std::move(*onCut));
1536 } else {
1537 TextFieldModelNG::SetOnCut(frameNode, nullptr);
1538 }
1539 }
1540
ResetTextInputOnCut(ArkUINodeHandle node)1541 void ResetTextInputOnCut(ArkUINodeHandle node)
1542 {
1543 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1544 CHECK_NULL_VOID(frameNode);
1545 TextFieldModelNG::SetOnCut(frameNode, nullptr);
1546 }
1547
SetTextInputOnPaste(ArkUINodeHandle node,void * callback)1548 void SetTextInputOnPaste(ArkUINodeHandle node, void* callback)
1549 {
1550 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1551 CHECK_NULL_VOID(frameNode);
1552 if (callback) {
1553 auto onPasteWithEvent = reinterpret_cast<std::function<void(
1554 const std::string&, NG::TextCommonEvent&)>*>(callback);
1555 TextFieldModelNG::SetOnPasteWithEvent(frameNode, std::move(*onPasteWithEvent));
1556 } else {
1557 TextFieldModelNG::SetOnPasteWithEvent(frameNode, nullptr);
1558 }
1559 }
1560
ResetTextInputOnPaste(ArkUINodeHandle node)1561 void ResetTextInputOnPaste(ArkUINodeHandle node)
1562 {
1563 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1564 CHECK_NULL_VOID(frameNode);
1565 TextFieldModelNG::SetOnPasteWithEvent(frameNode, nullptr);
1566 }
1567
SetBlurOnSubmit(ArkUINodeHandle node,ArkUI_Bool blurOnSubmit)1568 void SetBlurOnSubmit(ArkUINodeHandle node, ArkUI_Bool blurOnSubmit)
1569 {
1570 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1571 CHECK_NULL_VOID(frameNode);
1572 TextFieldModelNG::SetBlurOnSubmit(frameNode, blurOnSubmit);
1573 }
1574
GetBlurOnSubmit(ArkUINodeHandle node)1575 ArkUI_Bool GetBlurOnSubmit(ArkUINodeHandle node)
1576 {
1577 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1578 CHECK_NULL_RETURN(frameNode, true);
1579 return TextFieldModelNG::GetBlurOnSubmit(frameNode);
1580 }
1581
SetTextInputCustomKeyboard(ArkUINodeHandle node,ArkUINodeHandle customKeyboard,bool supportAvoidance)1582 void SetTextInputCustomKeyboard(ArkUINodeHandle node, ArkUINodeHandle customKeyboard, bool supportAvoidance)
1583 {
1584 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1585 CHECK_NULL_VOID(frameNode);
1586 auto *customKeyboardNode = reinterpret_cast<FrameNode*>(customKeyboard);
1587 CHECK_NULL_VOID(customKeyboardNode);
1588 TextFieldModelNG::SetCustomKeyboard(frameNode, customKeyboardNode, supportAvoidance);
1589 }
1590
GetTextInputCustomKeyboard(ArkUINodeHandle node)1591 ArkUINodeHandle GetTextInputCustomKeyboard(ArkUINodeHandle node)
1592 {
1593 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1594 CHECK_NULL_RETURN(frameNode, nullptr);
1595 auto customKeyboard = TextFieldModelNG::GetCustomKeyboard(frameNode);
1596 CHECK_NULL_RETURN(customKeyboard, nullptr);
1597 return reinterpret_cast<ArkUINodeHandle>(OHOS::Ace::AceType::RawPtr(customKeyboard));
1598 }
1599
GetTextInputCustomKeyboardOption(ArkUINodeHandle node)1600 ArkUI_Int32 GetTextInputCustomKeyboardOption(ArkUINodeHandle node)
1601 {
1602 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1603 CHECK_NULL_RETURN(frameNode, 0);
1604 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetCustomKeyboardOption(frameNode));
1605 }
1606
ResetTextInputCustomKeyboard(ArkUINodeHandle node)1607 void ResetTextInputCustomKeyboard(ArkUINodeHandle node)
1608 {
1609 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1610 CHECK_NULL_VOID(frameNode);
1611 TextFieldModelNG::SetCustomKeyboard(frameNode, nullptr, false);
1612 }
1613
1614
SetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node,ArkUI_Bool value)1615 void SetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node, ArkUI_Bool value)
1616 {
1617 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1618 CHECK_NULL_VOID(frameNode);
1619 TextFieldModelNG::SetShowKeyBoardOnFocus(frameNode, value);
1620 }
1621
GetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node)1622 ArkUI_Bool GetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node)
1623 {
1624 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1625 CHECK_NULL_RETURN(frameNode, true);
1626 return static_cast<ArkUI_Bool>(TextFieldModelNG::GetShowKeyBoardOnFocus(frameNode));
1627 }
1628
ResetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node)1629 void ResetTextInputShowKeyBoardOnFocus(ArkUINodeHandle node)
1630 {
1631 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1632 CHECK_NULL_VOID(frameNode);
1633 TextFieldModelNG::SetShowKeyBoardOnFocus(frameNode, true);
1634 }
1635
SetTextInputNumberOfLines(ArkUINodeHandle node,ArkUI_Int32 value)1636 void SetTextInputNumberOfLines(ArkUINodeHandle node, ArkUI_Int32 value)
1637 {
1638 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1639 CHECK_NULL_VOID(frameNode);
1640 TextFieldModelNG::SetNumberOfLines(frameNode, value);
1641 }
1642
GetTextInputNumberOfLines(ArkUINodeHandle node)1643 ArkUI_Int32 GetTextInputNumberOfLines(ArkUINodeHandle node)
1644 {
1645 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1646 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1647 return static_cast<ArkUI_Int32>(TextFieldModelNG::GetNumberOfLines(frameNode));
1648 }
1649
ResetTextInputNumberOfLines(ArkUINodeHandle node)1650 void ResetTextInputNumberOfLines(ArkUINodeHandle node)
1651 {
1652 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1653 CHECK_NULL_VOID(frameNode);
1654 TextFieldModelNG::ResetNumberOfLines(frameNode);
1655 }
1656
SetTextInputShowPassword(ArkUINodeHandle node,ArkUI_Uint32 value)1657 void SetTextInputShowPassword(ArkUINodeHandle node, ArkUI_Uint32 value)
1658 {
1659 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1660 CHECK_NULL_VOID(frameNode);
1661 TextFieldModelNG::SetShowPassword(frameNode, static_cast<bool>(value));
1662 }
1663
ResetTextInputShowPassword(ArkUINodeHandle node)1664 void ResetTextInputShowPassword(ArkUINodeHandle node)
1665 {
1666 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1667 CHECK_NULL_VOID(frameNode);
1668 TextFieldModelNG::SetShowPassword(frameNode, false);
1669 }
1670
GetTextInputShowPassword(ArkUINodeHandle node)1671 ArkUI_Bool GetTextInputShowPassword(ArkUINodeHandle node)
1672 {
1673 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1674 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1675 return TextFieldModelNG::GetShowPassword(frameNode);
1676 }
1677
SetTextInputLineBreakStrategy(ArkUINodeHandle node,ArkUI_Uint32 lineBreakStrategy)1678 void SetTextInputLineBreakStrategy(ArkUINodeHandle node, ArkUI_Uint32 lineBreakStrategy)
1679 {
1680 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1681 CHECK_NULL_VOID(frameNode);
1682 if (lineBreakStrategy < 0 || lineBreakStrategy >= LINE_BREAK_STRATEGY_TYPES.size()) {
1683 lineBreakStrategy = 0; // 0 is the default value of lineBreakStrategy::GREEDY
1684 }
1685 TextFieldModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[lineBreakStrategy]);
1686 }
1687
ResetTextInputLineBreakStrategy(ArkUINodeHandle node)1688 void ResetTextInputLineBreakStrategy(ArkUINodeHandle node)
1689 {
1690 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1691 CHECK_NULL_VOID(frameNode);
1692 // 0 is the default value of lineBreakStrategy::GREEDY
1693 TextFieldModelNG::SetLineBreakStrategy(frameNode, LINE_BREAK_STRATEGY_TYPES[0]);
1694 }
1695
SetTextInputMargin(ArkUINodeHandle node,const struct ArkUISizeType * top,const struct ArkUISizeType * right,const struct ArkUISizeType * bottom,const struct ArkUISizeType * left)1696 void SetTextInputMargin(ArkUINodeHandle node, const struct ArkUISizeType* top, const struct ArkUISizeType* right,
1697 const struct ArkUISizeType* bottom, const struct ArkUISizeType* left)
1698 {
1699 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1700 CHECK_NULL_VOID(frameNode);
1701 CalcLength topDimen;
1702 CalcLength rightDimen;
1703 CalcLength bottomDimen;
1704 CalcLength leftDimen;
1705 if (top->string != nullptr) {
1706 topDimen = CalcLength(top->string);
1707 } else {
1708 topDimen = CalcLength(top->value, static_cast<DimensionUnit>(top->unit));
1709 }
1710 if (right->string != nullptr) {
1711 rightDimen = CalcLength(right->string);
1712 } else {
1713 rightDimen = CalcLength(right->value, static_cast<DimensionUnit>(right->unit));
1714 }
1715 if (bottom->string != nullptr) {
1716 bottomDimen = CalcLength(bottom->string);
1717 } else {
1718 bottomDimen = CalcLength(bottom->value, static_cast<DimensionUnit>(bottom->unit));
1719 }
1720 if (left->string != nullptr) {
1721 leftDimen = CalcLength(left->string);
1722 } else {
1723 leftDimen = CalcLength(left->value, static_cast<DimensionUnit>(left->unit));
1724 }
1725 NG::PaddingProperty paddings;
1726 paddings.top = std::optional<CalcLength>(topDimen);
1727 paddings.bottom = std::optional<CalcLength>(bottomDimen);
1728 paddings.left = std::optional<CalcLength>(leftDimen);
1729 paddings.right = std::optional<CalcLength>(rightDimen);
1730 TextFieldModelNG::SetMargin(frameNode, paddings);
1731 }
1732
ResetTextInputMargin(ArkUINodeHandle node)1733 void ResetTextInputMargin(ArkUINodeHandle node)
1734 {
1735 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1736 CHECK_NULL_VOID(frameNode);
1737 NG::PaddingProperty paddings;
1738 paddings.top = NG::CalcLength(0.0);
1739 paddings.bottom = NG::CalcLength(0.0);
1740 paddings.left = NG::CalcLength(0.0);
1741 paddings.right = NG::CalcLength(0.0);
1742 TextFieldModelNG::SetMargin(frameNode, paddings);
1743 }
1744
GetTextInputMargin(ArkUINodeHandle node,ArkUI_Float32 (* values)[4],ArkUI_Int32 length,ArkUI_Int32 unit)1745 void GetTextInputMargin(ArkUINodeHandle node, ArkUI_Float32 (*values)[4], ArkUI_Int32 length, ArkUI_Int32 unit)
1746 {
1747 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1748 CHECK_NULL_VOID(frameNode);
1749 auto margin = TextFieldModelNG::GetMargin(frameNode);
1750 (*values)[CALL_ARG_0] = margin.top->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1751 (*values)[CALL_ARG_1] = margin.right->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1752 (*values)[CALL_ARG_2] = margin.bottom->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1753 (*values)[CALL_ARG_3] = margin.left->GetDimension().GetNativeValue(static_cast<DimensionUnit>(unit));
1754 length = DEFAULT_MARGIN_VALUES_COUNT;
1755 }
1756
SetTextInputCaret(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)1757 void SetTextInputCaret(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
1758 {
1759 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1760 CHECK_NULL_VOID(frameNode);
1761 CaretStyle caretStyle;
1762 caretStyle.caretWidth = CalcDimension(value, (DimensionUnit)unit);
1763 TextFieldModelNG::SetCaretStyle(frameNode, caretStyle);
1764 }
1765
SetTextInputEnablePreviewText(ArkUINodeHandle node,ArkUI_Uint32 value)1766 void SetTextInputEnablePreviewText(ArkUINodeHandle node, ArkUI_Uint32 value)
1767 {
1768 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1769 CHECK_NULL_VOID(frameNode);
1770 TextFieldModelNG::SetEnablePreviewText(frameNode, static_cast<bool>(value));
1771 }
1772
ResetTextInputEnablePreviewText(ArkUINodeHandle node)1773 void ResetTextInputEnablePreviewText(ArkUINodeHandle node)
1774 {
1775 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1776 CHECK_NULL_VOID(frameNode);
1777 TextFieldModelNG::SetEnablePreviewText(frameNode, DEFAULT_ENABLE_PREVIEW_TEXT_VALUE);
1778 }
1779
GetTextInputEnablePreviewText(ArkUINodeHandle node)1780 ArkUI_Bool GetTextInputEnablePreviewText(ArkUINodeHandle node)
1781 {
1782 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1783 CHECK_NULL_RETURN(frameNode, false);
1784 return static_cast<int>(TextFieldModelNG::GetEnablePreviewText(frameNode));
1785 }
1786
SetTextInputSelectionMenuOptions(ArkUINodeHandle node,void * onCreateMenuCallback,void * onMenuItemClickCallback)1787 void SetTextInputSelectionMenuOptions(ArkUINodeHandle node, void* onCreateMenuCallback, void* onMenuItemClickCallback)
1788 {
1789 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1790 CHECK_NULL_VOID(frameNode);
1791 NG::OnCreateMenuCallback* onCreateMenu = nullptr;
1792 NG::OnMenuItemClickCallback* onMenuItemClick = nullptr;
1793 if (onCreateMenuCallback) {
1794 onCreateMenu = reinterpret_cast<NG::OnCreateMenuCallback*>(onCreateMenuCallback);
1795 }
1796 if (onMenuItemClickCallback) {
1797 onMenuItemClick = reinterpret_cast<NG::OnMenuItemClickCallback*>(onMenuItemClickCallback);
1798 }
1799 if (onCreateMenu != nullptr && onMenuItemClick != nullptr) {
1800 TextFieldModelNG::SetSelectionMenuOptions(frameNode, std::move(*onCreateMenu), std::move(*onMenuItemClick));
1801 } else if (onCreateMenu != nullptr && onMenuItemClick == nullptr) {
1802 TextFieldModelNG::SetSelectionMenuOptions(frameNode, std::move(*onCreateMenu), nullptr);
1803 } else if (onCreateMenu == nullptr && onMenuItemClick != nullptr) {
1804 TextFieldModelNG::SetSelectionMenuOptions(frameNode, nullptr, std::move(*onMenuItemClick));
1805 } else {
1806 TextFieldModelNG::SetSelectionMenuOptions(frameNode, nullptr, nullptr);
1807 }
1808 }
1809
ResetTextInputSelectionMenuOptions(ArkUINodeHandle node)1810 void ResetTextInputSelectionMenuOptions(ArkUINodeHandle node)
1811 {
1812 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1813 CHECK_NULL_VOID(frameNode);
1814 NG::OnCreateMenuCallback onCreateMenuCallback;
1815 NG::OnMenuItemClickCallback onMenuItemClick;
1816 TextFieldModelNG::SetSelectionMenuOptions(frameNode, std::move(onCreateMenuCallback), std::move(onMenuItemClick));
1817 }
1818
SetTextInputWidth(ArkUINodeHandle node,ArkUI_CharPtr value)1819 void SetTextInputWidth(ArkUINodeHandle node, ArkUI_CharPtr value)
1820 {
1821 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1822 CHECK_NULL_VOID(frameNode);
1823 auto widthValue = std::string(value);
1824 TextFieldModelNG::SetWidth(frameNode, widthValue);
1825 }
1826
ResetTextInputWidth(ArkUINodeHandle node)1827 void ResetTextInputWidth(ArkUINodeHandle node)
1828 {
1829 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1830 CHECK_NULL_VOID(frameNode);
1831 TextFieldModelNG::ClearWidth(frameNode);
1832 }
1833
SetTextInputEnableHapticFeedback(ArkUINodeHandle node,ArkUI_Uint32 value)1834 void SetTextInputEnableHapticFeedback(ArkUINodeHandle node, ArkUI_Uint32 value)
1835 {
1836 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1837 CHECK_NULL_VOID(frameNode);
1838 TextFieldModelNG::SetEnableHapticFeedback(frameNode, static_cast<bool>(value));
1839 }
1840
ResetTextInputEnableHapticFeedback(ArkUINodeHandle node)1841 void ResetTextInputEnableHapticFeedback(ArkUINodeHandle node)
1842 {
1843 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1844 CHECK_NULL_VOID(frameNode);
1845 TextFieldModelNG::SetEnableHapticFeedback(frameNode, DEFAULT_ENABLE_HAPTIC_FEEDBACK_VALUE);
1846 }
1847
SetStopBackPress(ArkUINodeHandle node,ArkUI_Uint32 value)1848 void SetStopBackPress(ArkUINodeHandle node, ArkUI_Uint32 value)
1849 {
1850 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1851 CHECK_NULL_VOID(frameNode);
1852 TextFieldModelNG::SetStopBackPress(frameNode, static_cast<bool>(value));
1853 }
1854
ResetStopBackPress(ArkUINodeHandle node)1855 void ResetStopBackPress(ArkUINodeHandle node)
1856 {
1857 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1858 CHECK_NULL_VOID(frameNode);
1859 TextFieldModelNG::SetStopBackPress(frameNode, true);
1860 }
1861
SetTextInputOnWillChange(ArkUINodeHandle node,ArkUI_Int64 callback)1862 void SetTextInputOnWillChange(ArkUINodeHandle node, ArkUI_Int64 callback)
1863 {
1864 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1865 CHECK_NULL_VOID(frameNode);
1866 if (callback) {
1867 auto onWillChange = reinterpret_cast<std::function<bool(const ChangeValueInfo&)>*>(callback);
1868 TextFieldModelNG::SetOnWillChangeEvent(frameNode, std::move(*onWillChange));
1869 } else {
1870 TextFieldModelNG::SetOnWillChangeEvent(frameNode, nullptr);
1871 }
1872 }
1873
ResetTextInputOnWillChange(ArkUINodeHandle node)1874 void ResetTextInputOnWillChange(ArkUINodeHandle node)
1875 {
1876 auto *frameNode = reinterpret_cast<FrameNode *>(node);
1877 CHECK_NULL_VOID(frameNode);
1878 TextFieldModelNG::SetOnWillChangeEvent(frameNode, nullptr);
1879 }
1880
1881 } // namespace
1882
1883 namespace NodeModifier {
GetTextInputModifier()1884 const ArkUITextInputModifier* GetTextInputModifier()
1885 {
1886 static const ArkUITextInputModifier modifier = { SetTextInputCaretColor, ResetTextInputCaretColor, SetTextInputType,
1887 ResetTextInputType, SetTextInputMaxLines, ResetTextInputMaxLines, SetTextInputPlaceholderColor,
1888 ResetTextInputPlaceholderColor, SetTextInputCaretPosition, ResetTextInputCaretPosition, SetTextInputCopyOption,
1889 ResetTextInputCopyOption, SetTextInputShowPasswordIcon, ResetTextInputShowPasswordIcon,
1890 SetTextInputPasswordIcon, ResetTextInputPasswordIcon, SetTextInputTextAlign, ResetTextInputTextAlign,
1891 SetTextInputStyle, ResetTextInputStyle, SetTextInputSelectionMenuHidden, ResetTextInputSelectionMenuHidden,
1892 SetTextInputShowUnderline, ResetTextInputShowUnderline, SetTextInputCaretStyle, ResetTextInputCaretStyle,
1893 SetTextInputEnableKeyboardOnFocus, ResetTextInputEnableKeyboardOnFocus, SetTextInputBarState,
1894 ResetTextInputBarState, SetTextInputEnterKeyType, ResetTextInputEnterKeyType, SetTextInputFontWeight,
1895 ResetTextInputFontWeight, SetTextInputFontSize, ResetTextInputFontSize, SetTextInputMaxLength,
1896 ResetTextInputMaxLength, SetTextInputSelectedBackgroundColor, ResetTextInputSelectedBackgroundColor,
1897 SetTextInputShowError, ResetTextInputShowError, SetTextInputPlaceholderFont, ResetTextInputPlaceholderFont,
1898 SetTextInputFontColor, ResetTextInputFontColor, SetTextInputFontStyle, ResetTextInputFontStyle,
1899 SetTextInputFontFamily, ResetTextInputFontFamily, SetTextInputPlaceholderString, SetTextInputTextString,
1900 SetTextInputFontWeightStr, StopTextInputTextEditing, SetTextInputCancelButton, resetTextInputCancelButton,
1901 GetTextInputPlaceholder, GetTextInputText, GetTextInputCaretColor, GetTextInputCaretStyle,
1902 GetTextInputShowUnderline, GetTextInputMaxLength, GetTextInputEnterKeyType, GetTextInputPlaceholderColor,
1903 GetTextInputPlaceholderFont, GetTextInputRequestKeyboardOnFocus, GetTextInputType,
1904 GetTextInputSelectedBackgroundColor, GetTextInputShowPasswordIcon, GetTextInputEditing,
1905 GetTextInputShowCancelButton, GetTextInputCancelIconSize, getTextInputTextCancelIconSrc,
1906 getTextInputTextCancelIconColor, GetTextInputTextAlign, GetTextInputFontColor, GetTextInputFontStyle,
1907 GetTextInputFontWeight, GetTextInputFontSize, GetTextInputCancelButtonStyle, SetTextInputBackgroundColor,
1908 ResetTextInputBackgroundColor, SetTextInputTextSelection, GetTextInputTextSelectionIndex,
1909 SetTextInputPasswordRules, ResetTextInputPasswordRules, SetTextInputEnableAutoFill,
1910 ResetTextInputEnableAutoFill, SetTextInputPadding, ResetTextInputPadding,
1911 SetTextInputFontFeature, ResetTextInputFontFeature,
1912 SetTextInputDecoration, ResetTextInputDecoration, SetTextInputLetterSpacing, ResetTextInputLetterSpacing,
1913 SetTextInputLineHeight, ResetTextInputLineHeight,
1914 SetTextInputNormalUnderlineColor, SetTextInputUserUnderlineColor, ResetTextInputUserUnderlineColor,
1915 SetTextInputWordBreak, ResetTextInputWordBreak, SetTextInputPlaceholderFontEnum,
1916 SetTextInputAdaptMinFontSize, ResetTextInputAdaptMinFontSize, SetTextInputAdaptMaxFontSize,
1917 ResetTextInputAdaptMaxFontSize, SetTextInputHeightAdaptivePolicy, ResetTextInputHeightAdaptivePolicy,
1918 SetTextInputTextOverflow, ResetTextInputTextOverflow, SetTextInputTextIndent, ResetTextInputTextIndent,
1919 GetTextInputSelectionMenuHidden, GetTextInputWordBreak, GetTextInputEnableAutoFill,
1920 SetTextInputContentType, ResetTextInputContentType, GetTextInputContentType,
1921 GetTextInputUserUnderlineColor, GetTextInputPasswordRules, GetTextInputSelectAll,
1922 SetTextInputInputFilter, GetTextInputInputFilter, ResetTextInputInputFilter, GetTextInputCaretIndex,
1923 GetTextInputCaretOffset, GetTextInputStyle, GetTextInputContentRect, GetTextInputContentLinesNum,
1924 SetBlurOnSubmit, GetBlurOnSubmit, GetTextInputAdaptMinFontSize, GetTextInputAdaptMaxFontSize,
1925 GetTextInputLineHeight, GetTextInputMaxLines, GetTextInputFontFeature,
1926 SetTextInputCustomKeyboard, GetTextInputCustomKeyboard, GetTextInputCustomKeyboardOption,
1927 ResetTextInputCustomKeyboard, SetTextInputSelectAll, ResetTextInputSelectAll, SetTextInputShowCounter,
1928 ResetTextInputShowCounter, SetTextInputOnEditChange, ResetTextInputOnEditChange, SetTextInputFilter,
1929 ResetTextInputFilter, SetTextInputOnSubmitWithEvent, ResetTextInputOnSubmitWithEvent, SetTextInputOnChange,
1930 ResetTextInputOnChange, SetTextInputOnTextSelectionChange, ResetTextInputOnTextSelectionChange,
1931 SetTextInputOnContentScroll, ResetTextInputOnContentScroll, SetTextInputOnCopy, ResetTextInputOnCopy,
1932 SetTextInputOnCut, ResetTextInputOnCut, SetTextInputOnPaste, ResetTextInputOnPaste,
1933 SetTextInputShowKeyBoardOnFocus, GetTextInputShowKeyBoardOnFocus, ResetTextInputShowKeyBoardOnFocus,
1934 SetTextInputNumberOfLines, GetTextInputNumberOfLines, ResetTextInputNumberOfLines,
1935 SetTextInputShowPassword, ResetTextInputShowPassword, GetTextInputShowPassword, SetTextInputLineBreakStrategy,
1936 ResetTextInputLineBreakStrategy, SetTextInputMargin, ResetTextInputMargin,
1937 GetTextInputMargin, SetTextInputCaret, GetTextInputController,
1938 SetTextInputEnablePreviewText, ResetTextInputEnablePreviewText,
1939 SetTextInputSelectionMenuOptions, ResetTextInputSelectionMenuOptions,
1940 SetTextInputWidth, ResetTextInputWidth, SetTextInputEnableHapticFeedback, ResetTextInputEnableHapticFeedback,
1941 SetStopBackPress, ResetStopBackPress, SetTextInputKeyboardAppearance, GetTextInputKeyboardAppearance,
1942 ResetTextInputKeyboardAppearance, GetTextInputLetterSpacing, GetTextInputEnablePreviewText,
1943 SetTextInputOnWillChange, ResetTextInputOnWillChange };
1944 return &modifier;
1945 }
1946
GetCJUITextInputModifier()1947 const CJUITextInputModifier* GetCJUITextInputModifier()
1948 {
1949 static const CJUITextInputModifier modifier = { SetTextInputCaretColor, ResetTextInputCaretColor, SetTextInputType,
1950 ResetTextInputType, SetTextInputMaxLines, ResetTextInputMaxLines, SetTextInputPlaceholderColor,
1951 ResetTextInputPlaceholderColor, SetTextInputCaretPosition, ResetTextInputCaretPosition, SetTextInputCopyOption,
1952 ResetTextInputCopyOption, SetTextInputShowPasswordIcon, ResetTextInputShowPasswordIcon,
1953 SetTextInputPasswordIcon, ResetTextInputPasswordIcon, SetTextInputTextAlign, ResetTextInputTextAlign,
1954 SetTextInputStyle, ResetTextInputStyle, SetTextInputSelectionMenuHidden, ResetTextInputSelectionMenuHidden,
1955 SetTextInputShowUnderline, ResetTextInputShowUnderline, SetTextInputCaretStyle, ResetTextInputCaretStyle,
1956 SetTextInputEnableKeyboardOnFocus, ResetTextInputEnableKeyboardOnFocus, SetTextInputBarState,
1957 ResetTextInputBarState, SetTextInputEnterKeyType, ResetTextInputEnterKeyType, SetTextInputFontWeight,
1958 ResetTextInputFontWeight, SetTextInputFontSize, ResetTextInputFontSize, SetTextInputMaxLength,
1959 ResetTextInputMaxLength, SetTextInputSelectedBackgroundColor, ResetTextInputSelectedBackgroundColor,
1960 SetTextInputShowError, ResetTextInputShowError, SetTextInputPlaceholderFont, ResetTextInputPlaceholderFont,
1961 SetTextInputFontColor, ResetTextInputFontColor, SetTextInputFontStyle, ResetTextInputFontStyle,
1962 SetTextInputFontFamily, ResetTextInputFontFamily, SetTextInputPlaceholderString, SetTextInputTextString,
1963 SetTextInputFontWeightStr, StopTextInputTextEditing, SetTextInputCancelButton, resetTextInputCancelButton,
1964 GetTextInputPlaceholder, GetTextInputText, GetTextInputCaretColor, GetTextInputCaretStyle,
1965 GetTextInputShowUnderline, GetTextInputMaxLength, GetTextInputEnterKeyType, GetTextInputPlaceholderColor,
1966 GetTextInputPlaceholderFont, GetTextInputRequestKeyboardOnFocus, GetTextInputType,
1967 GetTextInputSelectedBackgroundColor, GetTextInputShowPasswordIcon, GetTextInputEditing,
1968 GetTextInputShowCancelButton, GetTextInputCancelIconSize, getTextInputTextCancelIconSrc,
1969 getTextInputTextCancelIconColor, GetTextInputTextAlign, GetTextInputFontColor, GetTextInputFontStyle,
1970 GetTextInputFontWeight, GetTextInputFontSize, GetTextInputCancelButtonStyle, SetTextInputBackgroundColor,
1971 ResetTextInputBackgroundColor, SetTextInputTextSelection, GetTextInputTextSelectionIndex,
1972 SetTextInputPasswordRules, ResetTextInputPasswordRules, SetTextInputEnableAutoFill,
1973 ResetTextInputEnableAutoFill, SetTextInputPadding, ResetTextInputPadding,
1974 SetTextInputFontFeature, ResetTextInputFontFeature,
1975 SetTextInputDecoration, ResetTextInputDecoration, SetTextInputLetterSpacing, ResetTextInputLetterSpacing,
1976 SetTextInputLineHeight, ResetTextInputLineHeight,
1977 SetTextInputNormalUnderlineColor, SetTextInputUserUnderlineColor, ResetTextInputUserUnderlineColor,
1978 SetTextInputWordBreak, ResetTextInputWordBreak, SetTextInputPlaceholderFontEnum,
1979 SetTextInputAdaptMinFontSize, ResetTextInputAdaptMinFontSize, SetTextInputAdaptMaxFontSize,
1980 ResetTextInputAdaptMaxFontSize, SetTextInputHeightAdaptivePolicy, ResetTextInputHeightAdaptivePolicy,
1981 SetTextInputTextOverflow, ResetTextInputTextOverflow, SetTextInputTextIndent, ResetTextInputTextIndent,
1982 GetTextInputSelectionMenuHidden, GetTextInputWordBreak, GetTextInputEnableAutoFill,
1983 SetTextInputContentType, ResetTextInputContentType, GetTextInputContentType,
1984 GetTextInputUserUnderlineColor, GetTextInputPasswordRules, GetTextInputSelectAll,
1985 SetTextInputInputFilter, GetTextInputInputFilter, ResetTextInputInputFilter, GetTextInputCaretIndex,
1986 GetTextInputCaretOffset, GetTextInputStyle, GetTextInputContentRect, GetTextInputContentLinesNum,
1987 SetBlurOnSubmit, GetBlurOnSubmit, GetTextInputAdaptMinFontSize, GetTextInputAdaptMaxFontSize,
1988 GetTextInputLineHeight, GetTextInputMaxLines, GetTextInputFontFeature,
1989 SetTextInputCustomKeyboard, GetTextInputCustomKeyboard, GetTextInputCustomKeyboardOption,
1990 ResetTextInputCustomKeyboard, SetTextInputSelectAll, ResetTextInputSelectAll, SetTextInputShowCounter,
1991 ResetTextInputShowCounter, SetTextInputOnEditChange, ResetTextInputOnEditChange, SetTextInputFilter,
1992 ResetTextInputFilter, SetTextInputOnSubmitWithEvent, ResetTextInputOnSubmitWithEvent, SetTextInputOnChange,
1993 ResetTextInputOnChange, SetTextInputOnTextSelectionChange, ResetTextInputOnTextSelectionChange,
1994 SetTextInputOnContentScroll, ResetTextInputOnContentScroll, SetTextInputOnCopy, ResetTextInputOnCopy,
1995 SetTextInputOnCut, ResetTextInputOnCut, SetTextInputOnPaste, ResetTextInputOnPaste,
1996 SetTextInputShowKeyBoardOnFocus, GetTextInputShowKeyBoardOnFocus, ResetTextInputShowKeyBoardOnFocus,
1997 SetTextInputNumberOfLines, GetTextInputNumberOfLines, ResetTextInputNumberOfLines,
1998 SetTextInputShowPassword, ResetTextInputShowPassword, GetTextInputShowPassword, SetTextInputLineBreakStrategy,
1999 ResetTextInputLineBreakStrategy, SetTextInputMargin, ResetTextInputMargin,
2000 GetTextInputMargin, SetTextInputCaret, GetTextInputController,
2001 SetTextInputEnablePreviewText, ResetTextInputEnablePreviewText };
2002
2003 return &modifier;
2004 }
2005
SetOnTextInputChange(ArkUINodeHandle node,void * extraParam)2006 void SetOnTextInputChange(ArkUINodeHandle node, void* extraParam)
2007 {
2008 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2009 CHECK_NULL_VOID(frameNode);
2010 auto onChange = [node, extraParam](const ChangeValueInfo& info) {
2011 ArkUINodeEvent event;
2012 event.kind = TEXT_INPUT;
2013 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2014 event.textInputEvent.subKind = ON_TEXT_INPUT_CHANGE;
2015 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(info.value.c_str());
2016 SendArkUIAsyncEvent(&event);
2017 };
2018 TextFieldModelNG::SetOnChange(frameNode, std::move(onChange));
2019 }
2020
SetOnTextInputChangeWithPreviewText(ArkUINodeHandle node,void * extraParam)2021 void SetOnTextInputChangeWithPreviewText(ArkUINodeHandle node, void* extraParam)
2022 {
2023 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2024 CHECK_NULL_VOID(frameNode);
2025 auto onChange = [node, extraParam](const ChangeValueInfo& info) {
2026 ArkUINodeEvent eventWithPreview;
2027 eventWithPreview.kind = TEXT_INPUT_CHANGE;
2028 eventWithPreview.extraParam = reinterpret_cast<intptr_t>(extraParam);
2029 eventWithPreview.textChangeEvent.subKind = ON_TEXT_INPUT_CHANGE_WITH_PREVIEW_TEXT;
2030 eventWithPreview.textChangeEvent.nativeStringPtr = const_cast<char*>(info.value.c_str());
2031 eventWithPreview.textChangeEvent.extendStringPtr = const_cast<char*>(info.previewText.value.c_str());
2032 eventWithPreview.textChangeEvent.numArgs = info.previewText.offset;
2033 SendArkUIAsyncEvent(&eventWithPreview);
2034 };
2035 TextFieldModelNG::SetOnChange(frameNode, std::move(onChange));
2036 }
2037
SetTextInputOnSubmit(ArkUINodeHandle node,void * extraParam)2038 void SetTextInputOnSubmit(ArkUINodeHandle node, void* extraParam)
2039 {
2040 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2041 CHECK_NULL_VOID(frameNode);
2042 auto onEvent = [node, extraParam](int32_t value, NG::TextFieldCommonEvent& commonEvent) {
2043 ArkUINodeEvent event;
2044 event.kind = COMPONENT_ASYNC_EVENT;
2045 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2046 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_SUBMIT;
2047 event.componentAsyncEvent.data[0].i32 = value;
2048 SendArkUIAsyncEvent(&event);
2049 };
2050 TextFieldModelNG::SetOnSubmit(frameNode, std::move(onEvent));
2051 }
2052
SetOnTextInputCut(ArkUINodeHandle node,void * extraParam)2053 void SetOnTextInputCut(ArkUINodeHandle node, void* extraParam)
2054 {
2055 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2056 CHECK_NULL_VOID(frameNode);
2057 auto onCut = [node, extraParam](const std::string& str) {
2058 ArkUINodeEvent event;
2059 event.kind = TEXT_INPUT;
2060 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2061 event.textInputEvent.subKind = ON_TEXT_INPUT_CUT;
2062 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
2063 SendArkUIAsyncEvent(&event);
2064 };
2065 TextFieldModelNG::SetOnCut(frameNode, std::move(onCut));
2066 }
2067
SetOnTextInputPaste(ArkUINodeHandle node,void * extraParam)2068 void SetOnTextInputPaste(ArkUINodeHandle node, void* extraParam)
2069 {
2070 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2071 CHECK_NULL_VOID(frameNode);
2072 auto onPaste = [node, extraParam](const std::string& str, NG::TextCommonEvent& commonEvent) {
2073 ArkUINodeEvent event;
2074 event.kind = TEXT_INPUT;
2075 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2076 event.textInputEvent.subKind = ON_TEXT_INPUT_PASTE;
2077 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
2078 SendArkUIAsyncEvent(&event);
2079 };
2080 TextFieldModelNG::SetOnPasteWithEvent(frameNode, std::move(onPaste));
2081 }
2082
SetOnTextInputSelectionChange(ArkUINodeHandle node,void * extraParam)2083 void SetOnTextInputSelectionChange(ArkUINodeHandle node, void* extraParam)
2084 {
2085 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2086 CHECK_NULL_VOID(frameNode);
2087 auto onSelectionChange = [node, extraParam](int32_t start, int32_t end) {
2088 ArkUINodeEvent event;
2089 event.kind = COMPONENT_ASYNC_EVENT;
2090 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2091 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_TEXT_SELECTION_CHANGE;
2092 event.componentAsyncEvent.data[0].i32 = static_cast<int>(start);
2093 event.componentAsyncEvent.data[1].i32 = static_cast<int>(end);
2094 SendArkUIAsyncEvent(&event);
2095 };
2096 TextFieldModelNG::SetOnTextSelectionChange(frameNode, std::move(onSelectionChange));
2097 }
2098
SetOnTextInputEditChange(ArkUINodeHandle node,void * extraParam)2099 void SetOnTextInputEditChange(ArkUINodeHandle node, void* extraParam)
2100 {
2101 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2102 CHECK_NULL_VOID(frameNode);
2103 auto onChange = [node, extraParam](bool isEditing) {
2104 ArkUINodeEvent event;
2105 event.kind = COMPONENT_ASYNC_EVENT;
2106 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2107 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_EDIT_CHANGE;
2108 event.componentAsyncEvent.data[0].i32 = static_cast<int>(isEditing);
2109 SendArkUIAsyncEvent(&event);
2110 };
2111 TextFieldModelNG::SetOnEditChanged(frameNode, std::move(onChange));
2112 }
2113
SetOnTextInputContentSizeChange(ArkUINodeHandle node,void * extraParam)2114 void SetOnTextInputContentSizeChange(ArkUINodeHandle node, void* extraParam)
2115 {
2116 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2117 CHECK_NULL_VOID(frameNode);
2118 auto onChange = [node, extraParam](float width, float height) {
2119 ArkUINodeEvent event;
2120 event.kind = COMPONENT_ASYNC_EVENT;
2121 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2122 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_CONTENT_SIZE_CHANGE;
2123 bool usePx = NodeModel::UsePXUnit(reinterpret_cast<ArkUI_Node*>(extraParam));
2124 double density = usePx ? 1 : PipelineBase::GetCurrentDensity();
2125 //0 width
2126 event.componentAsyncEvent.data[0].f32 = NearEqual(density, 0.0) ? 0.0f : width / density;
2127 //1 height
2128 event.componentAsyncEvent.data[1].f32 = NearEqual(density, 0.0) ? 0.0f : height / density;
2129 SendArkUIAsyncEvent(&event);
2130 };
2131 TextFieldModelNG::SetOnContentSizeChange(frameNode, std::move(onChange));
2132 }
2133
SetOnTextInputInputFilterError(ArkUINodeHandle node,void * extraParam)2134 void SetOnTextInputInputFilterError(ArkUINodeHandle node, void* extraParam)
2135 {
2136 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2137 CHECK_NULL_VOID(frameNode);
2138 auto onInputFilterError = [node, extraParam](const std::string& str) {
2139 ArkUINodeEvent event;
2140 event.kind = TEXT_INPUT;
2141 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2142 event.textInputEvent.subKind = ON_TEXT_INPUT_INPUT_FILTER_ERROR;
2143 event.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
2144 SendArkUIAsyncEvent(&event);
2145 };
2146 TextFieldModelNG::SetInputFilterError(frameNode, std::move(onInputFilterError));
2147 }
2148
SetTextInputOnTextContentScroll(ArkUINodeHandle node,void * extraParam)2149 void SetTextInputOnTextContentScroll(ArkUINodeHandle node, void* extraParam)
2150 {
2151 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2152 CHECK_NULL_VOID(frameNode);
2153 auto onScroll = [node, extraParam](float totalOffsetX, float totalOffsetY) {
2154 ArkUINodeEvent event;
2155 event.kind = COMPONENT_ASYNC_EVENT;
2156 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2157 event.componentAsyncEvent.subKind = ON_TEXT_INPUT_CONTENT_SCROLL;
2158 event.componentAsyncEvent.data[0].f32 = totalOffsetX;
2159 event.componentAsyncEvent.data[1].f32 = totalOffsetY;
2160 SendArkUIAsyncEvent(&event);
2161 };
2162 TextFieldModelNG::SetOnContentScroll(frameNode, std::move(onScroll));
2163 }
2164
ResetOnTextInputChange(ArkUINodeHandle node)2165 void ResetOnTextInputChange(ArkUINodeHandle node)
2166 {
2167 GetTextInputModifier()->resetTextInputOnChange(node);
2168 }
ResetTextInputOnSubmit(ArkUINodeHandle node)2169 void ResetTextInputOnSubmit(ArkUINodeHandle node)
2170 {
2171 GetTextInputModifier()->resetTextInputOnSubmitWithEvent(node);
2172 }
ResetOnTextInputCut(ArkUINodeHandle node)2173 void ResetOnTextInputCut(ArkUINodeHandle node)
2174 {
2175 GetTextInputModifier()->resetTextInputOnCut(node);
2176 }
ResetOnTextInputPaste(ArkUINodeHandle node)2177 void ResetOnTextInputPaste(ArkUINodeHandle node)
2178 {
2179 GetTextInputModifier()->resetTextInputOnPaste(node);
2180 }
ResetOnTextInputSelectionChange(ArkUINodeHandle node)2181 void ResetOnTextInputSelectionChange(ArkUINodeHandle node)
2182 {
2183 GetTextInputModifier()->resetTextInputOnTextSelectionChange(node);
2184 }
ResetOnTextInputEditChange(ArkUINodeHandle node)2185 void ResetOnTextInputEditChange(ArkUINodeHandle node)
2186 {
2187 GetTextInputModifier()->resetTextInputOnEditChange(node);
2188 }
ResetOnTextInputContentSizeChange(ArkUINodeHandle node)2189 void ResetOnTextInputContentSizeChange(ArkUINodeHandle node)
2190 {
2191 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2192 CHECK_NULL_VOID(frameNode);
2193 TextFieldModelNG::SetOnContentSizeChange(frameNode, nullptr);
2194 }
ResetOnTextInputInputFilterError(ArkUINodeHandle node)2195 void ResetOnTextInputInputFilterError(ArkUINodeHandle node)
2196 {
2197 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2198 CHECK_NULL_VOID(frameNode);
2199 TextFieldModelNG::SetInputFilterError(frameNode, nullptr);
2200 }
ResetTextInputOnTextContentScroll(ArkUINodeHandle node)2201 void ResetTextInputOnTextContentScroll(ArkUINodeHandle node)
2202 {
2203 GetTextInputModifier()->resetTextInputOnContentScroll(node);
2204 }
2205
SetTextInputOnWillInsert(ArkUINodeHandle node,void * extraParam)2206 void SetTextInputOnWillInsert(ArkUINodeHandle node, void* extraParam)
2207 {
2208 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2209 CHECK_NULL_VOID(frameNode);
2210 auto onWillInsert = [node, extraParam](const InsertValueInfo& Info) -> bool {
2211 ArkUINodeEvent event;
2212 event.kind = MIXED_EVENT;
2213 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2214 event.mixedEvent.subKind = ON_TEXT_INPUT_WILL_INSERT;
2215 event.mixedEvent.numberData[0].f32 = Info.insertOffset;
2216 event.mixedEvent.numberDataLength = 1;
2217 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(Info.insertValue.c_str());
2218 event.mixedEvent.stringPtrDataLength = 1;
2219 SendArkUIAsyncEvent(&event);
2220 return event.mixedEvent.numberReturnData[0].i32;
2221 };
2222 TextFieldModelNG::SetOnWillInsertValueEvent(frameNode, std::move(onWillInsert));
2223 }
2224
SetTextInputOnDidInsert(ArkUINodeHandle node,void * extraParam)2225 void SetTextInputOnDidInsert(ArkUINodeHandle node, void* extraParam)
2226 {
2227 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2228 CHECK_NULL_VOID(frameNode);
2229 auto onDidInsert = [node, extraParam](const InsertValueInfo& Info) {
2230 ArkUINodeEvent event;
2231 event.kind = MIXED_EVENT;
2232 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2233 event.mixedEvent.subKind = ON_TEXT_INPUT_DID_INSERT;
2234 event.mixedEvent.numberData[0].f32 = Info.insertOffset;
2235 event.mixedEvent.numberDataLength = 1;
2236 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(Info.insertValue.c_str());
2237 event.mixedEvent.stringPtrDataLength = 1;
2238 SendArkUIAsyncEvent(&event);
2239 };
2240 TextFieldModelNG::SetOnDidInsertValueEvent(frameNode, std::move(onDidInsert));
2241 }
2242
SetTextInputOnWillDelete(ArkUINodeHandle node,void * extraParam)2243 void SetTextInputOnWillDelete(ArkUINodeHandle node, void* extraParam)
2244 {
2245 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2246 CHECK_NULL_VOID(frameNode);
2247 auto onWillDelete = [node, extraParam](const DeleteValueInfo& Info) -> bool {
2248 ArkUINodeEvent event;
2249 event.kind = MIXED_EVENT;
2250 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2251 event.mixedEvent.subKind = ON_TEXT_INPUT_WILL_DELETE;
2252 event.mixedEvent.numberData[0].f32 = Info.deleteOffset;
2253 event.mixedEvent.numberData[1].i32 = static_cast<int32_t>(Info.direction);
2254 event.mixedEvent.numberDataLength = 2;
2255 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(Info.deleteValue.c_str());
2256 event.mixedEvent.stringPtrDataLength = 1;
2257 SendArkUIAsyncEvent(&event);
2258 return event.mixedEvent.numberReturnData[0].i32;
2259 };
2260 TextFieldModelNG::SetOnWillDeleteEvent(frameNode, std::move(onWillDelete));
2261 }
2262
SetTextInputOnDidDelete(ArkUINodeHandle node,void * extraParam)2263 void SetTextInputOnDidDelete(ArkUINodeHandle node, void* extraParam)
2264 {
2265 auto* frameNode = reinterpret_cast<FrameNode*>(node);
2266 CHECK_NULL_VOID(frameNode);
2267 auto onDidDelete = [node, extraParam](const DeleteValueInfo& Info) {
2268 ArkUINodeEvent event;
2269 event.kind = MIXED_EVENT;
2270 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
2271 event.mixedEvent.subKind = ON_TEXT_INPUT_DID_DELETE;
2272 event.mixedEvent.numberData[0].f32 = Info.deleteOffset;
2273 event.mixedEvent.numberData[1].i32 = static_cast<int32_t>(Info.direction);
2274 event.mixedEvent.numberDataLength = 2;
2275 event.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(Info.deleteValue.c_str());
2276 event.mixedEvent.stringPtrDataLength = 1;
2277 SendArkUIAsyncEvent(&event);
2278 };
2279 TextFieldModelNG::SetOnDidDeleteEvent(frameNode, std::move(onDidDelete));
2280 }
ResetOnTextInputChangeWithPreviewText(ArkUINodeHandle node)2281 void ResetOnTextInputChangeWithPreviewText(ArkUINodeHandle node)
2282 {
2283 GetTextInputModifier()->resetTextInputOnChange(node);
2284 }
2285 } // namespace NodeModifier
2286 } // namespace OHOS::Ace::NG
2287