1 /*
2 * Copyright (c) 2022-2025 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
16 #include "core/components_ng/pattern/text_field/text_field_model_ng.h"
17
18 #include <cstddef>
19
20 #include "base/geometry/dimension.h"
21 #include "base/memory/ace_type.h"
22 #include "base/memory/referenced.h"
23 #include "base/utils/multi_thread.h"
24 #include "base/utils/utils.h"
25 #include "core/common/ime/text_edit_controller.h"
26 #include "core/common/ime/text_input_type.h"
27 #include "core/components_ng/pattern/text_field/text_field_layout_property.h"
28 #include "core/components_ng/pattern/text_field/text_field_paint_property.h"
29 #include "core/components_ng/pattern/text_field/text_field_pattern.h"
30
31 namespace OHOS::Ace::NG {
32 namespace {
33 const std::string DROP_TYPE_STYLED_STRING = "ApplicationDefinedType";
34 const std::string DROP_TYPE_PLAIN_TEXT = "general.plain-text";
35 const std::string DROP_TYPE_HYPERLINK = "general.hyperlink";
36 }
CreateNode(const std::optional<std::u16string> & placeholder,const std::optional<std::u16string> & value,bool isTextArea)37 void TextFieldModelNG::CreateNode(
38 const std::optional<std::u16string>& placeholder, const std::optional<std::u16string>& value, bool isTextArea)
39 {
40 auto* stack = ViewStackProcessor::GetInstance();
41 auto nodeId = stack->ClaimNodeId();
42 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", isTextArea ? V2::TEXTAREA_ETS_TAG : V2::TEXTINPUT_ETS_TAG, nodeId);
43 auto frameNode = FrameNode::GetOrCreateFrameNode(isTextArea ? V2::TEXTAREA_ETS_TAG : V2::TEXTINPUT_ETS_TAG, nodeId,
44 []() { return AceType::MakeRefPtr<TextFieldPattern>(); });
45 stack->Push(frameNode);
46 auto textFieldLayoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
47 CHECK_NULL_VOID(textFieldLayoutProperty);
48 auto textfieldPaintProperty = frameNode->GetPaintProperty<TextFieldPaintProperty>();
49 CHECK_NULL_VOID(textfieldPaintProperty);
50 std::set<std::string> allowDropSet({ DROP_TYPE_PLAIN_TEXT, DROP_TYPE_HYPERLINK, DROP_TYPE_STYLED_STRING });
51 frameNode->SetAllowDrop(allowDropSet);
52 auto pattern = frameNode->GetPattern<TextFieldPattern>();
53 pattern->InitTheme();
54 pattern->SetModifyDoneStatus(false);
55 pattern->ResetContextAttr();
56 auto textValue = pattern->GetTextUtf16Value();
57 if (value.has_value() && value.value() != textValue) {
58 auto changed = pattern->InitValueText(value.value());
59 pattern->SetTextChangedAtCreation(changed);
60 if (changed) {
61 pattern->ClearOperationRecords();
62 }
63 }
64 if (!pattern->HasOperationRecords()) {
65 pattern->UpdateEditingValueToRecord(); // record initial status
66 }
67 textFieldLayoutProperty->UpdatePlaceholder(placeholder.value_or(u""));
68 if (!isTextArea) {
69 textFieldLayoutProperty->UpdateMaxLines(1);
70 textFieldLayoutProperty->UpdatePlaceholderMaxLines(1);
71 pattern->SetTextInputFlag(true);
72 } else {
73 textFieldLayoutProperty->UpdatePlaceholderMaxLines(Infinity<uint32_t>());
74 }
75 pattern->SetTextFieldController(AceType::MakeRefPtr<TextFieldController>());
76 pattern->GetTextFieldController()->SetPattern(AceType::WeakClaim(AceType::RawPtr(pattern)));
77 pattern->InitSurfaceChangedCallback();
78 pattern->RegisterWindowSizeCallback();
79 pattern->InitSurfacePositionChangedCallback();
80 auto pipeline = frameNode->GetContext();
81 CHECK_NULL_VOID(pipeline);
82 auto colorMode = pipeline->GetColorMode();
83 pattern->SetOriginCursorColor(colorMode == ColorMode::DARK ? Color(0x4DFFFFFF) : Color(0x4D000000));
84 if (pipeline->GetHasPreviewTextOption()) {
85 pattern->SetSupportPreviewText(pipeline->GetSupportPreviewText());
86 }
87 auto textFieldTheme = pattern->GetTheme();
88 CHECK_NULL_VOID(textFieldTheme);
89 textfieldPaintProperty->UpdatePressBgColor(textFieldTheme->GetPressColor());
90 textfieldPaintProperty->UpdateHoverBgColor(textFieldTheme->GetHoverColor());
91 pattern->SetHoverPressBgColorEnabled(textFieldTheme->GetHoverAndPressBgColorEnabled());
92 if (!textfieldPaintProperty->HasCaretColorFlagByUser()) {
93 textfieldPaintProperty->UpdateCursorColor(textFieldTheme->GetCursorColor());
94 }
95 if (!textfieldPaintProperty->HasCursorWidth()) {
96 CaretStyle caretStyle;
97 caretStyle.caretWidth = textFieldTheme->GetCursorWidth();
98 SetCaretStyle(caretStyle);
99 }
100 AddDragFrameNodeToManager();
101 if (frameNode->IsFirstBuilding()) {
102 auto draggable = pipeline->GetDraggable<TextFieldTheme>();
103 SetDraggable(draggable);
104 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
105 CHECK_NULL_VOID(gestureHub);
106 gestureHub->SetTextDraggable(true);
107 }
108 }
109
CreateTextInputNode(int32_t nodeId,const std::optional<std::u16string> & placeholder,const std::optional<std::u16string> & value)110 RefPtr<FrameNode> TextFieldModelNG::CreateTextInputNode(
111 int32_t nodeId, const std::optional<std::u16string>& placeholder, const std::optional<std::u16string>& value)
112 {
113 auto frameNode = FrameNode::CreateFrameNode(V2::TEXTINPUT_ETS_TAG, nodeId, AceType::MakeRefPtr<TextFieldPattern>());
114 auto textFieldLayoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
115 CHECK_NULL_RETURN(textFieldLayoutProperty, nullptr);
116 auto pattern = frameNode->GetPattern<TextFieldPattern>();
117 CHECK_NULL_RETURN(pattern, nullptr);
118 textFieldLayoutProperty->UpdatePlaceholder(placeholder.value_or(u""));
119 textFieldLayoutProperty->UpdateMaxLines(1);
120 textFieldLayoutProperty->UpdatePlaceholderMaxLines(1);
121 pattern->SetTextInputFlag(true);
122 UpdateTextFieldPattern(frameNode, value);
123 return frameNode;
124 }
125
CreateTextAreaNode(int32_t nodeId,const std::optional<std::u16string> & placeholder,const std::optional<std::u16string> & value)126 RefPtr<FrameNode> TextFieldModelNG::CreateTextAreaNode(
127 int32_t nodeId, const std::optional<std::u16string>& placeholder, const std::optional<std::u16string>& value)
128 {
129 auto frameNode = FrameNode::CreateFrameNode(V2::TEXTAREA_ETS_TAG, nodeId, AceType::MakeRefPtr<TextFieldPattern>());
130 auto textFieldLayoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
131 CHECK_NULL_RETURN(textFieldLayoutProperty, nullptr);
132 textFieldLayoutProperty->UpdatePlaceholder(placeholder.value_or(u""));
133 textFieldLayoutProperty->UpdatePlaceholderMaxLines(Infinity<uint32_t>());
134 UpdateTextFieldPattern(frameNode, value);
135 return frameNode;
136 }
137
UpdateTextFieldPattern(const RefPtr<FrameNode> & frameNode,const std::optional<std::u16string> & value)138 void TextFieldModelNG::UpdateTextFieldPattern(
139 const RefPtr<FrameNode>& frameNode, const std::optional<std::u16string>& value)
140 {
141 auto pattern = frameNode->GetPattern<TextFieldPattern>();
142 CHECK_NULL_VOID(pattern);
143 pattern->InitTheme();
144 pattern->SetModifyDoneStatus(false);
145 auto textValue = pattern->GetTextUtf16Value();
146 if (value.has_value() && value.value() != textValue) {
147 pattern->InitEditingValueText(value.value());
148 pattern->SetTextChangedAtCreation(true);
149 pattern->ClearOperationRecords();
150 }
151 if (!pattern->HasOperationRecords()) {
152 pattern->UpdateEditingValueToRecord(); // record initial status
153 }
154 pattern->InitSurfaceChangedCallback();
155 pattern->InitSurfacePositionChangedCallback();
156 pattern->RegisterWindowSizeCallback();
157 auto pipeline = frameNode->GetContext();
158 CHECK_NULL_VOID(pipeline);
159 if (pipeline->GetHasPreviewTextOption()) {
160 pattern->SetSupportPreviewText(pipeline->GetSupportPreviewText());
161 }
162 ProcessDefaultStyleAndBehaviors(frameNode);
163 }
164
SetDraggable(bool draggable)165 void TextFieldModelNG::SetDraggable(bool draggable)
166 {
167 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
168 CHECK_NULL_VOID(frameNode);
169 frameNode->SetDraggable(draggable);
170 }
171
SetShowUnderline(bool showUnderLine)172 void TextFieldModelNG::SetShowUnderline(bool showUnderLine)
173 {
174 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowUnderline, showUnderLine);
175 }
176
SetFontFeature(const FONT_FEATURES_LIST & value)177 void TextFieldModelNG::SetFontFeature(const FONT_FEATURES_LIST& value)
178 {
179 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, FontFeature, value);
180 }
181
SetFontFeature(FrameNode * frameNode,const FONT_FEATURES_LIST & value)182 void TextFieldModelNG::SetFontFeature(FrameNode* frameNode, const FONT_FEATURES_LIST& value)
183 {
184 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, FontFeature, value, frameNode);
185 }
186
SetAutoWidth(FrameNode * frameNode)187 void TextFieldModelNG::SetAutoWidth(FrameNode* frameNode)
188 {
189 CHECK_NULL_VOID(frameNode);
190 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, WidthAuto, true, frameNode);
191 ViewAbstract::ClearWidthOrHeight(frameNode, true);
192 }
193
SetWidth(FrameNode * frameNode,const std::string & value)194 void TextFieldModelNG::SetWidth(FrameNode* frameNode, const std::string& value)
195 {
196 if (value == "auto") {
197 SetAutoWidth(frameNode);
198 return;
199 }
200 CHECK_NULL_VOID(frameNode);
201 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, WidthAuto, false, frameNode);
202 CalcDimension result;
203 StringUtils::StringToCalcDimensionNG(value, result, false, DimensionUnit::VP);
204 ViewAbstract::SetWidth(frameNode, NG::CalcLength(result));
205 }
206
ClearWidth(FrameNode * frameNode)207 void TextFieldModelNG::ClearWidth(FrameNode* frameNode)
208 {
209 CHECK_NULL_VOID(frameNode);
210 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, WidthAuto, false, frameNode);
211 ViewAbstract::ClearWidthOrHeight(frameNode, true);
212 }
213
SetUserUnderlineColor(UserUnderlineColor userColor)214 void TextFieldModelNG::SetUserUnderlineColor(UserUnderlineColor userColor)
215 {
216 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
217 CHECK_NULL_VOID(pattern);
218 pattern->SetUserUnderlineColor(userColor);
219 }
220
SetTypingUnderlineColor(const Color & normalColor)221 void TextFieldModelNG::SetTypingUnderlineColor(const Color& normalColor)
222 {
223 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
224 CHECK_NULL_VOID(pattern);
225 pattern->SetTypingUnderlineColor(normalColor);
226 }
227
ResetTypingUnderlineColor()228 void TextFieldModelNG::ResetTypingUnderlineColor()
229 {
230 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
231 CHECK_NULL_VOID(pattern);
232 pattern->ResetTypingUnderlineColor();
233 }
234
SetNormalUnderlineColor(const Color & normalColor)235 void TextFieldModelNG::SetNormalUnderlineColor(const Color& normalColor)
236 {
237 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
238 CHECK_NULL_VOID(pattern);
239 pattern->SetNormalUnderlineColor(normalColor);
240 }
241
ResetNormalUnderlineColor()242 void TextFieldModelNG::ResetNormalUnderlineColor()
243 {
244 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
245 CHECK_NULL_VOID(pattern);
246 pattern->ResetNormalUnderlineColor();
247 }
248
SetErrorUnderlineColor(const Color & normalColor)249 void TextFieldModelNG::SetErrorUnderlineColor(const Color& normalColor)
250 {
251 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
252 CHECK_NULL_VOID(pattern);
253 pattern->SetErrorUnderlineColor(normalColor);
254 }
255
ResetErrorUnderlineColor()256 void TextFieldModelNG::ResetErrorUnderlineColor()
257 {
258 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
259 CHECK_NULL_VOID(pattern);
260 pattern->ResetErrorUnderlineColor();
261 }
262
SetDisableUnderlineColor(const Color & normalColor)263 void TextFieldModelNG::SetDisableUnderlineColor(const Color& normalColor)
264 {
265 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
266 CHECK_NULL_VOID(pattern);
267 pattern->SetDisableUnderlineColor(normalColor);
268 }
269
ResetDisableUnderlineColor()270 void TextFieldModelNG::ResetDisableUnderlineColor()
271 {
272 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
273 CHECK_NULL_VOID(pattern);
274 pattern->ResetDisableUnderlineColor();
275 }
276
ProcessDefaultStyleAndBehaviors(const RefPtr<FrameNode> & frameNode)277 void TextFieldModelNG::ProcessDefaultStyleAndBehaviors(const RefPtr<FrameNode>& frameNode)
278 {
279 FREE_NODE_CHECK(frameNode, ProcessDefaultStyleAndBehaviors,
280 frameNode); // call ProcessDefaultStyleAndBehaviorsMultiThread() by multi thread
281 auto pipeline = frameNode->GetContext();
282 CHECK_NULL_VOID(pipeline);
283 auto themeManager = pipeline->GetThemeManager();
284 CHECK_NULL_VOID(themeManager);
285 auto textFieldTheme = themeManager->GetTheme<TextFieldTheme>(frameNode->GetThemeScopeId());
286 CHECK_NULL_VOID(textFieldTheme);
287 auto textfieldPaintProperty = frameNode->GetPaintProperty<TextFieldPaintProperty>();
288 CHECK_NULL_VOID(textfieldPaintProperty);
289 std::set<std::string> allowDropSet({ DROP_TYPE_PLAIN_TEXT, DROP_TYPE_HYPERLINK, DROP_TYPE_STYLED_STRING });
290 frameNode->SetAllowDrop(allowDropSet);
291 textfieldPaintProperty->UpdatePressBgColor(textFieldTheme->GetPressColor());
292 textfieldPaintProperty->UpdateHoverBgColor(textFieldTheme->GetHoverColor());
293 auto renderContext = frameNode->GetRenderContext();
294 renderContext->UpdateBackgroundColor(textFieldTheme->GetBgColor());
295 auto radius = textFieldTheme->GetBorderRadius();
296 textfieldPaintProperty->UpdateCursorColor(textFieldTheme->GetCursorColor());
297 BorderRadiusProperty borderRadius { radius.GetX(), radius.GetY(), radius.GetY(), radius.GetX() };
298 renderContext->UpdateBorderRadius(borderRadius);
299 auto dragDropManager = pipeline->GetDragDropManager();
300 CHECK_NULL_VOID(dragDropManager);
301 dragDropManager->AddTextFieldDragFrameNode(frameNode->GetId(), AceType::WeakClaim(AceType::RawPtr(frameNode)));
302 PaddingProperty paddings;
303 auto themePadding = textFieldTheme->GetPadding();
304 paddings.top = NG::CalcLength(themePadding.Top().ConvertToPx());
305 paddings.bottom = NG::CalcLength(themePadding.Bottom().ConvertToPx());
306 paddings.left = NG::CalcLength(themePadding.Left().ConvertToPx());
307 paddings.right = NG::CalcLength(themePadding.Right().ConvertToPx());
308 auto layoutProperty = frameNode->GetLayoutProperty<LayoutProperty>();
309 layoutProperty->UpdatePadding(paddings);
310 if (frameNode->IsFirstBuilding()) {
311 auto draggable = pipeline->GetDraggable<TextFieldTheme>();
312 frameNode->SetDraggable(draggable);
313 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
314 CHECK_NULL_VOID(gestureHub);
315 gestureHub->SetTextDraggable(true);
316 }
317 }
318
CreateTextInput(const std::optional<std::u16string> & placeholder,const std::optional<std::u16string> & value)319 RefPtr<TextFieldControllerBase> TextFieldModelNG::CreateTextInput(
320 const std::optional<std::u16string>& placeholder, const std::optional<std::u16string>& value)
321 {
322 CreateNode(placeholder, value, false);
323 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
324 CHECK_NULL_RETURN(frameNode, nullptr);
325 auto pattern = frameNode->GetPattern<TextFieldPattern>();
326 CHECK_NULL_RETURN(pattern, nullptr);
327 auto focusHub = pattern->GetFocusHub();
328 CHECK_NULL_RETURN(focusHub, nullptr);
329 focusHub->SetFocusType(FocusType::NODE);
330 focusHub->SetFocusStyleType(FocusStyleType::CUSTOM_REGION);
331 return pattern->GetTextFieldController();
332 };
333
CreateTextArea(const std::optional<std::u16string> & placeholder,const std::optional<std::u16string> & value)334 RefPtr<TextFieldControllerBase> TextFieldModelNG::CreateTextArea(
335 const std::optional<std::u16string>& placeholder, const std::optional<std::u16string>& value)
336 {
337 CreateNode(placeholder, value, true);
338 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
339 CHECK_NULL_RETURN(frameNode, nullptr);
340 auto pattern = frameNode->GetPattern<TextFieldPattern>();
341 CHECK_NULL_RETURN(pattern, nullptr);
342 return pattern->GetTextFieldController();
343 }
344
SetWidthAuto(bool isAuto)345 void TextFieldModelNG::SetWidthAuto(bool isAuto)
346 {
347 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
348 CHECK_NULL_VOID(frameNode);
349 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, WidthAuto, isAuto);
350 }
351
RequestKeyboardOnFocus(bool needToRequest)352 void TextFieldModelNG::RequestKeyboardOnFocus(bool needToRequest)
353 {
354 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
355 CHECK_NULL_VOID(frameNode);
356 auto pattern = frameNode->GetPattern<TextFieldPattern>();
357 pattern->SetNeedToRequestKeyboardOnFocus(needToRequest);
358 }
359
SetType(TextInputType value)360 void TextFieldModelNG::SetType(TextInputType value)
361 {
362 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
363 CHECK_NULL_VOID(frameNode);
364 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
365 if (layoutProperty->HasTextInputType() && layoutProperty->GetTextInputTypeValue() != value) {
366 layoutProperty->UpdateTypeChanged(true);
367 auto pattern = frameNode->GetPattern<TextFieldPattern>();
368 CHECK_NULL_VOID(pattern);
369 pattern->SetIsFilterChanged(true);
370 }
371 if (layoutProperty) {
372 layoutProperty->UpdateTextInputType(value);
373 }
374 }
375
SetPlaceholderColor(const Color & value)376 void TextFieldModelNG::SetPlaceholderColor(const Color& value)
377 {
378 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PlaceholderTextColor, value);
379 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, PlaceholderColorFlagByUser, true);
380 }
381
ResetPlaceholderColor()382 void TextFieldModelNG::ResetPlaceholderColor()
383 {
384 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
385 CHECK_NULL_VOID(frameNode);
386 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
387 CHECK_NULL_VOID(layoutProperty);
388 if (layoutProperty->GetPlaceholderFontStyle()) {
389 layoutProperty->GetPlaceholderFontStyle()->ResetTextColor();
390 }
391 ACE_RESET_PAINT_PROPERTY(TextFieldPaintProperty, PlaceholderColorFlagByUser);
392 }
393
SetContentType(const TextContentType & value)394 void TextFieldModelNG::SetContentType(const TextContentType& value)
395 {
396 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
397 CHECK_NULL_VOID(frameNode);
398 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
399 CHECK_NULL_VOID(layoutProperty);
400 if (layoutProperty->HasTextContentType() && layoutProperty->GetTextContentTypeValue() != value) {
401 layoutProperty->UpdateTextContentTypeChanged(true);
402 }
403 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextContentType, value);
404 }
405
SetPlaceholderFont(const Font & value)406 void TextFieldModelNG::SetPlaceholderFont(const Font& value)
407 {
408 if (value.fontSize.has_value()) {
409 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PlaceholderFontSize, value.fontSize.value());
410 }
411 if (value.fontStyle) {
412 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PlaceholderItalicFontStyle, value.fontStyle.value());
413 }
414 if (value.fontWeight) {
415 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PlaceholderFontWeight, value.fontWeight.value());
416 }
417 if (!value.fontFamilies.empty()) {
418 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PlaceholderFontFamily, value.fontFamilies);
419 }
420 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredPlaceholderLineHeightNeedToUpdate, true);
421 }
422
SetEnterKeyType(TextInputAction value)423 void TextFieldModelNG::SetEnterKeyType(TextInputAction value)
424 {
425 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
426 CHECK_NULL_VOID(pattern);
427 if (value == TextInputAction::UNSPECIFIED) {
428 value = pattern->IsTextArea() ? TextInputAction::NEW_LINE : TextInputAction::DONE;
429 }
430 pattern->UpdateTextInputAction(value);
431 }
432
SetCapitalizationMode(AutoCapitalizationMode value)433 void TextFieldModelNG::SetCapitalizationMode(AutoCapitalizationMode value)
434 {
435 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
436 CHECK_NULL_VOID(pattern);
437 pattern->UpdateAutoCapitalizationMode(value);
438 }
439
SetCaretColor(const Color & value)440 void TextFieldModelNG::SetCaretColor(const Color& value)
441 {
442 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, CursorColor, value);
443 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, CaretColorFlagByUser, true);
444 }
445
ResetCaretColor()446 void TextFieldModelNG::ResetCaretColor()
447 {
448 ACE_RESET_PAINT_PROPERTY(TextFieldPaintProperty, CursorColor);
449 ACE_RESET_PAINT_PROPERTY(TextFieldPaintProperty, CaretColorFlagByUser);
450 }
451
SetCaretStyle(const CaretStyle & value)452 void TextFieldModelNG::SetCaretStyle(const CaretStyle& value)
453 {
454 if (value.caretWidth.has_value()) {
455 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, CursorWidth, value.caretWidth.value());
456 }
457 }
458
SetCaretPosition(const int32_t & value)459 void TextFieldModelNG::SetCaretPosition(const int32_t& value)
460 {
461 auto frameNode = ViewStackProcessor ::GetInstance()->GetMainFrameNode();
462 CHECK_NULL_VOID(frameNode);
463 auto pattern = frameNode->GetPattern<TextFieldPattern>();
464 pattern->SetCaretPosition(value);
465 }
466
SetSelectedBackgroundColor(const Color & value)467 void TextFieldModelNG::SetSelectedBackgroundColor(const Color& value)
468 {
469 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, SelectedBackgroundColor, value);
470 }
471
SetTextAlign(TextAlign value)472 void TextFieldModelNG::SetTextAlign(TextAlign value)
473 {
474 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
475 CHECK_NULL_VOID(frameNode);
476 auto pattern = frameNode->GetPattern<TextFieldPattern>();
477 CHECK_NULL_VOID(pattern);
478 TextAlign newValue = value;
479 if (!pattern->IsTextArea() && newValue == TextAlign::JUSTIFY) {
480 newValue = TextAlign::START;
481 }
482 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
483 if (layoutProperty->GetTextAlignValue(TextAlign::START) != newValue) {
484 layoutProperty->UpdateTextAlignChanged(true);
485 }
486 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextAlign, newValue);
487 }
488
SetLineBreakStrategy(LineBreakStrategy value)489 void TextFieldModelNG::SetLineBreakStrategy(LineBreakStrategy value)
490 {
491 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, LineBreakStrategy, value);
492 }
493
SetMaxLength(uint32_t value)494 void TextFieldModelNG::SetMaxLength(uint32_t value)
495 {
496 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
497 CHECK_NULL_VOID(frameNode);
498 uint32_t preMaxLength = GetMaxLength(frameNode);
499 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MaxLength, value, frameNode);
500 if (preMaxLength != value) {
501 auto pattern = frameNode->GetPattern<TextFieldPattern>();
502 CHECK_NULL_VOID(pattern);
503 CHECK_NULL_VOID(pattern->HasFocus());
504 pattern->UpdateShowCountBorderStyle();
505 }
506 }
507
ResetMaxLength()508 void TextFieldModelNG::ResetMaxLength()
509 {
510 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
511 CHECK_NULL_VOID(frameNode);
512 auto textFieldLayoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
513 if (textFieldLayoutProperty) {
514 textFieldLayoutProperty->ResetMaxLength();
515 }
516 }
SetMaxLines(uint32_t value)517 void TextFieldModelNG::SetMaxLines(uint32_t value)
518 {
519 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MaxLines, value);
520 }
SetFontSize(const Dimension & value)521 void TextFieldModelNG::SetFontSize(const Dimension& value)
522 {
523 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, FontSize, value);
524 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredTextLineHeightNeedToUpdate, true);
525 }
SetFontWeight(FontWeight value)526 void TextFieldModelNG::SetFontWeight(FontWeight value)
527 {
528 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, FontWeight, value);
529 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredTextLineHeightNeedToUpdate, true);
530 }
SetTextColor(const Color & value)531 void TextFieldModelNG::SetTextColor(const Color& value)
532 {
533 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextColor, value);
534 ACE_UPDATE_RENDER_CONTEXT(ForegroundColor, value);
535 ACE_RESET_RENDER_CONTEXT(RenderContext, ForegroundColorStrategy);
536 ACE_UPDATE_RENDER_CONTEXT(ForegroundColorFlag, true);
537 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, TextColorFlagByUser, value);
538 }
ResetTextColor()539 void TextFieldModelNG::ResetTextColor()
540 {
541 ACE_RESET_LAYOUT_PROPERTY_WITH_FLAG(TextFieldLayoutProperty, TextColor, PROPERTY_UPDATE_MEASURE_SELF);
542 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(TextFieldPaintProperty, TextColorFlagByUser, PROPERTY_UPDATE_MEASURE_SELF);
543 ACE_RESET_RENDER_CONTEXT(RenderContext, ForegroundColor);
544 ACE_RESET_RENDER_CONTEXT(RenderContext, ForegroundColorStrategy);
545 ACE_RESET_RENDER_CONTEXT(RenderContext, ForegroundColorFlag);
546 }
SetWordBreak(Ace::WordBreak value)547 void TextFieldModelNG::SetWordBreak(Ace::WordBreak value)
548 {
549 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, WordBreak, value);
550 }
SetFontStyle(Ace::FontStyle value)551 void TextFieldModelNG::SetFontStyle(Ace::FontStyle value)
552 {
553 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ItalicFontStyle, value);
554 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredTextLineHeightNeedToUpdate, true);
555 }
SetFontFamily(const std::vector<std::string> & value)556 void TextFieldModelNG::SetFontFamily(const std::vector<std::string>& value)
557 {
558 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, FontFamily, value);
559 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredTextLineHeightNeedToUpdate, true);
560 }
561
SetMinFontScale(const float value)562 void TextFieldModelNG::SetMinFontScale(const float value)
563 {
564 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MinFontScale, value);
565 }
566
SetMaxFontScale(const float value)567 void TextFieldModelNG::SetMaxFontScale(const float value)
568 {
569 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MaxFontScale, value);
570 }
571
SetMinFontScale(FrameNode * frameNode,const float value)572 void TextFieldModelNG::SetMinFontScale(FrameNode* frameNode, const float value)
573 {
574 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MinFontScale, value, frameNode);
575 }
576
SetMaxFontScale(FrameNode * frameNode,const float value)577 void TextFieldModelNG::SetMaxFontScale(FrameNode* frameNode, const float value)
578 {
579 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MaxFontScale, value, frameNode);
580 }
581
SetInputFilter(const std::string & value,const std::function<void (const std::u16string &)> && func)582 void TextFieldModelNG::SetInputFilter(const std::string& value,
583 const std::function<void(const std::u16string&)>&& func)
584 {
585 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, InputFilter, value);
586 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
587 CHECK_NULL_VOID(eventHub);
588 eventHub->SetOnInputFilterError(std::move(func));
589 }
590
SetInputStyle(InputStyle value)591 void TextFieldModelNG::SetInputStyle(InputStyle value)
592 {
593 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, InputStyle, value);
594 }
595
SetShowPasswordIcon(bool value)596 void TextFieldModelNG::SetShowPasswordIcon(bool value)
597 {
598 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
599 CHECK_NULL_VOID(frameNode);
600 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
601 CHECK_NULL_VOID(layoutProperty);
602 auto pattern = frameNode->GetPattern<TextFieldPattern>();
603 CHECK_NULL_VOID(pattern);
604 if (pattern->IsInPasswordMode() && layoutProperty->GetShowPasswordIconValue(true) != true) {
605 pattern->SetTextChangedAtCreation(true);
606 }
607 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowPasswordIcon, value);
608 }
609
SetShowPasswordText(bool value)610 void TextFieldModelNG::SetShowPasswordText(bool value)
611 {
612 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
613 CHECK_NULL_VOID(frameNode);
614 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
615 CHECK_NULL_VOID(layoutProperty);
616 auto pattern = frameNode->GetPattern<TextFieldPattern>();
617 CHECK_NULL_VOID(pattern);
618 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowPasswordText, value);
619 }
620
SetOnEditChanged(std::function<void (bool)> && func)621 void TextFieldModelNG::SetOnEditChanged(std::function<void(bool)>&& func)
622 {
623 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
624 CHECK_NULL_VOID(eventHub);
625 eventHub->SetOnEditChanged(std::move(func));
626 }
627
SetOnSubmit(std::function<void (int32_t,NG::TextFieldCommonEvent &)> && func)628 void TextFieldModelNG::SetOnSubmit(std::function<void(int32_t, NG::TextFieldCommonEvent&)>&& func)
629 {
630 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
631 CHECK_NULL_VOID(eventHub);
632 eventHub->SetOnSubmit(std::move(func));
633 }
634
SetOnChange(std::function<void (const ChangeValueInfo &)> && func)635 void TextFieldModelNG::SetOnChange(std::function<void(const ChangeValueInfo&)>&& func)
636 {
637 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
638 CHECK_NULL_VOID(eventHub);
639 eventHub->SetOnChange(std::move(func));
640 }
641
SetOnTextSelectionChange(std::function<void (int32_t,int32_t)> && func)642 void TextFieldModelNG::SetOnTextSelectionChange(std::function<void(int32_t, int32_t)>&& func)
643 {
644 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
645 CHECK_NULL_VOID(eventHub);
646 eventHub->SetOnSelectionChange(std::move(func));
647 }
648
SetOnTextSelectionChange(FrameNode * frameNode,std::function<void (int32_t,int32_t)> && func)649 void TextFieldModelNG::SetOnTextSelectionChange(FrameNode* frameNode, std::function<void(int32_t, int32_t)>&& func)
650 {
651 CHECK_NULL_VOID(frameNode);
652 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
653 CHECK_NULL_VOID(eventHub);
654 eventHub->SetOnSelectionChange(std::move(func));
655 }
656
SetOnSecurityStateChange(std::function<void (bool)> && func)657 void TextFieldModelNG::SetOnSecurityStateChange(std::function<void(bool)>&& func)
658 {
659 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
660 CHECK_NULL_VOID(eventHub);
661 eventHub->SetOnSecurityStateChange(std::move(func));
662 }
663
SetOnContentScroll(std::function<void (float,float)> && func)664 void TextFieldModelNG::SetOnContentScroll(std::function<void(float, float)>&& func)
665 {
666 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
667 CHECK_NULL_VOID(eventHub);
668 eventHub->SetOnScrollChangeEvent(std::move(func));
669 }
670
SetOnCopy(std::function<void (const std::u16string &)> && func)671 void TextFieldModelNG::SetOnCopy(std::function<void(const std::u16string&)>&& func)
672 {
673 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
674 CHECK_NULL_VOID(eventHub);
675 eventHub->SetOnCopy(std::move(func));
676 }
677
SetOnCut(std::function<void (const std::u16string &)> && func)678 void TextFieldModelNG::SetOnCut(std::function<void(const std::u16string&)>&& func)
679 {
680 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
681 CHECK_NULL_VOID(eventHub);
682 eventHub->SetOnCut(std::move(func));
683 }
684
SetOnPaste(std::function<void (const std::u16string &)> && func)685 void TextFieldModelNG::SetOnPaste(std::function<void(const std::u16string&)>&& func)
686 {
687 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
688 CHECK_NULL_VOID(eventHub);
689 eventHub->SetOnPaste(std::move(func));
690 }
691
SetOnPasteWithEvent(std::function<void (const std::u16string &,NG::TextCommonEvent &)> && func)692 void TextFieldModelNG::SetOnPasteWithEvent(std::function<void(const std::u16string&, NG::TextCommonEvent&)>&& func)
693 {
694 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
695 CHECK_NULL_VOID(eventHub);
696 eventHub->SetOnPasteWithEvent(std::move(func));
697 }
698
SetCopyOption(CopyOptions copyOption)699 void TextFieldModelNG::SetCopyOption(CopyOptions copyOption)
700 {
701 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, CopyOptions, copyOption);
702 }
703
AddDragFrameNodeToManager() const704 void TextFieldModelNG::AddDragFrameNodeToManager() const
705 {
706 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
707 CHECK_NULL_VOID(frameNode);
708 auto pipeline = frameNode->GetContext();
709 CHECK_NULL_VOID(pipeline);
710 auto dragDropManager = pipeline->GetDragDropManager();
711 CHECK_NULL_VOID(dragDropManager);
712 dragDropManager->AddTextFieldDragFrameNode(frameNode->GetId(), AceType::WeakClaim(frameNode));
713 }
714
SetForegroundColor(const Color & value)715 void TextFieldModelNG::SetForegroundColor(const Color& value)
716 {
717 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextColor, value);
718 }
719
SetPasswordIcon(const PasswordIcon & passwordIcon)720 void TextFieldModelNG::SetPasswordIcon(const PasswordIcon& passwordIcon)
721 {
722 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
723 CHECK_NULL_VOID(frameNode);
724 auto pattern = frameNode->GetPattern<TextFieldPattern>();
725 CHECK_NULL_VOID(pattern);
726 // when not call SetPasswordIcon() and api >= 13, use symbol format image, else use image format.
727 pattern->SetIsPasswordSymbol(false);
728 if (passwordIcon.showResult != "") {
729 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowPasswordSourceInfo,
730 ImageSourceInfo(passwordIcon.showResult, passwordIcon.showBundleName, passwordIcon.showModuleName));
731 } else {
732 ImageSourceInfo showSystemSourceInfo;
733 showSystemSourceInfo.SetResourceId(InternalResource::ResourceId::SHOW_PASSWORD_SVG);
734 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowPasswordSourceInfo, showSystemSourceInfo);
735 }
736 if (passwordIcon.hideResult != "") {
737 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, HidePasswordSourceInfo,
738 ImageSourceInfo(passwordIcon.hideResult, passwordIcon.hideBundleName, passwordIcon.hideModuleName));
739 } else {
740 ImageSourceInfo hideSystemSourceInfo;
741 hideSystemSourceInfo.SetResourceId(InternalResource::ResourceId::HIDE_PASSWORD_SVG);
742 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, HidePasswordSourceInfo, hideSystemSourceInfo);
743 }
744 }
745
SetShowUnit(std::function<void ()> && unitFunction)746 void TextFieldModelNG::SetShowUnit(std::function<void()>&& unitFunction)
747 {
748 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
749 CHECK_NULL_VOID(frameNode);
750 auto pattern = frameNode->GetPattern<TextFieldPattern>();
751 CHECK_NULL_VOID(pattern);
752 RefPtr<NG::UINode> unitNode;
753 if (unitFunction) {
754 NG::ScopedViewStackProcessor builderViewStackProcessor;
755 unitFunction();
756 unitNode = NG::ViewStackProcessor::GetInstance()->Finish();
757 }
758 pattern->SetUnitNode(unitNode);
759 }
760
SetShowError(const std::u16string & errorText,bool visible)761 void TextFieldModelNG::SetShowError(const std::u16string& errorText, bool visible)
762 {
763 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ErrorText, errorText);
764 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowErrorText, visible);
765 }
766
SetShowCounter(bool value)767 void TextFieldModelNG::SetShowCounter(bool value)
768 {
769 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowCounter, value);
770 }
771
SetCounterType(int32_t value)772 void TextFieldModelNG::SetCounterType(int32_t value)
773 {
774 auto frameNode = ViewStackProcessor ::GetInstance()->GetMainFrameNode();
775 CHECK_NULL_VOID(frameNode);
776 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
777 CHECK_NULL_VOID(layoutProperty);
778 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, SetCounter, value);
779 }
780
SetShowCounterBorder(bool value)781 void TextFieldModelNG::SetShowCounterBorder(bool value)
782 {
783 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
784 CHECK_NULL_VOID(frameNode);
785 auto pattern = frameNode->GetPattern<TextFieldPattern>();
786 CHECK_NULL_VOID(pattern);
787 pattern->SetCounterState(false);
788 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowHighlightBorder, value);
789 }
790
SetShowCounterBorder(FrameNode * frameNode,bool value)791 void TextFieldModelNG::SetShowCounterBorder(FrameNode* frameNode, bool value)
792 {
793 CHECK_NULL_VOID(frameNode);
794 auto pattern = frameNode->GetPattern<TextFieldPattern>();
795 CHECK_NULL_VOID(pattern);
796 pattern->SetCounterState(false);
797 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowHighlightBorder, value, frameNode);
798 }
799
SetBarState(OHOS::Ace::DisplayMode value)800 void TextFieldModelNG::SetBarState(OHOS::Ace::DisplayMode value)
801 {
802 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, DisplayMode, value);
803 }
804
SetMaxViewLines(uint32_t value)805 void TextFieldModelNG::SetMaxViewLines(uint32_t value)
806 {
807 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MaxViewLines, value);
808 }
809
SetNormalMaxViewLines(uint32_t value)810 void TextFieldModelNG::SetNormalMaxViewLines(uint32_t value)
811 {
812 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, NormalMaxViewLines, value);
813 }
814
SetMinLines(uint32_t value)815 void TextFieldModelNG::SetMinLines(uint32_t value)
816 {
817 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MinLines, value);
818 }
819
SetOverflowMode(OverflowMode value)820 void TextFieldModelNG::SetOverflowMode(OverflowMode value)
821 {
822 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, OverflowMode, value);
823 }
824
SetBackgroundColor(const Color & color,bool tmp)825 void TextFieldModelNG::SetBackgroundColor(const Color& color, bool tmp)
826 {
827 Color backgroundColor = color;
828 if (tmp) {
829 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
830 CHECK_NULL_VOID(frameNode);
831 auto pipeline = frameNode->GetContextRefPtr();
832 CHECK_NULL_VOID(pipeline);
833 auto themeManager = pipeline->GetThemeManager();
834 CHECK_NULL_VOID(themeManager);
835 auto theme = themeManager->GetTheme<TextFieldTheme>(frameNode->GetThemeScopeId());
836 CHECK_NULL_VOID(theme);
837 backgroundColor = theme->GetBgColor();
838 }
839 NG::ViewAbstract::SetBackgroundColor(backgroundColor);
840 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, BackgroundColor, backgroundColor);
841 }
842
ResetBackgroundColor()843 void TextFieldModelNG::ResetBackgroundColor()
844 {
845 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(TextFieldPaintProperty, BackgroundColor, PROPERTY_UPDATE_RENDER);
846 }
847
SetBackgroundColor(FrameNode * frameNode,const Color & color)848 void TextFieldModelNG::SetBackgroundColor(FrameNode* frameNode, const Color& color)
849 {
850 CHECK_NULL_VOID(frameNode);
851 NG::ViewAbstract::SetBackgroundColor(frameNode, color);
852 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, BackgroundColor, color, frameNode);
853 }
854
ResetBackgroundColor(FrameNode * frameNode)855 void TextFieldModelNG::ResetBackgroundColor(FrameNode* frameNode)
856 {
857 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(TextFieldPaintProperty, BackgroundColor, PROPERTY_UPDATE_RENDER, frameNode);
858 }
859
SetHeight(const Dimension & value)860 void TextFieldModelNG::SetHeight(const Dimension& value) {}
861
SetMargin()862 void TextFieldModelNG::SetMargin()
863 {
864 auto frameNode = ViewStackProcessor ::GetInstance()->GetMainFrameNode();
865 CHECK_NULL_VOID(frameNode);
866 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
867 CHECK_NULL_VOID(layoutProperty);
868 const auto& margin = layoutProperty->GetMarginProperty();
869 CHECK_NULL_VOID(margin);
870 bool isRTL = layoutProperty->GetNonAutoLayoutDirection() == TextDirection::RTL;
871
872 MarginProperty userMargin;
873 userMargin.top = margin->top;
874 userMargin.bottom = margin->bottom;
875 userMargin.left = margin->left.has_value() ? margin->left :
876 (isRTL ? margin->end : margin->start);
877 userMargin.right = margin->right.has_value() ? margin->right :
878 (isRTL ? margin->start : margin->end);
879 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, MarginByUser, userMargin);
880 }
881
SetPadding(const NG::PaddingProperty & newPadding,Edge oldPadding,bool tmp,bool hasRegist)882 void TextFieldModelNG::SetPadding(const NG::PaddingProperty& newPadding, Edge oldPadding, bool tmp, bool hasRegist)
883 {
884 if (tmp) {
885 SetDefaultPadding();
886 return;
887 }
888 if (!hasRegist) {
889 NG::ViewAbstract::SetPadding(newPadding);
890 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, PaddingByUser, newPadding);
891 }
892 }
893
SetDefaultPadding()894 void TextFieldModelNG::SetDefaultPadding()
895 {
896 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
897 CHECK_NULL_VOID(frameNode);
898 auto pattern = frameNode->GetPattern<TextFieldPattern>();
899 CHECK_NULL_VOID(pattern);
900 auto theme = pattern->GetTheme();
901 CHECK_NULL_VOID(theme);
902 auto themePadding = theme->GetPadding();
903 PaddingProperty paddings;
904 paddings.top = NG::CalcLength(themePadding.Top().ConvertToPx());
905 paddings.bottom = NG::CalcLength(themePadding.Bottom().ConvertToPx());
906 paddings.left = NG::CalcLength(themePadding.Left().ConvertToPx());
907 paddings.right = NG::CalcLength(themePadding.Right().ConvertToPx());
908 ViewAbstract::SetPadding(paddings);
909 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, PaddingByUser, paddings);
910 }
911
SetHoverEffect(HoverEffectType hoverEffect)912 void TextFieldModelNG::SetHoverEffect(HoverEffectType hoverEffect)
913 {
914 NG::ViewAbstract::SetHoverEffect(hoverEffect);
915 }
916
SetOnWillChangeEvent(std::function<bool (const ChangeValueInfo &)> && func)917 void TextFieldModelNG::SetOnWillChangeEvent(std::function<bool(const ChangeValueInfo&)>&& func)
918 {
919 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
920 CHECK_NULL_VOID(eventHub);
921 eventHub->SetOnWillChangeEvent(std::move(func));
922 }
923
SetOnChangeEvent(std::function<void (const std::u16string &)> && func)924 void TextFieldModelNG::SetOnChangeEvent(std::function<void(const std::u16string&)>&& func)
925 {
926 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
927 CHECK_NULL_VOID(eventHub);
928 eventHub->SetOnChangeEvent(std::move(func));
929 }
930
SetSelectionMenuHidden(bool selectionMenuHidden)931 void TextFieldModelNG::SetSelectionMenuHidden(bool selectionMenuHidden)
932 {
933 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, SelectionMenuHidden, selectionMenuHidden);
934 }
935
SetCustomKeyboard(const std::function<void ()> && buildFunc,bool supportAvoidance)936 void TextFieldModelNG::SetCustomKeyboard(const std::function<void()>&& buildFunc, bool supportAvoidance)
937 {
938 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
939 CHECK_NULL_VOID(frameNode);
940 auto pattern = frameNode->GetPattern<TextFieldPattern>();
941 if (pattern) {
942 pattern->SetCustomKeyboardOption(supportAvoidance);
943 pattern->SetCustomKeyboard(std::move(buildFunc));
944 }
945 }
946
SetPasswordRules(const std::string & passwordRules)947 void TextFieldModelNG::SetPasswordRules(const std::string& passwordRules)
948 {
949 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PasswordRules, passwordRules);
950 }
951
SetEnableAutoFill(bool enableAutoFill)952 void TextFieldModelNG::SetEnableAutoFill(bool enableAutoFill)
953 {
954 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, EnableAutoFill, enableAutoFill);
955 }
956
SetEnableAutoFillAnimation(bool enableAutoFillAnimation)957 void TextFieldModelNG::SetEnableAutoFillAnimation(bool enableAutoFillAnimation)
958 {
959 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, EnableAutoFillAnimation, enableAutoFillAnimation);
960 }
961
SetAdaptMinFontSize(const Dimension & value)962 void TextFieldModelNG::SetAdaptMinFontSize(const Dimension& value)
963 {
964 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, AdaptMinFontSize, value);
965 }
966
SetAdaptMaxFontSize(const Dimension & value)967 void TextFieldModelNG::SetAdaptMaxFontSize(const Dimension& value)
968 {
969 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, AdaptMaxFontSize, value);
970 }
971
SetHeightAdaptivePolicy(TextHeightAdaptivePolicy value)972 void TextFieldModelNG::SetHeightAdaptivePolicy(TextHeightAdaptivePolicy value)
973 {
974 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, HeightAdaptivePolicy, value);
975 }
976
SetCleanNodeStyle(CleanNodeStyle cleanNodeStyle)977 void TextFieldModelNG::SetCleanNodeStyle(CleanNodeStyle cleanNodeStyle)
978 {
979 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, CleanNodeStyle, cleanNodeStyle);
980 }
981
SetCancelIconSize(const CalcDimension & iconSize)982 void TextFieldModelNG::SetCancelIconSize(const CalcDimension& iconSize)
983 {
984 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IconSize, iconSize);
985 }
SetAdaptMinFontSize(FrameNode * frameNode,const Dimension & value)986 void TextFieldModelNG::SetAdaptMinFontSize(FrameNode* frameNode, const Dimension& value)
987 {
988 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, AdaptMinFontSize, value, frameNode);
989 }
990
SetAdaptMaxFontSize(FrameNode * frameNode,const Dimension & value)991 void TextFieldModelNG::SetAdaptMaxFontSize(FrameNode* frameNode, const Dimension& value)
992 {
993 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, AdaptMaxFontSize, value, frameNode);
994 }
995
SetHeightAdaptivePolicy(FrameNode * frameNode,TextHeightAdaptivePolicy value)996 void TextFieldModelNG::SetHeightAdaptivePolicy(FrameNode* frameNode, TextHeightAdaptivePolicy value)
997 {
998 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, HeightAdaptivePolicy, value, frameNode);
999 }
1000
SetCanacelIconSrc(const std::string & iconSrc,const std::string & bundleName,const std::string & moduleName)1001 void TextFieldModelNG::SetCanacelIconSrc(
1002 const std::string& iconSrc, const std::string& bundleName, const std::string& moduleName)
1003 {
1004 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IconSrc, iconSrc);
1005 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, BundleName, bundleName);
1006 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ModuleName, moduleName);
1007 }
1008
SetCancelIconColor(const Color & iconColor)1009 void TextFieldModelNG::SetCancelIconColor(const Color& iconColor)
1010 {
1011 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IconColor, iconColor);
1012 }
1013
SetCancelButtonSymbol(bool isShowSymbol)1014 void TextFieldModelNG::SetCancelButtonSymbol(bool isShowSymbol)
1015 {
1016 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IsShowSymbol, isShowSymbol);
1017 }
1018
SetCancelSymbolIcon(const std::function<void (WeakPtr<NG::FrameNode>)> & iconSymbol)1019 void TextFieldModelNG::SetCancelSymbolIcon(const std::function<void(WeakPtr<NG::FrameNode>)>& iconSymbol)
1020 {
1021 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1022 CHECK_NULL_VOID(frameNode);
1023 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1024 CHECK_NULL_VOID(layoutProperty);
1025 layoutProperty->SetCancelIconSymbol(iconSymbol);
1026 }
1027
SetIsShowCancelButton(bool isShowCancelButton)1028 void TextFieldModelNG::SetIsShowCancelButton(bool isShowCancelButton)
1029 {
1030 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IsShowCancelButton, isShowCancelButton);
1031 }
1032
SetSelectAllValue(bool isSelectAllValue)1033 void TextFieldModelNG::SetSelectAllValue(bool isSelectAllValue)
1034 {
1035 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, SelectAllValue, isSelectAllValue);
1036 }
1037
SetKeyboardAppearance(KeyboardAppearance value)1038 void TextFieldModelNG::SetKeyboardAppearance(KeyboardAppearance value)
1039 {
1040 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1041 CHECK_NULL_VOID(frameNode);
1042 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1043 CHECK_NULL_VOID(pattern);
1044 pattern->SetKeyboardAppearance(value);
1045 }
1046
SetLetterSpacing(const Dimension & value)1047 void TextFieldModelNG::SetLetterSpacing(const Dimension& value)
1048 {
1049 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, LetterSpacing, value);
1050 }
1051
GetLetterSpacing(FrameNode * frameNode)1052 Dimension TextFieldModelNG::GetLetterSpacing(FrameNode* frameNode)
1053 {
1054 Dimension value;
1055 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1056 TextFieldLayoutProperty, LetterSpacing, value, frameNode, value);
1057 return value;
1058 }
1059
SetLineHeight(const Dimension & value)1060 void TextFieldModelNG::SetLineHeight(const Dimension& value)
1061 {
1062 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, LineHeight, value);
1063 }
1064
SetHalfLeading(bool value)1065 void TextFieldModelNG::SetHalfLeading(bool value)
1066 {
1067 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, HalfLeading, value);
1068 }
1069
SetLineSpacing(const Dimension & value)1070 void TextFieldModelNG::SetLineSpacing(const Dimension& value)
1071 {
1072 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, LineSpacing, value);
1073 }
1074
SetIsOnlyBetweenLines(bool isOnlyBetweenLines)1075 void TextFieldModelNG::SetIsOnlyBetweenLines(bool isOnlyBetweenLines)
1076 {
1077 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IsOnlyBetweenLines, isOnlyBetweenLines);
1078 }
1079
SetTextDecoration(Ace::TextDecoration value)1080 void TextFieldModelNG::SetTextDecoration(Ace::TextDecoration value)
1081 {
1082 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextDecoration, {value});
1083 }
1084
SetTextDecorationColor(const Color & value)1085 void TextFieldModelNG::SetTextDecorationColor(const Color& value)
1086 {
1087 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextDecorationColor, value);
1088 }
1089
SetTextDecorationStyle(Ace::TextDecorationStyle value)1090 void TextFieldModelNG::SetTextDecorationStyle(Ace::TextDecorationStyle value)
1091 {
1092 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextDecorationStyle, value);
1093 }
1094
SetBackBorderRadius()1095 void TextFieldModelNG::SetBackBorderRadius()
1096 {
1097 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1098 CHECK_NULL_VOID(frameNode);
1099 auto renderContext = frameNode->GetRenderContext();
1100 CHECK_NULL_VOID(renderContext);
1101 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1102 CHECK_NULL_VOID(layoutProperty);
1103 CHECK_NULL_VOID(renderContext->GetBorderRadius());
1104
1105 bool isRTL = layoutProperty->GetNonAutoLayoutDirection() == TextDirection::RTL;
1106 auto optRadius = renderContext->GetBorderRadius();
1107 CHECK_NULL_VOID(optRadius);
1108 auto radius = optRadius.value();
1109
1110 radius.radiusTopLeft = radius.radiusTopLeft.has_value() ? radius.radiusTopLeft :
1111 (isRTL ? radius.radiusTopEnd : radius.radiusTopStart);
1112 radius.radiusTopRight = radius.radiusTopRight.has_value() ? radius.radiusTopRight :
1113 (isRTL ? radius.radiusTopStart : radius.radiusTopEnd);
1114 radius.radiusBottomLeft = radius.radiusBottomLeft.has_value() ? radius.radiusBottomLeft :
1115 (isRTL ? radius.radiusBottomEnd : radius.radiusBottomStart);
1116 radius.radiusBottomRight = radius.radiusBottomRight.has_value() ? radius.radiusBottomRight :
1117 (isRTL ? radius.radiusBottomStart : radius.radiusBottomEnd);
1118
1119 ACE_UPDATE_PAINT_PROPERTY(TextFieldPaintProperty, BorderRadiusFlagByUser, radius);
1120 }
1121
SetBackBorder()1122 void TextFieldModelNG::SetBackBorder()
1123 {
1124 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1125 CHECK_NULL_VOID(frameNode);
1126 auto renderContext = frameNode->GetRenderContext();
1127 CHECK_NULL_VOID(renderContext);
1128 if (renderContext->HasBorderRadius()) {
1129 SetBackBorderRadius();
1130 }
1131 if (renderContext->HasBorderColor()) {
1132 ACE_UPDATE_PAINT_PROPERTY(
1133 TextFieldPaintProperty, BorderColorFlagByUser, renderContext->GetBorderColor().value());
1134 }
1135 if (renderContext->HasBorderWidth()) {
1136 ACE_UPDATE_PAINT_PROPERTY(
1137 TextFieldPaintProperty, BorderWidthFlagByUser, renderContext->GetBorderWidth().value());
1138 }
1139 if (renderContext->HasBorderStyle()) {
1140 ACE_UPDATE_PAINT_PROPERTY(
1141 TextFieldPaintProperty, BorderStyleFlagByUser, renderContext->GetBorderStyle().value());
1142 }
1143 }
1144
SetTextOverflow(Ace::TextOverflow value)1145 void TextFieldModelNG::SetTextOverflow(Ace::TextOverflow value)
1146 {
1147 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextOverflow, value);
1148 }
1149
SetTextIndent(const Dimension & value)1150 void TextFieldModelNG::SetTextIndent(const Dimension& value)
1151 {
1152 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextIndent, value);
1153 }
1154
SetTextOverflow(FrameNode * frameNode,Ace::TextOverflow value)1155 void TextFieldModelNG::SetTextOverflow(FrameNode* frameNode, Ace::TextOverflow value)
1156 {
1157 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextOverflow, value, frameNode);
1158 }
1159
SetTextIndent(FrameNode * frameNode,const Dimension & value)1160 void TextFieldModelNG::SetTextIndent(FrameNode* frameNode, const Dimension& value)
1161 {
1162 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextIndent, value, frameNode);
1163 }
1164
SetInputStyle(FrameNode * frameNode,InputStyle value)1165 void TextFieldModelNG::SetInputStyle(FrameNode* frameNode, InputStyle value)
1166 {
1167 CHECK_NULL_VOID(frameNode);
1168 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, InputStyle, value, frameNode);
1169 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1170 if (pattern->GetTextInputFlag() && value == InputStyle::DEFAULT) {
1171 auto textFieldLayoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1172 CHECK_NULL_VOID(textFieldLayoutProperty);
1173 textFieldLayoutProperty->UpdateMaxLines(1);
1174 textFieldLayoutProperty->UpdatePlaceholderMaxLines(1);
1175 }
1176 }
1177
RequestKeyboardOnFocus(FrameNode * frameNode,bool needToRequest)1178 void TextFieldModelNG::RequestKeyboardOnFocus(FrameNode* frameNode, bool needToRequest)
1179 {
1180 CHECK_NULL_VOID(frameNode);
1181 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1182 pattern->SetNeedToRequestKeyboardOnFocus(needToRequest);
1183 }
1184
SetBarState(FrameNode * frameNode,OHOS::Ace::DisplayMode value)1185 void TextFieldModelNG::SetBarState(FrameNode* frameNode, OHOS::Ace::DisplayMode value)
1186 {
1187 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, DisplayMode, value, frameNode);
1188 }
1189
SetPasswordIcon(FrameNode * frameNode,const PasswordIcon & passwordIcon)1190 void TextFieldModelNG::SetPasswordIcon(FrameNode* frameNode, const PasswordIcon& passwordIcon)
1191 {
1192 CHECK_NULL_VOID(frameNode);
1193 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1194 CHECK_NULL_VOID(pattern);
1195 // when not call SetPasswordIcon() and api >= 13, use symbol format image, else use image format.
1196 pattern->SetIsPasswordSymbol(false);
1197 if (passwordIcon.showResult != "") {
1198 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowPasswordSourceInfo,
1199 ImageSourceInfo(passwordIcon.showResult,
1200 passwordIcon.showBundleName, passwordIcon.showModuleName), frameNode);
1201 } else {
1202 ImageSourceInfo showSystemSourceInfo;
1203 showSystemSourceInfo.SetResourceId(InternalResource::ResourceId::SHOW_PASSWORD_SVG);
1204 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowPasswordSourceInfo,
1205 showSystemSourceInfo, frameNode);
1206 }
1207 if (passwordIcon.hideResult != "") {
1208 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, HidePasswordSourceInfo,
1209 ImageSourceInfo(passwordIcon.hideResult,
1210 passwordIcon.hideBundleName, passwordIcon.hideModuleName), frameNode);
1211 } else {
1212 ImageSourceInfo hideSystemSourceInfo;
1213 hideSystemSourceInfo.SetResourceId(InternalResource::ResourceId::HIDE_PASSWORD_SVG);
1214 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, HidePasswordSourceInfo,
1215 hideSystemSourceInfo, frameNode);
1216 }
1217 }
1218
SetSelectedBackgroundColor(FrameNode * frameNode,const Color & value)1219 void TextFieldModelNG::SetSelectedBackgroundColor(FrameNode* frameNode, const Color& value)
1220 {
1221 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, SelectedBackgroundColor, value, frameNode);
1222 }
1223
SetMaxViewLines(FrameNode * frameNode,uint32_t value)1224 void TextFieldModelNG::SetMaxViewLines(FrameNode* frameNode, uint32_t value)
1225 {
1226 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MaxViewLines, value, frameNode);
1227 }
1228
SetNormalMaxViewLines(FrameNode * frameNode,uint32_t value)1229 void TextFieldModelNG::SetNormalMaxViewLines(FrameNode* frameNode, uint32_t value)
1230 {
1231 auto normalMaxViewLines = value <= 0 ? Infinity<uint32_t>() : value;
1232 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, NormalMaxViewLines, normalMaxViewLines, frameNode);
1233 }
1234
SetMinLines(FrameNode * frameNode,uint32_t value)1235 void TextFieldModelNG::SetMinLines(FrameNode* frameNode, uint32_t value)
1236 {
1237 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MinLines, value, frameNode);
1238 }
1239
SetOverflowMode(FrameNode * frameNode,OverflowMode value)1240 void TextFieldModelNG::SetOverflowMode(FrameNode* frameNode, OverflowMode value)
1241 {
1242 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, OverflowMode, value, frameNode);
1243 }
1244
SetType(FrameNode * frameNode,TextInputType value)1245 void TextFieldModelNG::SetType(FrameNode* frameNode, TextInputType value)
1246 {
1247 CHECK_NULL_VOID(frameNode);
1248 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1249 if (layoutProperty->HasTextInputType() && layoutProperty->GetTextInputTypeValue() != value) {
1250 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1251 CHECK_NULL_VOID(pattern);
1252 pattern->SetIsFilterChanged(true);
1253 layoutProperty->UpdateTypeChanged(true);
1254 }
1255 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextInputType, value, frameNode);
1256 }
1257
SetContentType(const FrameNode * frameNode,const TextContentType & value)1258 void TextFieldModelNG::SetContentType(const FrameNode* frameNode, const TextContentType& value)
1259 {
1260 CHECK_NULL_VOID(frameNode);
1261 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1262 CHECK_NULL_VOID(layoutProperty);
1263 if (layoutProperty->HasTextContentType() && layoutProperty->GetTextContentTypeValue() != value) {
1264 layoutProperty->UpdateTextContentTypeChanged(true);
1265 }
1266 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextContentType, value, frameNode);
1267 }
1268
SetCopyOption(FrameNode * frameNode,CopyOptions copyOption)1269 void TextFieldModelNG::SetCopyOption(FrameNode* frameNode, CopyOptions copyOption)
1270 {
1271 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, CopyOptions, copyOption, frameNode);
1272 }
1273
SetShowPasswordIcon(FrameNode * frameNode,bool value)1274 void TextFieldModelNG::SetShowPasswordIcon(FrameNode* frameNode, bool value)
1275 {
1276 CHECK_NULL_VOID(frameNode);
1277 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1278 CHECK_NULL_VOID(layoutProperty);
1279 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1280 CHECK_NULL_VOID(pattern);
1281 if (pattern->IsInPasswordMode() && layoutProperty-> GetShowPasswordIconValue(true) != value) {
1282 pattern->SetTextChangedAtCreation(true);
1283 }
1284 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowPasswordIcon, value, frameNode);
1285 }
1286
SetShowPassword(FrameNode * frameNode,bool value)1287 void TextFieldModelNG::SetShowPassword(FrameNode* frameNode, bool value)
1288 {
1289 CHECK_NULL_VOID(frameNode);
1290 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1291 CHECK_NULL_VOID(layoutProperty);
1292 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1293 CHECK_NULL_VOID(pattern);
1294 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowPasswordText, value, frameNode);
1295 }
1296
SetTextAlign(FrameNode * frameNode,TextAlign value)1297 void TextFieldModelNG::SetTextAlign(FrameNode* frameNode, TextAlign value)
1298 {
1299 CHECK_NULL_VOID(frameNode);
1300 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1301 CHECK_NULL_VOID(pattern);
1302 TextAlign newValue = value;
1303 if (!pattern->IsTextArea() && newValue == TextAlign::JUSTIFY) {
1304 newValue = TextAlign::START;
1305 }
1306 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1307 if (layoutProperty->GetTextAlignValue(TextAlign::START) != newValue) {
1308 layoutProperty->UpdateTextAlignChanged(true);
1309 }
1310 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextAlign, newValue, frameNode);
1311 }
1312
SetTextColor(FrameNode * frameNode,const Color & value)1313 void TextFieldModelNG::SetTextColor(FrameNode* frameNode, const Color& value)
1314 {
1315 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextColor, value, frameNode);
1316 ACE_UPDATE_NODE_RENDER_CONTEXT(ForegroundColor, value, frameNode);
1317 ACE_RESET_NODE_RENDER_CONTEXT(RenderContext, ForegroundColorStrategy, frameNode);
1318 ACE_UPDATE_NODE_RENDER_CONTEXT(ForegroundColorFlag, true, frameNode);
1319 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, TextColorFlagByUser, value, frameNode);
1320 }
1321
ResetTextColor(FrameNode * frameNode)1322 void TextFieldModelNG::ResetTextColor(FrameNode* frameNode)
1323 {
1324 ACE_RESET_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextColor, frameNode);
1325 ACE_RESET_NODE_RENDER_CONTEXT(RenderContext, ForegroundColor, frameNode);
1326 ACE_RESET_NODE_RENDER_CONTEXT(RenderContext, ForegroundColorFlag, frameNode);
1327 ACE_RESET_NODE_PAINT_PROPERTY(TextFieldPaintProperty, TextColorFlagByUser, frameNode);
1328 }
1329
SetCaretPosition(FrameNode * frameNode,const int32_t & value)1330 void TextFieldModelNG::SetCaretPosition(FrameNode* frameNode, const int32_t& value)
1331 {
1332 CHECK_NULL_VOID(frameNode);
1333 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1334 pattern->SetCaretPosition(value);
1335 }
1336
SetFontStyle(FrameNode * frameNode,Ace::FontStyle value)1337 void TextFieldModelNG::SetFontStyle(FrameNode* frameNode, Ace::FontStyle value)
1338 {
1339 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ItalicFontStyle, value, frameNode);
1340 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredTextLineHeightNeedToUpdate, true, frameNode);
1341 }
1342
SetMaxLength(FrameNode * frameNode,uint32_t value)1343 void TextFieldModelNG::SetMaxLength(FrameNode* frameNode, uint32_t value)
1344 {
1345 CHECK_NULL_VOID(frameNode);
1346 uint32_t preMaxLength = GetMaxLength(frameNode);
1347 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MaxLength, value, frameNode);
1348 if (preMaxLength != value) {
1349 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1350 CHECK_NULL_VOID(pattern);
1351 CHECK_NULL_VOID(pattern->HasFocus());
1352 pattern->UpdateShowCountBorderStyle();
1353 }
1354 }
1355
ResetMaxLength(FrameNode * frameNode)1356 void TextFieldModelNG::ResetMaxLength(FrameNode* frameNode)
1357 {
1358 CHECK_NULL_VOID(frameNode);
1359 auto textFieldLayoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1360 if (textFieldLayoutProperty) {
1361 textFieldLayoutProperty->ResetMaxLength();
1362 }
1363 }
1364
SetCaretStyle(FrameNode * frameNode,const CaretStyle & value)1365 void TextFieldModelNG::SetCaretStyle(FrameNode* frameNode, const CaretStyle& value)
1366 {
1367 if (value.caretWidth.has_value()) {
1368 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, CursorWidth, value.caretWidth.value(), frameNode);
1369 }
1370 }
1371
SetPlaceholderColor(FrameNode * frameNode,const Color & value)1372 void TextFieldModelNG::SetPlaceholderColor(FrameNode* frameNode, const Color& value)
1373 {
1374 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PlaceholderTextColor, value, frameNode);
1375 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, PlaceholderColorFlagByUser, true, frameNode);
1376 }
1377
ResetPlaceholderColor(FrameNode * frameNode)1378 void TextFieldModelNG::ResetPlaceholderColor(FrameNode* frameNode)
1379 {
1380 CHECK_NULL_VOID(frameNode);
1381 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1382 CHECK_NULL_VOID(layoutProperty);
1383 if (layoutProperty->GetPlaceholderFontStyle()) {
1384 layoutProperty->GetPlaceholderFontStyle()->ResetTextColor();
1385 }
1386 ACE_RESET_NODE_PAINT_PROPERTY(TextFieldPaintProperty, PlaceholderColorFlagByUser, frameNode);
1387 }
1388
SetFontWeight(FrameNode * frameNode,FontWeight value)1389 void TextFieldModelNG::SetFontWeight(FrameNode* frameNode, FontWeight value)
1390 {
1391 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, FontWeight, value, frameNode);
1392 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredTextLineHeightNeedToUpdate, true, frameNode);
1393 }
1394
SetShowUnderline(FrameNode * frameNode,bool showUnderLine)1395 void TextFieldModelNG::SetShowUnderline(FrameNode* frameNode, bool showUnderLine)
1396 {
1397 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowUnderline, showUnderLine, frameNode);
1398 }
1399
SetUserUnderlineColor(FrameNode * frameNode,UserUnderlineColor userColor)1400 void TextFieldModelNG::SetUserUnderlineColor(FrameNode* frameNode, UserUnderlineColor userColor)
1401 {
1402 auto pattern = AceType::DynamicCast<TextFieldPattern>(frameNode->GetPattern());
1403 CHECK_NULL_VOID(pattern);
1404 pattern->SetUserUnderlineColor(userColor);
1405 }
1406
SetNormalUnderlineColor(FrameNode * frameNode,const Color & normalColor)1407 void TextFieldModelNG::SetNormalUnderlineColor(FrameNode* frameNode, const Color& normalColor)
1408 {
1409 auto pattern = AceType::DynamicCast<TextFieldPattern>(frameNode->GetPattern());
1410 CHECK_NULL_VOID(pattern);
1411 pattern->SetNormalUnderlineColor(normalColor);
1412 }
1413
SetEnterKeyType(FrameNode * frameNode,TextInputAction value)1414 void TextFieldModelNG::SetEnterKeyType(FrameNode* frameNode, TextInputAction value)
1415 {
1416 auto pattern = AceType::DynamicCast<TextFieldPattern>(frameNode->GetPattern());
1417 CHECK_NULL_VOID(pattern);
1418 if (value == TextInputAction::UNSPECIFIED) {
1419 value = pattern->IsTextArea() ? TextInputAction::NEW_LINE : TextInputAction::DONE;
1420 }
1421 pattern->UpdateTextInputAction(value);
1422 }
1423
SetAutoCapitalizationMode(FrameNode * frameNode,AutoCapitalizationMode value)1424 void TextFieldModelNG::SetAutoCapitalizationMode(FrameNode* frameNode, AutoCapitalizationMode value)
1425 {
1426 auto pattern = AceType::DynamicCast<TextFieldPattern>(frameNode->GetPattern());
1427 CHECK_NULL_VOID(pattern);
1428 pattern->UpdateAutoCapitalizationMode(value);
1429 }
1430
SetFontFamily(FrameNode * frameNode,const std::vector<std::string> & value)1431 void TextFieldModelNG::SetFontFamily(FrameNode* frameNode, const std::vector<std::string>& value)
1432 {
1433 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, FontFamily, value, frameNode);
1434 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredTextLineHeightNeedToUpdate, true, frameNode);
1435 }
1436
SetMaxLines(FrameNode * frameNode,uint32_t value)1437 void TextFieldModelNG::SetMaxLines(FrameNode* frameNode, uint32_t value)
1438 {
1439 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, MaxLines, value, frameNode);
1440 }
1441
SetPlaceholderFont(FrameNode * frameNode,const Font & value)1442 void TextFieldModelNG::SetPlaceholderFont(FrameNode* frameNode, const Font& value)
1443 {
1444 if (value.fontSize.has_value()) {
1445 ACE_UPDATE_NODE_LAYOUT_PROPERTY(
1446 TextFieldLayoutProperty, PlaceholderFontSize, value.fontSize.value(), frameNode);
1447 }
1448 if (value.fontStyle) {
1449 ACE_UPDATE_NODE_LAYOUT_PROPERTY(
1450 TextFieldLayoutProperty, PlaceholderItalicFontStyle, value.fontStyle.value(), frameNode);
1451 }
1452 if (value.fontWeight) {
1453 ACE_UPDATE_NODE_LAYOUT_PROPERTY(
1454 TextFieldLayoutProperty, PlaceholderFontWeight, value.fontWeight.value(), frameNode);
1455 }
1456 if (!value.fontFamilies.empty()) {
1457 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PlaceholderFontFamily, value.fontFamilies, frameNode);
1458 }
1459 ACE_UPDATE_NODE_LAYOUT_PROPERTY(
1460 TextFieldLayoutProperty, PreferredPlaceholderLineHeightNeedToUpdate, true, frameNode);
1461 }
1462
SetFontSize(FrameNode * frameNode,const Dimension & value)1463 void TextFieldModelNG::SetFontSize(FrameNode* frameNode, const Dimension& value)
1464 {
1465 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, FontSize, value, frameNode);
1466 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PreferredTextLineHeightNeedToUpdate, true, frameNode);
1467 }
1468
SetCaretColor(FrameNode * frameNode,const Color & value)1469 void TextFieldModelNG::SetCaretColor(FrameNode* frameNode, const Color& value)
1470 {
1471 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, CursorColor, value, frameNode);
1472 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, CaretColorFlagByUser, true, frameNode);
1473 }
1474
ResetCaretColor(FrameNode * frameNode)1475 void TextFieldModelNG::ResetCaretColor(FrameNode* frameNode)
1476 {
1477 ACE_RESET_NODE_PAINT_PROPERTY(TextFieldPaintProperty, CursorColor, frameNode);
1478 ACE_RESET_NODE_PAINT_PROPERTY(TextFieldPaintProperty, CaretColorFlagByUser, frameNode);
1479 }
1480
SetSelectionMenuHidden(FrameNode * frameNode,bool selectionMenuHidden)1481 void TextFieldModelNG::SetSelectionMenuHidden(FrameNode* frameNode, bool selectionMenuHidden)
1482 {
1483 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, SelectionMenuHidden, selectionMenuHidden, frameNode);
1484 }
1485
GetSelectionMenuHidden(FrameNode * frameNode)1486 bool TextFieldModelNG::GetSelectionMenuHidden(FrameNode* frameNode)
1487 {
1488 bool value = false;
1489 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1490 TextFieldLayoutProperty, SelectionMenuHidden, value, frameNode, value);
1491 return value;
1492 }
1493
SetPasswordRules(FrameNode * frameNode,const std::string & passwordRules)1494 void TextFieldModelNG::SetPasswordRules(FrameNode* frameNode, const std::string& passwordRules)
1495 {
1496 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, PasswordRules, passwordRules, frameNode);
1497 }
1498
SetEnableAutoFill(FrameNode * frameNode,bool enableAutoFill)1499 void TextFieldModelNG::SetEnableAutoFill(FrameNode* frameNode, bool enableAutoFill)
1500 {
1501 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, EnableAutoFill, enableAutoFill, frameNode);
1502 }
1503
SetEnableAutoFillAnimation(FrameNode * frameNode,bool enableAutoFillAnimation)1504 void TextFieldModelNG::SetEnableAutoFillAnimation(FrameNode* frameNode, bool enableAutoFillAnimation)
1505 {
1506 ACE_UPDATE_NODE_LAYOUT_PROPERTY(
1507 TextFieldLayoutProperty, EnableAutoFillAnimation, enableAutoFillAnimation, frameNode);
1508 }
1509
SetShowCounter(FrameNode * frameNode,bool value)1510 void TextFieldModelNG::SetShowCounter(FrameNode* frameNode, bool value)
1511 {
1512 CHECK_NULL_VOID(frameNode);
1513 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowCounter, value, frameNode);
1514 }
1515
SetShowError(FrameNode * frameNode,const std::u16string & errorText,bool visible)1516 void TextFieldModelNG::SetShowError(FrameNode* frameNode, const std::u16string& errorText, bool visible)
1517 {
1518 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ErrorText, errorText, frameNode);
1519 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, ShowErrorText, visible, frameNode);
1520 }
1521
SetCounterType(FrameNode * frameNode,int32_t value)1522 void TextFieldModelNG::SetCounterType(FrameNode* frameNode, int32_t value)
1523 {
1524 CHECK_NULL_VOID(frameNode);
1525 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1526 CHECK_NULL_VOID(layoutProperty);
1527 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, SetCounter, value, frameNode);
1528 }
1529
SetOnWillChangeEvent(FrameNode * frameNode,std::function<bool (const ChangeValueInfo &)> && func)1530 void TextFieldModelNG::SetOnWillChangeEvent(FrameNode* frameNode, std::function<bool(const ChangeValueInfo&)>&& func)
1531 {
1532 CHECK_NULL_VOID(frameNode);
1533 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
1534 CHECK_NULL_VOID(eventHub);
1535 eventHub->SetOnWillChangeEvent(std::move(func));
1536 }
1537
SetOnChange(FrameNode * frameNode,std::function<void (const ChangeValueInfo &)> && func)1538 void TextFieldModelNG::SetOnChange(FrameNode* frameNode, std::function<void(const ChangeValueInfo&)>&& func)
1539 {
1540 CHECK_NULL_VOID(frameNode);
1541 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
1542 CHECK_NULL_VOID(eventHub);
1543 eventHub->SetOnChange(std::move(func));
1544 }
1545
SetOnContentSizeChange(FrameNode * frameNode,std::function<void (float,float)> && func)1546 void TextFieldModelNG::SetOnContentSizeChange(FrameNode* frameNode, std::function<void(float, float)>&& func)
1547 {
1548 CHECK_NULL_VOID(frameNode);
1549 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
1550 CHECK_NULL_VOID(eventHub);
1551 eventHub->SetOnContentSizeChange(std::move(func));
1552 }
1553
SetTextFieldText(FrameNode * frameNode,const std::u16string & value)1554 void TextFieldModelNG::SetTextFieldText(FrameNode* frameNode, const std::u16string& value)
1555 {
1556 CHECK_NULL_VOID(frameNode);
1557 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1558 auto textValue = pattern->GetTextUtf16Value();
1559 if (value != textValue) {
1560 pattern->InitEditingValueText(value);
1561 }
1562 }
1563
SetTextFieldPlaceHolder(FrameNode * frameNode,const std::u16string & placeholder)1564 void TextFieldModelNG::SetTextFieldPlaceHolder(FrameNode* frameNode, const std::u16string& placeholder)
1565 {
1566 CHECK_NULL_VOID(frameNode);
1567 auto textFieldLayoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1568 textFieldLayoutProperty->UpdatePlaceholder(placeholder);
1569 }
1570
StopTextFieldEditing(FrameNode * frameNode)1571 void TextFieldModelNG::StopTextFieldEditing(FrameNode* frameNode)
1572 {
1573 CHECK_NULL_VOID(frameNode);
1574 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1575 if (pattern) {
1576 pattern->StopEditing();
1577 }
1578 }
1579
SetOnSubmit(FrameNode * frameNode,std::function<void (int32_t,NG::TextFieldCommonEvent &)> && func)1580 void TextFieldModelNG::SetOnSubmit(FrameNode* frameNode, std::function<void(int32_t, NG::TextFieldCommonEvent&)>&& func)
1581 {
1582 CHECK_NULL_VOID(frameNode);
1583 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
1584 CHECK_NULL_VOID(eventHub);
1585 eventHub->SetOnSubmit(std::move(func));
1586 }
1587
SetOnCut(FrameNode * frameNode,std::function<void (const std::u16string &)> && func)1588 void TextFieldModelNG::SetOnCut(FrameNode* frameNode, std::function<void(const std::u16string&)>&& func)
1589 {
1590 CHECK_NULL_VOID(frameNode);
1591 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
1592 CHECK_NULL_VOID(eventHub);
1593 eventHub->SetOnCut(std::move(func));
1594 }
1595
SetOnPasteWithEvent(FrameNode * frameNode,std::function<void (const std::u16string &,NG::TextCommonEvent &)> && func)1596 void TextFieldModelNG::SetOnPasteWithEvent(
1597 FrameNode* frameNode, std::function<void(const std::u16string&, NG::TextCommonEvent&)>&& func)
1598 {
1599 CHECK_NULL_VOID(frameNode);
1600 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
1601 CHECK_NULL_VOID(eventHub);
1602 eventHub->SetOnPasteWithEvent(std::move(func));
1603 }
1604
SetCleanNodeStyle(FrameNode * frameNode,CleanNodeStyle cleanNodeStyle)1605 void TextFieldModelNG::SetCleanNodeStyle(FrameNode* frameNode, CleanNodeStyle cleanNodeStyle)
1606 {
1607 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, CleanNodeStyle, cleanNodeStyle, frameNode);
1608 }
1609
SetIsShowCancelButton(FrameNode * frameNode,bool isShowCancelButton)1610 void TextFieldModelNG::SetIsShowCancelButton(FrameNode* frameNode, bool isShowCancelButton)
1611 {
1612 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IsShowCancelButton, isShowCancelButton, frameNode);
1613 }
1614
SetCancelIconSize(FrameNode * frameNode,const CalcDimension & iconSize)1615 void TextFieldModelNG::SetCancelIconSize(FrameNode* frameNode, const CalcDimension& iconSize)
1616 {
1617 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IconSize, iconSize, frameNode);
1618 }
1619
SetCanacelIconSrc(FrameNode * frameNode,const std::string & iconSrc)1620 void TextFieldModelNG::SetCanacelIconSrc(FrameNode* frameNode, const std::string& iconSrc)
1621 {
1622 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IconSrc, iconSrc, frameNode);
1623 }
1624
SetCancelIconColor(FrameNode * frameNode,const Color & iconColor)1625 void TextFieldModelNG::SetCancelIconColor(FrameNode* frameNode, const Color& iconColor)
1626 {
1627 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IconColor, iconColor, frameNode);
1628 }
1629
SetCancelButtonSymbol(FrameNode * frameNode,bool isShowSymbol)1630 void TextFieldModelNG::SetCancelButtonSymbol(FrameNode* frameNode, bool isShowSymbol)
1631 {
1632 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, IsShowSymbol, isShowSymbol, frameNode);
1633 }
1634
SetCancelSymbolIcon(FrameNode * frameNode,const std::function<void (WeakPtr<NG::FrameNode>)> & iconSymbol)1635 void TextFieldModelNG::SetCancelSymbolIcon(FrameNode* frameNode,
1636 const std::function<void(WeakPtr<NG::FrameNode>)>& iconSymbol)
1637 {
1638 CHECK_NULL_VOID(frameNode);
1639 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1640 CHECK_NULL_VOID(layoutProperty);
1641 layoutProperty->SetCancelIconSymbol(iconSymbol);
1642 }
1643
GetPlaceholderText(FrameNode * frameNode)1644 std::u16string TextFieldModelNG::GetPlaceholderText(FrameNode* frameNode)
1645 {
1646 std::u16string value;
1647 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, Placeholder, value, frameNode, value);
1648 return value;
1649 }
1650
GetTextFieldText(FrameNode * frameNode)1651 std::u16string TextFieldModelNG::GetTextFieldText(FrameNode* frameNode)
1652 {
1653 std::u16string value;
1654 CHECK_NULL_RETURN(frameNode, value);
1655 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1656 return pattern->GetTextUtf16Value();
1657 }
1658
GetCaretColor(FrameNode * frameNode)1659 Color TextFieldModelNG::GetCaretColor(FrameNode* frameNode)
1660 {
1661 Color value;
1662 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldPaintProperty, CursorColor, value, frameNode, value);
1663 return value;
1664 }
1665
GetCaretStyle(FrameNode * frameNode)1666 Dimension TextFieldModelNG::GetCaretStyle(FrameNode* frameNode)
1667 {
1668 Dimension value;
1669 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldPaintProperty, CursorWidth, value, frameNode, value);
1670 return value;
1671 }
1672
GetShowUnderline(FrameNode * frameNode)1673 bool TextFieldModelNG::GetShowUnderline(FrameNode* frameNode)
1674 {
1675 bool value = false;
1676 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, ShowUnderline, value, frameNode, value);
1677 return value;
1678 }
1679
GetMaxLength(FrameNode * frameNode)1680 uint32_t TextFieldModelNG::GetMaxLength(FrameNode* frameNode)
1681 {
1682 uint32_t value = 0;
1683 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, MaxLength, value, frameNode, value);
1684 return value;
1685 }
1686
GetEnterKeyType(FrameNode * frameNode)1687 TextInputAction TextFieldModelNG::GetEnterKeyType(FrameNode* frameNode)
1688 {
1689 TextInputAction value = TextInputAction::UNSPECIFIED;
1690 CHECK_NULL_RETURN(frameNode, value);
1691 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1692 return pattern->GetTextInputActionValue(
1693 frameNode->GetTag() == V2::TEXTAREA_ETS_TAG ? TextInputAction::NEW_LINE : TextInputAction::DONE);
1694 }
1695
GetPlaceholderColor(FrameNode * frameNode)1696 Color TextFieldModelNG::GetPlaceholderColor(FrameNode* frameNode)
1697 {
1698 Color value;
1699 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1700 TextFieldLayoutProperty, PlaceholderTextColor, value, frameNode, value);
1701 return value;
1702 }
1703
GetPlaceholderFont(FrameNode * frameNode)1704 Font TextFieldModelNG::GetPlaceholderFont(FrameNode* frameNode)
1705 {
1706 std::vector<std::string> fontFamilies;
1707 Dimension fontSize;
1708 Ace::FontStyle fontStyle = Ace::FontStyle::NORMAL;
1709 Ace::FontWeight fontWeight = Ace::FontWeight::NORMAL;
1710 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1711 TextFieldLayoutProperty, PlaceholderFontSize, fontSize, frameNode, Dimension());
1712 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1713 TextFieldLayoutProperty, PlaceholderItalicFontStyle, fontStyle, frameNode, fontStyle);
1714 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1715 TextFieldLayoutProperty, PlaceholderFontWeight, fontWeight, frameNode, fontWeight);
1716 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1717 TextFieldLayoutProperty, PlaceholderFontFamily, fontFamilies, frameNode, fontFamilies);
1718 Font value { fontWeight, fontSize, fontStyle, fontFamilies, std::nullopt, std::nullopt, std::nullopt };
1719 return value;
1720 }
1721
GetRequestKeyboardOnFocus(FrameNode * frameNode)1722 bool TextFieldModelNG::GetRequestKeyboardOnFocus(FrameNode* frameNode)
1723 {
1724 bool value = false;
1725 CHECK_NULL_RETURN(frameNode, value);
1726 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1727 return pattern->NeedToRequestKeyboardOnFocus();
1728 }
1729
GetType(FrameNode * frameNode)1730 TextInputType TextFieldModelNG::GetType(FrameNode* frameNode)
1731 {
1732 TextInputType value = TextInputType::UNSPECIFIED;
1733 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, TextInputType, value, frameNode, value);
1734 return value;
1735 }
1736
GetSelectedBackgroundColor(FrameNode * frameNode)1737 Color TextFieldModelNG::GetSelectedBackgroundColor(FrameNode* frameNode)
1738 {
1739 Color value;
1740 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
1741 TextFieldPaintProperty, SelectedBackgroundColor, value, frameNode, value);
1742 return value;
1743 }
1744
GetShowPasswordIcon(FrameNode * frameNode)1745 bool TextFieldModelNG::GetShowPasswordIcon(FrameNode* frameNode)
1746 {
1747 bool value = false;
1748 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, ShowPasswordIcon, value, frameNode, value);
1749 return value;
1750 }
1751
GetShowPassword(FrameNode * frameNode)1752 bool TextFieldModelNG::GetShowPassword(FrameNode* frameNode)
1753 {
1754 bool value = false;
1755 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, ShowPasswordText, value, frameNode, value);
1756 return value;
1757 }
1758
GetTextFieldEditing(FrameNode * frameNode)1759 bool TextFieldModelNG::GetTextFieldEditing(FrameNode* frameNode)
1760 {
1761 bool value = false;
1762 CHECK_NULL_RETURN(frameNode, value);
1763 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1764 return pattern->HasFocus();
1765 }
1766
GetShowCancelButton(FrameNode * frameNode)1767 bool TextFieldModelNG::GetShowCancelButton(FrameNode* frameNode)
1768 {
1769 bool value = false;
1770 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1771 TextFieldLayoutProperty, IsShowCancelButton, value, frameNode, value);
1772 return value;
1773 }
1774
GetCancelIconSize(FrameNode * frameNode)1775 CalcDimension TextFieldModelNG::GetCancelIconSize(FrameNode* frameNode)
1776 {
1777 CalcDimension value;
1778 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, IconSize, value, frameNode, value);
1779 return value;
1780 }
1781
GetCanacelIconSrc(FrameNode * frameNode)1782 std::string TextFieldModelNG::GetCanacelIconSrc(FrameNode* frameNode)
1783 {
1784 std::string value;
1785 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, IconSrc, value, frameNode, value);
1786 return value;
1787 }
1788
GetCancelIconColor(FrameNode * frameNode)1789 Color TextFieldModelNG::GetCancelIconColor(FrameNode* frameNode)
1790 {
1791 Color value;
1792 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, IconColor, value, frameNode, value);
1793 return value;
1794 }
1795
GetTextAlign(FrameNode * frameNode)1796 TextAlign TextFieldModelNG::GetTextAlign(FrameNode* frameNode)
1797 {
1798 TextAlign value = TextAlign::START;
1799 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, TextAlign, value, frameNode, value);
1800 return value;
1801 }
GetTextColor(FrameNode * frameNode)1802 Color TextFieldModelNG::GetTextColor(FrameNode* frameNode)
1803 {
1804 Color value;
1805 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, TextColor, value, frameNode, value);
1806 return value;
1807 }
GetFontStyle(FrameNode * frameNode)1808 Ace::FontStyle TextFieldModelNG::GetFontStyle(FrameNode* frameNode)
1809 {
1810 Ace::FontStyle value = Ace::FontStyle::NORMAL;
1811 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, ItalicFontStyle, value, frameNode, value);
1812 return value;
1813 }
GetFontWeight(FrameNode * frameNode)1814 FontWeight TextFieldModelNG::GetFontWeight(FrameNode* frameNode)
1815 {
1816 FontWeight value = FontWeight::NORMAL;
1817 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, FontWeight, value, frameNode, value);
1818 return value;
1819 }
GetFontSize(FrameNode * frameNode)1820 Dimension TextFieldModelNG::GetFontSize(FrameNode* frameNode)
1821 {
1822 Dimension value;
1823 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, FontSize, value, frameNode, Dimension());
1824 return value;
1825 }
GetCleanNodeStyle(FrameNode * frameNode)1826 CleanNodeStyle TextFieldModelNG::GetCleanNodeStyle(FrameNode* frameNode)
1827 {
1828 CleanNodeStyle value = CleanNodeStyle::INPUT;
1829 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, CleanNodeStyle, value, frameNode, value);
1830 return value;
1831 }
GetShowCounter(FrameNode * frameNode)1832 bool TextFieldModelNG::GetShowCounter(FrameNode* frameNode)
1833 {
1834 bool value = false;
1835 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, ShowCounter, value, frameNode, value);
1836 return static_cast<int>(value);
1837 }
1838
GetMinLines(FrameNode * frameNode)1839 uint32_t TextFieldModelNG::GetMinLines(FrameNode* frameNode)
1840 {
1841 uint32_t value = false;
1842 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, MinLines, value, frameNode, value);
1843 return value;
1844 }
1845
GetCounterType(FrameNode * frameNode)1846 int TextFieldModelNG::GetCounterType(FrameNode* frameNode)
1847 {
1848 int value = -1;
1849 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, SetCounter, value, frameNode, value);
1850 return value;
1851 }
GetShowCounterBorder(FrameNode * frameNode)1852 bool TextFieldModelNG::GetShowCounterBorder(FrameNode* frameNode)
1853 {
1854 bool value = true;
1855 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
1856 TextFieldLayoutProperty, ShowHighlightBorder, value, frameNode, value);
1857 return value;
1858 }
1859
SetTextSelection(FrameNode * frameNode,int32_t start,int32_t end)1860 void TextFieldModelNG::SetTextSelection(FrameNode* frameNode, int32_t start, int32_t end)
1861 {
1862 CHECK_NULL_VOID(frameNode);
1863 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1864 CHECK_NULL_VOID(pattern);
1865 auto wideText = pattern->GetTextUtf16Value();
1866 int32_t length = static_cast<int32_t>(wideText.length());
1867 start = std::clamp(start, 0, length);
1868 end = std::clamp(end, 0, length);
1869 pattern->SetSelectionFlag(start, end);
1870 }
1871
GetTextSelectionIndex(FrameNode * frameNode,bool isEnd)1872 int32_t TextFieldModelNG::GetTextSelectionIndex(FrameNode* frameNode, bool isEnd)
1873 {
1874 int32_t defaultValue = 0;
1875 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1876 CHECK_NULL_RETURN(pattern, defaultValue);
1877 auto selectController = pattern->GetTextSelectController();
1878 if (isEnd) {
1879 return selectController->GetEndIndex();
1880 }
1881 return selectController->GetStartIndex();
1882 }
1883
ResetTextInputPadding(FrameNode * frameNode)1884 void TextFieldModelNG::ResetTextInputPadding(FrameNode* frameNode)
1885 {
1886 CHECK_NULL_VOID(frameNode);
1887 auto pipeline = frameNode->GetContext();
1888 CHECK_NULL_VOID(pipeline);
1889 auto themeManager = pipeline->GetThemeManager();
1890 CHECK_NULL_VOID(themeManager);
1891 auto textFieldTheme = themeManager->GetTheme<TextFieldTheme>();
1892 CHECK_NULL_VOID(textFieldTheme);
1893 auto themePadding = textFieldTheme->GetPadding();
1894 PaddingProperty paddings;
1895 paddings.top = NG::CalcLength(themePadding.Top().ConvertToPx());
1896 paddings.bottom = NG::CalcLength(themePadding.Bottom().ConvertToPx());
1897 paddings.left = NG::CalcLength(themePadding.Left().ConvertToPx());
1898 paddings.right = NG::CalcLength(themePadding.Right().ConvertToPx());
1899 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, Padding, paddings, frameNode);
1900 }
1901
SetTextDecoration(FrameNode * frameNode,TextDecoration value)1902 void TextFieldModelNG::SetTextDecoration(FrameNode* frameNode, TextDecoration value)
1903 {
1904 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextDecoration, {value}, frameNode);
1905 }
1906
SetTextDecorationColor(FrameNode * frameNode,const Color & value)1907 void TextFieldModelNG::SetTextDecorationColor(FrameNode* frameNode, const Color& value)
1908 {
1909 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextDecorationColor, value, frameNode);
1910 }
1911
SetTextDecorationStyle(FrameNode * frameNode,TextDecorationStyle value)1912 void TextFieldModelNG::SetTextDecorationStyle(FrameNode* frameNode, TextDecorationStyle value)
1913 {
1914 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, TextDecorationStyle, value, frameNode);
1915 }
1916
SetLetterSpacing(FrameNode * frameNode,const Dimension & value)1917 void TextFieldModelNG::SetLetterSpacing(FrameNode* frameNode, const Dimension& value)
1918 {
1919 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, LetterSpacing, value, frameNode);
1920 }
1921
SetLineHeight(FrameNode * frameNode,const Dimension & value)1922 void TextFieldModelNG::SetLineHeight(FrameNode* frameNode, const Dimension& value)
1923 {
1924 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, LineHeight, value, frameNode);
1925 }
1926
SetHalfLeading(FrameNode * frameNode,const bool & value)1927 void TextFieldModelNG::SetHalfLeading(FrameNode* frameNode, const bool& value)
1928 {
1929 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, HalfLeading, value, frameNode);
1930 }
1931
SetLineSpacing(FrameNode * frameNode,const Dimension & value,bool isOnlyBetweenLines)1932 void TextFieldModelNG::SetLineSpacing(FrameNode* frameNode, const Dimension& value, bool isOnlyBetweenLines)
1933 {
1934 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, LineSpacing, value, frameNode);
1935 ACE_UPDATE_NODE_LAYOUT_PROPERTY(
1936 TextFieldLayoutProperty, IsOnlyBetweenLines, isOnlyBetweenLines, frameNode);
1937 }
1938
GetLineSpacing(FrameNode * frameNode)1939 float TextFieldModelNG::GetLineSpacing(FrameNode* frameNode)
1940 {
1941 CHECK_NULL_RETURN(frameNode, 0.0f);
1942 auto layoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
1943 CHECK_NULL_RETURN(layoutProperty, 0.0f);
1944 Dimension defaultLineSpacing(0);
1945 auto value = layoutProperty->GetLineSpacing().value_or(defaultLineSpacing);
1946 return static_cast<float>(value.Value());
1947 }
1948
SetWordBreak(FrameNode * frameNode,Ace::WordBreak value)1949 void TextFieldModelNG::TextFieldModelNG::SetWordBreak(FrameNode* frameNode, Ace::WordBreak value)
1950 {
1951 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, WordBreak, value, frameNode);
1952 }
1953
SetLineBreakStrategy(FrameNode * frameNode,LineBreakStrategy value)1954 void TextFieldModelNG::SetLineBreakStrategy(FrameNode* frameNode, LineBreakStrategy value)
1955 {
1956 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, LineBreakStrategy, value, frameNode);
1957 }
1958
SetSelectAllValue(FrameNode * frameNode,bool isSelectAllValue)1959 void TextFieldModelNG::SetSelectAllValue(FrameNode* frameNode, bool isSelectAllValue)
1960 {
1961 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, SelectAllValue, isSelectAllValue, frameNode);
1962 }
1963
SetBlurOnSubmit(FrameNode * frameNode,bool blurOnSubmit)1964 void TextFieldModelNG::SetBlurOnSubmit(FrameNode* frameNode, bool blurOnSubmit)
1965 {
1966 CHECK_NULL_VOID(frameNode);
1967 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1968 CHECK_NULL_VOID(pattern);
1969 return pattern->SetBlurOnSubmit(blurOnSubmit);
1970 }
1971
GetBlurOnSubmit(FrameNode * frameNode)1972 bool TextFieldModelNG::GetBlurOnSubmit(FrameNode* frameNode)
1973 {
1974 CHECK_NULL_RETURN(frameNode, true);
1975 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1976 CHECK_NULL_RETURN(pattern, true);
1977 return pattern->GetBlurOnSubmit();
1978 }
1979
SetKeyboardAppearance(FrameNode * frameNode,KeyboardAppearance value)1980 void TextFieldModelNG::SetKeyboardAppearance(FrameNode* frameNode, KeyboardAppearance value)
1981 {
1982 CHECK_NULL_VOID(frameNode);
1983 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1984 CHECK_NULL_VOID(pattern);
1985 pattern->SetKeyboardAppearance(value);
1986 }
1987
GetKeyboardAppearance(FrameNode * frameNode)1988 int32_t TextFieldModelNG::GetKeyboardAppearance(FrameNode* frameNode)
1989 {
1990 CHECK_NULL_RETURN(frameNode, false);
1991 auto pattern = frameNode->GetPattern<TextFieldPattern>();
1992 CHECK_NULL_RETURN(pattern, false);
1993 return static_cast<int32_t>(pattern->GetKeyboardAppearance());
1994 }
1995
SetOnEditChange(FrameNode * frameNode,std::function<void (bool)> && func)1996 void TextFieldModelNG::SetOnEditChange(FrameNode* frameNode, std::function<void(bool)>&& func)
1997 {
1998 CHECK_NULL_VOID(frameNode);
1999 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2000 CHECK_NULL_VOID(eventHub);
2001 eventHub->SetOnEditChanged(std::move(func));
2002 }
2003
SetInputFilter(FrameNode * frameNode,const std::string & value,const std::function<void (const std::u16string &)> & onError)2004 void TextFieldModelNG::SetInputFilter(FrameNode* frameNode,
2005 const std::string& value, const std::function<void(const std::u16string&)>& onError)
2006 {
2007 CHECK_NULL_VOID(frameNode);
2008 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, InputFilter, value, frameNode);
2009 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2010 CHECK_NULL_VOID(eventHub);
2011 eventHub->SetOnInputFilterError(onError);
2012 }
2013
SetOnContentScroll(FrameNode * frameNode,std::function<void (float,float)> && func)2014 void TextFieldModelNG::SetOnContentScroll(FrameNode* frameNode, std::function<void(float, float)>&& func)
2015 {
2016 CHECK_NULL_VOID(frameNode);
2017 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2018 CHECK_NULL_VOID(eventHub);
2019 eventHub->SetOnScrollChangeEvent(std::move(func));
2020 }
2021
SetOnCopy(FrameNode * frameNode,std::function<void (const std::u16string &)> && func)2022 void TextFieldModelNG::SetOnCopy(FrameNode* frameNode, std::function<void(const std::u16string&)>&& func)
2023 {
2024 CHECK_NULL_VOID(frameNode);
2025 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2026 CHECK_NULL_VOID(eventHub);
2027 eventHub->SetOnCopy(std::move(func));
2028 }
2029
SetOnEditChanged(FrameNode * frameNode,std::function<void (bool)> && func)2030 void TextFieldModelNG::SetOnEditChanged(FrameNode* frameNode, std::function<void(bool)>&& func)
2031 {
2032 CHECK_NULL_VOID(frameNode);
2033 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2034 CHECK_NULL_VOID(eventHub);
2035 eventHub->SetOnEditChanged(std::move(func));
2036 }
2037
SetCustomKeyboard(FrameNode * frameNode,FrameNode * customKeyboard,bool supportAvoidance)2038 void TextFieldModelNG::SetCustomKeyboard(FrameNode* frameNode, FrameNode* customKeyboard, bool supportAvoidance)
2039 {
2040 CHECK_NULL_VOID(frameNode);
2041 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2042 if (pattern) {
2043 pattern->SetCustomKeyboardWithNode(AceType::Claim<UINode>(customKeyboard));
2044 pattern->SetCustomKeyboardOption(supportAvoidance);
2045 }
2046 }
2047
SetInputFilter(FrameNode * frameNode,const std::string & value)2048 void TextFieldModelNG::SetInputFilter(FrameNode* frameNode, const std::string& value)
2049 {
2050 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, InputFilter, value, frameNode);
2051 }
2052
SetInputFilterError(FrameNode * frameNode,const std::function<void (const std::u16string &)> & onError)2053 void TextFieldModelNG::SetInputFilterError(FrameNode* frameNode,
2054 const std::function<void(const std::u16string&)>& onError)
2055 {
2056 CHECK_NULL_VOID(frameNode);
2057 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2058 CHECK_NULL_VOID(eventHub);
2059 eventHub->SetOnInputFilterError(onError);
2060 }
2061
GetWordBreak(FrameNode * frameNode)2062 Ace::WordBreak TextFieldModelNG::GetWordBreak(FrameNode* frameNode)
2063 {
2064 Ace::WordBreak value = Ace::WordBreak::BREAK_WORD;
2065 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, WordBreak, value, frameNode, value);
2066 return value;
2067 }
2068
GetEnableAutoFill(FrameNode * frameNode)2069 bool TextFieldModelNG::GetEnableAutoFill(FrameNode* frameNode)
2070 {
2071 bool value = true;
2072 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, EnableAutoFill, value, frameNode, value);
2073 return value;
2074 }
2075
GetEnableAutoFillAnimation(FrameNode * frameNode)2076 bool TextFieldModelNG::GetEnableAutoFillAnimation(FrameNode* frameNode)
2077 {
2078 bool value = true;
2079 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
2080 TextFieldLayoutProperty, EnableAutoFillAnimation, value, frameNode, value);
2081 return value;
2082 }
2083
GetContentType(FrameNode * frameNode)2084 TextContentType TextFieldModelNG::GetContentType(FrameNode* frameNode)
2085 {
2086 TextContentType value = TextContentType::UNSPECIFIED;
2087 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, TextContentType, value, frameNode, value);
2088 return value;
2089 }
2090
GetUnderLineColor(FrameNode * frameNode)2091 UserUnderlineColor TextFieldModelNG::GetUnderLineColor(FrameNode* frameNode)
2092 {
2093 CHECK_NULL_RETURN(frameNode, UserUnderlineColor());
2094 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2095 CHECK_NULL_RETURN(pattern, UserUnderlineColor());
2096 return pattern->GetUserUnderlineColor();
2097 }
2098
GetPasswordRules(FrameNode * frameNode)2099 std::string TextFieldModelNG::GetPasswordRules(FrameNode* frameNode)
2100 {
2101 std::string value;
2102 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, PasswordRules, value, frameNode, value);
2103 return value;
2104 }
2105
GetSelectAllValue(FrameNode * frameNode)2106 bool TextFieldModelNG::GetSelectAllValue(FrameNode* frameNode)
2107 {
2108 bool value = false;
2109 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, SelectAllValue, value, frameNode, value);
2110 return value;
2111 }
2112
GetInputFilter(FrameNode * frameNode)2113 std::string TextFieldModelNG::GetInputFilter(FrameNode* frameNode)
2114 {
2115 std::string value;
2116 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, InputFilter, value, frameNode, value);
2117 return value;
2118 }
2119
GetOrCreateController(FrameNode * frameNode)2120 RefPtr<TextFieldControllerBase> TextFieldModelNG::GetOrCreateController(FrameNode* frameNode)
2121 {
2122 CHECK_NULL_RETURN(frameNode, nullptr);
2123 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2124 CHECK_NULL_RETURN(pattern, nullptr);
2125 if (!pattern->GetTextFieldController()) {
2126 auto controller = AceType::MakeRefPtr<NG::TextFieldController>();
2127 pattern->SetTextFieldController(controller);
2128 controller->SetPattern(AceType::WeakClaim(AceType::RawPtr(pattern)));
2129 }
2130 return pattern->GetTextFieldController();
2131 }
2132
GetInputStyle(FrameNode * frameNode)2133 InputStyle TextFieldModelNG::GetInputStyle(FrameNode* frameNode)
2134 {
2135 InputStyle value = InputStyle::DEFAULT;
2136 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldPaintProperty, InputStyle, value, frameNode, value);
2137 return value;
2138 }
2139
GetFontFeature(FrameNode * frameNode)2140 FONT_FEATURES_LIST TextFieldModelNG::GetFontFeature(FrameNode* frameNode)
2141 {
2142 FONT_FEATURES_LIST value;
2143 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, FontFeature, value, frameNode, value);
2144 return value;
2145 }
2146
GetAdaptMinFontSize(FrameNode * frameNode)2147 Dimension TextFieldModelNG::GetAdaptMinFontSize(FrameNode* frameNode)
2148 {
2149 Dimension value;
2150 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, AdaptMinFontSize, value, frameNode, value);
2151 return value;
2152 }
2153
SetOnWillInsertValueEvent(std::function<bool (const InsertValueInfo &)> && func)2154 void TextFieldModelNG::SetOnWillInsertValueEvent(std::function<bool(const InsertValueInfo&)>&& func)
2155 {
2156 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
2157 CHECK_NULL_VOID(eventHub);
2158 eventHub->SetOnWillInsertValueEvent(std::move(func));
2159 }
2160
SetOnDidInsertValueEvent(std::function<void (const InsertValueInfo &)> && func)2161 void TextFieldModelNG::SetOnDidInsertValueEvent(std::function<void(const InsertValueInfo&)>&& func)
2162 {
2163 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
2164 CHECK_NULL_VOID(eventHub);
2165 eventHub->SetOnDidInsertValueEvent(std::move(func));
2166 }
2167
SetOnWillDeleteEvent(std::function<bool (const DeleteValueInfo &)> && func)2168 void TextFieldModelNG::SetOnWillDeleteEvent(std::function<bool(const DeleteValueInfo&)>&& func)
2169 {
2170 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
2171 CHECK_NULL_VOID(eventHub);
2172 eventHub->SetOnWillDeleteEvent(std::move(func));
2173 }
2174
SetOnDidDeleteEvent(std::function<void (const DeleteValueInfo &)> && func)2175 void TextFieldModelNG::SetOnDidDeleteEvent(std::function<void(const DeleteValueInfo&)>&& func)
2176 {
2177 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
2178 CHECK_NULL_VOID(eventHub);
2179 eventHub->SetOnDidDeleteEvent(std::move(func));
2180 }
2181
SetSelectionMenuOptions(const NG::OnCreateMenuCallback && onCreateMenuCallback,const NG::OnMenuItemClickCallback && onMenuItemClick,const NG::OnPrepareMenuCallback && onPrepareMenuCallback)2182 void TextFieldModelNG::SetSelectionMenuOptions(const NG::OnCreateMenuCallback&& onCreateMenuCallback,
2183 const NG::OnMenuItemClickCallback&& onMenuItemClick, const NG::OnPrepareMenuCallback&& onPrepareMenuCallback)
2184 {
2185 auto textFieldPattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
2186 CHECK_NULL_VOID(textFieldPattern);
2187 textFieldPattern->OnSelectionMenuOptionsUpdate(
2188 std::move(onCreateMenuCallback), std::move(onMenuItemClick), std::move(onPrepareMenuCallback));
2189 }
2190
SetEnablePreviewText(bool enablePreviewText)2191 void TextFieldModelNG::SetEnablePreviewText(bool enablePreviewText)
2192 {
2193 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
2194 CHECK_NULL_VOID(pattern);
2195 pattern->SetSupportPreviewText(enablePreviewText);
2196 }
2197
GetEnablePreviewText(FrameNode * frameNode)2198 bool TextFieldModelNG::GetEnablePreviewText(FrameNode* frameNode)
2199 {
2200 CHECK_NULL_RETURN(frameNode, false);
2201 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2202 CHECK_NULL_RETURN(pattern, false);
2203 return pattern->GetSupportPreviewText();
2204 }
2205
SetEnableHapticFeedback(bool state)2206 void TextFieldModelNG::SetEnableHapticFeedback(bool state)
2207 {
2208 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNodePattern<TextFieldPattern>();
2209 CHECK_NULL_VOID(pattern);
2210 pattern->SetEnableHapticFeedback(state);
2211 }
2212
SetEllipsisMode(EllipsisMode value)2213 void TextFieldModelNG::SetEllipsisMode(EllipsisMode value)
2214 {
2215 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, EllipsisMode, value);
2216 }
2217
GetAdaptMaxFontSize(FrameNode * frameNode)2218 Dimension TextFieldModelNG::GetAdaptMaxFontSize(FrameNode* frameNode)
2219 {
2220 Dimension value;
2221 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, AdaptMaxFontSize, value, frameNode, value);
2222 return value;
2223 }
2224
GetLineHeight(FrameNode * frameNode)2225 Dimension TextFieldModelNG::GetLineHeight(FrameNode* frameNode)
2226 {
2227 Dimension value;
2228 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, LineHeight, value, frameNode, value);
2229 return value;
2230 }
2231
GetHalfLeading(FrameNode * frameNode)2232 bool TextFieldModelNG::GetHalfLeading(FrameNode* frameNode)
2233 {
2234 bool value = false;
2235 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, HalfLeading, value, frameNode, value);
2236 return value;
2237 }
2238
GetMaxLines(FrameNode * frameNode)2239 uint32_t TextFieldModelNG::GetMaxLines(FrameNode* frameNode)
2240 {
2241 uint32_t value = 3;
2242 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, MaxLines, value, frameNode, value);
2243 return value;
2244 }
2245
SetPadding(FrameNode * frameNode,NG::PaddingProperty & newPadding)2246 void TextFieldModelNG::SetPadding(FrameNode* frameNode, NG::PaddingProperty& newPadding)
2247 {
2248 CHECK_NULL_VOID(frameNode);
2249 NG::ViewAbstract::SetPadding(frameNode, newPadding);
2250 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, PaddingByUser, newPadding, frameNode);
2251 }
2252
GetCustomKeyboard(FrameNode * frameNode)2253 RefPtr<UINode> TextFieldModelNG::GetCustomKeyboard(FrameNode* frameNode)
2254 {
2255 CHECK_NULL_RETURN(frameNode, nullptr);
2256 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2257 CHECK_NULL_RETURN(pattern, nullptr);
2258 return pattern->GetCustomKeyboard();
2259 }
2260
GetCustomKeyboardOption(FrameNode * frameNode)2261 bool TextFieldModelNG::GetCustomKeyboardOption(FrameNode* frameNode)
2262 {
2263 CHECK_NULL_RETURN(frameNode, false);
2264 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2265 CHECK_NULL_RETURN(pattern, false);
2266 return pattern->GetCustomKeyboardOption();
2267 }
2268
SetShowKeyBoardOnFocus(FrameNode * frameNode,bool value)2269 void TextFieldModelNG::SetShowKeyBoardOnFocus(FrameNode* frameNode, bool value)
2270 {
2271 CHECK_NULL_VOID(frameNode);
2272 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2273 CHECK_NULL_VOID(pattern);
2274 pattern->SetShowKeyBoardOnFocus(value);
2275 }
2276
GetShowKeyBoardOnFocus(FrameNode * frameNode)2277 bool TextFieldModelNG::GetShowKeyBoardOnFocus(FrameNode* frameNode)
2278 {
2279 CHECK_NULL_RETURN(frameNode, true);
2280 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2281 CHECK_NULL_RETURN(pattern, true);
2282 return pattern->GetShowKeyBoardOnFocus();
2283 }
2284
SetNumberOfLines(FrameNode * frameNode,int32_t value)2285 void TextFieldModelNG::SetNumberOfLines(FrameNode* frameNode, int32_t value)
2286 {
2287 CHECK_NULL_VOID(frameNode);
2288 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, NumberOfLines, value, frameNode);
2289 }
2290
GetNumberOfLines(FrameNode * frameNode)2291 int32_t TextFieldModelNG::GetNumberOfLines(FrameNode* frameNode)
2292 {
2293 int32_t value = -1;
2294 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, NumberOfLines, value, frameNode, value);
2295 return value;
2296 }
2297
ResetNumberOfLines(FrameNode * frameNode)2298 void TextFieldModelNG::ResetNumberOfLines(FrameNode* frameNode)
2299 {
2300 CHECK_NULL_VOID(frameNode);
2301 auto textFieldLayoutProperty = frameNode->GetLayoutProperty<TextFieldLayoutProperty>();
2302 if (textFieldLayoutProperty) {
2303 textFieldLayoutProperty->ResetNumberOfLines();
2304 }
2305 }
2306
SetBorderWidth(FrameNode * frameNode,NG::BorderWidthProperty borderWidth)2307 void TextFieldModelNG::SetBorderWidth(FrameNode* frameNode, NG::BorderWidthProperty borderWidth)
2308 {
2309 CHECK_NULL_VOID(frameNode);
2310 NG::ViewAbstract::SetBorderWidth(frameNode, borderWidth);
2311 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, BorderWidthFlagByUser, borderWidth, frameNode);
2312 }
2313
SetBorderRadius(FrameNode * frameNode,NG::BorderRadiusProperty borderRadius)2314 void TextFieldModelNG::SetBorderRadius(FrameNode* frameNode, NG::BorderRadiusProperty borderRadius)
2315 {
2316 CHECK_NULL_VOID(frameNode);
2317 NG::ViewAbstract::SetBorderRadius(frameNode, borderRadius);
2318 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, BorderRadiusFlagByUser, borderRadius, frameNode);
2319 }
2320
SetBorderColor(FrameNode * frameNode,NG::BorderColorProperty borderColors)2321 void TextFieldModelNG::SetBorderColor(FrameNode* frameNode, NG::BorderColorProperty borderColors)
2322 {
2323 CHECK_NULL_VOID(frameNode);
2324 NG::ViewAbstract::SetBorderColor(frameNode, borderColors);
2325 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, BorderColorFlagByUser, borderColors, frameNode);
2326 }
2327
SetBorderStyle(FrameNode * frameNode,NG::BorderStyleProperty borderStyles)2328 void TextFieldModelNG::SetBorderStyle(FrameNode* frameNode, NG::BorderStyleProperty borderStyles)
2329 {
2330 CHECK_NULL_VOID(frameNode);
2331 NG::ViewAbstract::SetBorderStyle(frameNode, borderStyles);
2332 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, BorderStyleFlagByUser, borderStyles, frameNode);
2333 }
2334
SetMargin(FrameNode * frameNode,NG::PaddingProperty & margin)2335 void TextFieldModelNG::SetMargin(FrameNode* frameNode, NG::PaddingProperty& margin)
2336 {
2337 CHECK_NULL_VOID(frameNode);
2338 MarginProperty userMargin;
2339 userMargin.top = margin.top;
2340 userMargin.bottom = margin.bottom;
2341 userMargin.left = margin.left;
2342 userMargin.right = margin.right;
2343 ACE_UPDATE_NODE_PAINT_PROPERTY(TextFieldPaintProperty, MarginByUser, userMargin, frameNode);
2344 }
2345
GetMargin(FrameNode * frameNode)2346 PaddingProperty TextFieldModelNG::GetMargin(FrameNode* frameNode)
2347 {
2348 CalcLength defaultDimen = CalcLength(0, DimensionUnit::VP);
2349 NG::PaddingProperty margins;
2350 margins.top = std::optional<CalcLength>(defaultDimen);
2351 margins.right = std::optional<CalcLength>(defaultDimen);
2352 margins.bottom = std::optional<CalcLength>(defaultDimen);
2353 margins.left = std::optional<CalcLength>(defaultDimen);
2354 auto textfieldPaintProperty = frameNode->GetPaintProperty<TextFieldPaintProperty>();
2355 CHECK_NULL_RETURN(textfieldPaintProperty, margins);
2356 if (textfieldPaintProperty->HasMarginByUser()) {
2357 const auto& property = textfieldPaintProperty->GetMarginByUserValue();
2358 margins.top = std::optional<CalcLength>(property.top);
2359 margins.right = std::optional<CalcLength>(property.right);
2360 margins.bottom = std::optional<CalcLength>(property.bottom);
2361 margins.left = std::optional<CalcLength>(property.left);
2362 }
2363 return margins;
2364 }
2365
SetOnWillInsertValueEvent(FrameNode * frameNode,std::function<bool (const InsertValueInfo &)> && func)2366 void TextFieldModelNG::SetOnWillInsertValueEvent(FrameNode* frameNode,
2367 std::function<bool(const InsertValueInfo&)>&& func)
2368 {
2369 CHECK_NULL_VOID(frameNode);
2370 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2371 CHECK_NULL_VOID(eventHub);
2372 eventHub->SetOnWillInsertValueEvent(std::move(func));
2373 }
2374
SetOnDidInsertValueEvent(FrameNode * frameNode,std::function<void (const InsertValueInfo &)> && func)2375 void TextFieldModelNG::SetOnDidInsertValueEvent(FrameNode* frameNode,
2376 std::function<void(const InsertValueInfo&)>&& func)
2377 {
2378 CHECK_NULL_VOID(frameNode);
2379 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2380 CHECK_NULL_VOID(eventHub);
2381 eventHub->SetOnDidInsertValueEvent(std::move(func));
2382 }
2383
SetOnWillDeleteEvent(FrameNode * frameNode,std::function<bool (const DeleteValueInfo &)> && func)2384 void TextFieldModelNG::SetOnWillDeleteEvent(FrameNode* frameNode,
2385 std::function<bool(const DeleteValueInfo&)>&& func)
2386 {
2387 CHECK_NULL_VOID(frameNode);
2388 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2389 CHECK_NULL_VOID(eventHub);
2390 eventHub->SetOnWillDeleteEvent(std::move(func));
2391 }
2392
SetOnDidDeleteEvent(FrameNode * frameNode,std::function<void (const DeleteValueInfo &)> && func)2393 void TextFieldModelNG::SetOnDidDeleteEvent(FrameNode* frameNode,
2394 std::function<void(const DeleteValueInfo&)>&& func)
2395 {
2396 CHECK_NULL_VOID(frameNode);
2397 auto eventHub = frameNode->GetOrCreateEventHub<TextFieldEventHub>();
2398 CHECK_NULL_VOID(eventHub);
2399 eventHub->SetOnDidDeleteEvent(std::move(func));
2400 }
2401
OnCreateMenuCallbackUpdate(FrameNode * frameNode,const NG::OnCreateMenuCallback && onCreateMenuCallback)2402 void TextFieldModelNG::OnCreateMenuCallbackUpdate(
2403 FrameNode* frameNode, const NG::OnCreateMenuCallback&& onCreateMenuCallback)
2404 {
2405 CHECK_NULL_VOID(frameNode);
2406 auto textFieldPattern = frameNode->GetPattern<TextFieldPattern>();
2407 CHECK_NULL_VOID(textFieldPattern);
2408 textFieldPattern->OnCreateMenuCallbackUpdate(std::move(onCreateMenuCallback));
2409 }
2410
OnMenuItemClickCallbackUpdate(FrameNode * frameNode,const NG::OnMenuItemClickCallback && onMenuItemClick)2411 void TextFieldModelNG::OnMenuItemClickCallbackUpdate(
2412 FrameNode* frameNode, const NG::OnMenuItemClickCallback&& onMenuItemClick)
2413 {
2414 CHECK_NULL_VOID(frameNode);
2415 auto textFieldPattern = frameNode->GetPattern<TextFieldPattern>();
2416 CHECK_NULL_VOID(textFieldPattern);
2417 textFieldPattern->OnMenuItemClickCallbackUpdate(std::move(onMenuItemClick));
2418 }
2419
OnPrepareMenuCallbackUpdate(FrameNode * frameNode,const NG::OnPrepareMenuCallback && onPrepareMenuCallback)2420 void TextFieldModelNG::OnPrepareMenuCallbackUpdate(
2421 FrameNode* frameNode, const NG::OnPrepareMenuCallback&& onPrepareMenuCallback)
2422 {
2423 CHECK_NULL_VOID(frameNode);
2424 auto textFieldPattern = frameNode->GetPattern<TextFieldPattern>();
2425 CHECK_NULL_VOID(textFieldPattern);
2426 textFieldPattern->OnPrepareMenuCallbackUpdate(std::move(onPrepareMenuCallback));
2427 }
2428
SetEnablePreviewText(FrameNode * frameNode,bool enablePreviewText)2429 void TextFieldModelNG::SetEnablePreviewText(FrameNode* frameNode, bool enablePreviewText)
2430 {
2431 CHECK_NULL_VOID(frameNode);
2432 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2433 CHECK_NULL_VOID(pattern);
2434 pattern->SetSupportPreviewText(enablePreviewText);
2435 }
2436
GetPadding(FrameNode * frameNode)2437 PaddingProperty TextFieldModelNG::GetPadding(FrameNode* frameNode)
2438 {
2439 NG::PaddingProperty paddings = NG::ViewAbstract::GetPadding(frameNode);
2440 auto textfieldPaintProperty = frameNode->GetPaintProperty<TextFieldPaintProperty>();
2441 CHECK_NULL_RETURN(textfieldPaintProperty, paddings);
2442 if (textfieldPaintProperty->HasPaddingByUser()) {
2443 const auto& property = textfieldPaintProperty->GetPaddingByUserValue();
2444 paddings.top = std::optional<CalcLength>(property.top);
2445 paddings.right = std::optional<CalcLength>(property.right);
2446 paddings.bottom = std::optional<CalcLength>(property.bottom);
2447 paddings.left = std::optional<CalcLength>(property.left);
2448 }
2449 return paddings;
2450 }
2451
SetJSTextEditableController(FrameNode * frameNode,const RefPtr<Referenced> & controller)2452 void TextFieldModelNG::SetJSTextEditableController(FrameNode* frameNode, const RefPtr<Referenced>& controller)
2453 {
2454 CHECK_NULL_VOID(frameNode);
2455 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2456 CHECK_NULL_VOID(pattern);
2457 pattern->SetJSTextEditableController(controller);
2458 }
2459
GetJSTextEditableController(FrameNode * frameNode)2460 RefPtr<Referenced> TextFieldModelNG::GetJSTextEditableController(FrameNode* frameNode)
2461 {
2462 CHECK_NULL_RETURN(frameNode, nullptr);
2463 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2464 CHECK_NULL_RETURN(pattern, nullptr);
2465 return pattern->GetJSTextEditableController();
2466 }
2467
SetEnableHapticFeedback(FrameNode * frameNode,bool state)2468 void TextFieldModelNG::SetEnableHapticFeedback(FrameNode* frameNode, bool state)
2469 {
2470 CHECK_NULL_VOID(frameNode);
2471 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2472 CHECK_NULL_VOID(pattern);
2473 pattern->SetEnableHapticFeedback(state);
2474 }
2475
SetEllipsisMode(FrameNode * frameNode,EllipsisMode value)2476 void TextFieldModelNG::SetEllipsisMode(FrameNode* frameNode, EllipsisMode value)
2477 {
2478 CHECK_NULL_VOID(frameNode);
2479 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, EllipsisMode, value, frameNode);
2480 }
2481
SetStopBackPress(bool isStopBackPress)2482 void TextFieldModelNG::SetStopBackPress(bool isStopBackPress)
2483 {
2484 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, StopBackPress, isStopBackPress);
2485 }
2486
SetStopBackPress(FrameNode * frameNode,bool isStopBackPress)2487 void TextFieldModelNG::SetStopBackPress(FrameNode* frameNode, bool isStopBackPress)
2488 {
2489 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, StopBackPress, isStopBackPress, frameNode);
2490 }
2491
SetStrokeWidth(const Dimension & value)2492 void TextFieldModelNG::SetStrokeWidth(const Dimension& value)
2493 {
2494 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, StrokeWidth, value);
2495 }
2496
GetStrokeWidth(FrameNode * frameNode)2497 Dimension TextFieldModelNG::GetStrokeWidth(FrameNode* frameNode)
2498 {
2499 Dimension value;
2500 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, StrokeWidth, value, frameNode, value);
2501 return value;
2502 }
2503
SetStrokeColor(const Color & value)2504 void TextFieldModelNG::SetStrokeColor(const Color& value)
2505 {
2506 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, StrokeColor, value);
2507 }
2508
GetStrokeColor(FrameNode * frameNode)2509 Color TextFieldModelNG::GetStrokeColor(FrameNode* frameNode)
2510 {
2511 Color value;
2512 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(TextFieldLayoutProperty, StrokeColor, value, frameNode, value);
2513 return value;
2514 }
2515
ResetStrokeColor()2516 void TextFieldModelNG::ResetStrokeColor()
2517 {
2518 ACE_RESET_LAYOUT_PROPERTY_WITH_FLAG(TextFieldLayoutProperty, StrokeColor, PROPERTY_UPDATE_MEASURE);
2519 }
2520
SetStrokeWidth(FrameNode * frameNode,const Dimension & value)2521 void TextFieldModelNG::SetStrokeWidth(FrameNode* frameNode, const Dimension& value)
2522 {
2523 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, StrokeWidth, value, frameNode);
2524 }
2525
SetStrokeColor(FrameNode * frameNode,const Color & value)2526 void TextFieldModelNG::SetStrokeColor(FrameNode* frameNode, const Color& value)
2527 {
2528 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, StrokeColor, value, frameNode);
2529 }
2530
ResetStrokeColor(FrameNode * frameNode)2531 void TextFieldModelNG::ResetStrokeColor(FrameNode* frameNode)
2532 {
2533 ACE_RESET_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, StrokeColor, frameNode);
2534 }
2535
SetEnableAutoSpacing(bool enabled)2536 void TextFieldModelNG::SetEnableAutoSpacing(bool enabled)
2537 {
2538 ACE_UPDATE_LAYOUT_PROPERTY(TextFieldLayoutProperty, EnableAutoSpacing, enabled);
2539 }
2540
SetEnableAutoSpacing(FrameNode * frameNode,bool enabled)2541 void TextFieldModelNG::SetEnableAutoSpacing(FrameNode* frameNode, bool enabled)
2542 {
2543 CHECK_NULL_VOID(frameNode);
2544 ACE_UPDATE_NODE_LAYOUT_PROPERTY(TextFieldLayoutProperty, EnableAutoSpacing, enabled, frameNode);
2545 }
2546
GetEnableAutoSpacing(FrameNode * frameNode)2547 bool TextFieldModelNG::GetEnableAutoSpacing(FrameNode* frameNode)
2548 {
2549 CHECK_NULL_RETURN(frameNode, false);
2550 bool value = false;
2551 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
2552 TextFieldLayoutProperty, EnableAutoSpacing, value, frameNode, value);
2553 return value;
2554 }
2555
SetOnSecurityStateChange(FrameNode * frameNode,std::function<void (bool)> && func)2556 void TextFieldModelNG::SetOnSecurityStateChange(FrameNode* frameNode, std::function<void(bool)>&& func)
2557 {
2558 CHECK_NULL_VOID(frameNode);
2559 auto eventHub = frameNode->GetEventHub<TextFieldEventHub>();
2560 CHECK_NULL_VOID(eventHub);
2561 eventHub->SetOnSecurityStateChange(std::move(func));
2562 }
2563
SetOnWillAttachIME(std::function<void (const IMEClient &)> && func)2564 void TextFieldModelNG::SetOnWillAttachIME(std::function<void(const IMEClient&)>&& func)
2565 {
2566 auto eventHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeEventHub<TextFieldEventHub>();
2567 CHECK_NULL_VOID(eventHub);
2568 eventHub->SetOnWillAttachIME(std::move(func));
2569 }
2570
SetKeyboardAppearanceConfig(FrameNode * frameNode,KeyboardAppearanceConfig config)2571 void TextFieldModelNG::SetKeyboardAppearanceConfig(FrameNode* frameNode, KeyboardAppearanceConfig config)
2572 {
2573 CHECK_NULL_VOID(frameNode);
2574 auto pattern = frameNode->GetPattern<TextFieldPattern>();
2575 CHECK_NULL_VOID(pattern);
2576 pattern->SetKeyboardAppearanceConfig(config);
2577 }
2578 } // namespace OHOS::Ace::NG
2579