1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "core/components_ng/pattern/text_picker/textpicker_dialog_view.h"
17 
18 #include <securec.h>
19 
20 #include "base/i18n/localization.h"
21 #include "base/utils/utils.h"
22 #include "core/common/recorder/event_recorder.h"
23 #include "core/components_ng/base/view_abstract_model.h"
24 #include "core/components_ng/base/view_stack_processor.h"
25 #include "core/components_ng/pattern/button/button_pattern.h"
26 #include "core/components_ng/pattern/dialog/dialog_view.h"
27 #include "core/components_ng/pattern/divider/divider_pattern.h"
28 #include "core/components_ng/pattern/dialog/dialog_pattern.h"
29 #include "core/components_ng/pattern/image/image_pattern.h"
30 #include "core/components_ng/pattern/stack/stack_pattern.h"
31 #include "core/components_ng/pattern/text/text_pattern.h"
32 #include "core/components_ng/pattern/text_picker/textpicker_column_pattern.h"
33 #include "core/components_ng/pattern/text_picker/textpicker_event_hub.h"
34 #include "core/components_ng/pattern/text_picker/textpicker_pattern.h"
35 #include "core/components_v2/inspector/inspector_constants.h"
36 #include "core/pipeline_ng/pipeline_context.h"
37 
38 namespace OHOS::Ace::NG {
39 namespace {
40 const int32_t MARGIN_HALF = 2;
41 const int32_t BUFFER_NODE_NUMBER = 2;
42 const int32_t SECOND_DIVEDER_NODE_INDEX = 3;
43 const int32_t THIRD_DIVEDER_NODE_INDEX = 5;
44 const int32_t BACKWARD_BUTTON_DIVEDER_INDEX = 2;
45 const int32_t FORWAED_BUTTON_DIVEDER_INDEX = 4;
46 const int32_t CONFIRM_BUTTON_DIVEDER_INDEX = 6;
47 constexpr size_t ACCEPT_BUTTON_INDEX = 0;
48 constexpr size_t CANCEL_BUTTON_INDEX = 1;
49 constexpr size_t BACKWARD_BUTTON_INDEX = 2;
50 constexpr size_t FORWAED_BUTTON_INDEX = 3;
51 } // namespace
52 
53 WeakPtr<FrameNode> TextPickerDialogView::dialogNode_ = nullptr;
54 uint32_t dialogNodePage = 0;
55 uint32_t totalPageNum_ = 0;
56 Dimension TextPickerDialogView::selectedTextStyleFont_ = 40.0_vp;
57 Dimension TextPickerDialogView::normalTextStyleFont_ = 32.0_vp;
58 Dimension TextPickerDialogView::disappearTextStyleFont_ = 28.0_vp;
59 
Show(const DialogProperties & dialogProperties,const TextPickerSettingData & settingData,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogTextEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)60 RefPtr<FrameNode> TextPickerDialogView::Show(const DialogProperties& dialogProperties,
61     const TextPickerSettingData& settingData, const std::vector<ButtonInfo>& buttonInfos,
62     std::map<std::string, NG::DialogTextEvent> dialogEvent,
63     std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
64 {
65     if (settingData.rangeVector.empty() && settingData.options.empty()) {
66         return nullptr;
67     }
68     GetUserSettingLimit();
69     if (settingData.options.empty()) {
70         return RangeShow(dialogProperties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
71     } else {
72         return OptionsShow(dialogProperties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
73     }
74 }
75 
RangeShow(const DialogProperties & dialogProperties,const TextPickerSettingData & settingData,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogTextEvent> & dialogEvent,std::map<std::string,NG::DialogGestureEvent> & dialogCancelEvent)76 RefPtr<FrameNode> TextPickerDialogView::RangeShow(const DialogProperties& dialogProperties,
77     const TextPickerSettingData& settingData, const std::vector<ButtonInfo>& buttonInfos,
78     std::map<std::string, NG::DialogTextEvent>& dialogEvent,
79     std::map<std::string, NG::DialogGestureEvent>& dialogCancelEvent)
80 {
81     auto contentColumn = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
82         AceType::MakeRefPtr<LinearLayoutPattern>(true));
83     auto textNodeId = ElementRegister::GetInstance()->MakeUniqueId();
84     auto textPickerNode = FrameNode::GetOrCreateFrameNode(
85         V2::TEXT_PICKER_ETS_TAG, textNodeId, []() { return AceType::MakeRefPtr<TextPickerPattern>(); });
86     ViewStackProcessor::GetInstance()->Push(textPickerNode);
87     auto textPickerPattern = textPickerNode->GetPattern<TextPickerPattern>();
88     CHECK_NULL_RETURN(textPickerPattern, nullptr);
89     textPickerPattern->SetColumnsKind(settingData.columnKind);
90     textPickerPattern->SetIsShowInDialog(true);
91     textPickerPattern->SetPickerTag(false);
92     textPickerPattern->SetTextProperties(settingData.properties);
93     auto context = textPickerNode->GetContext();
94     CHECK_NULL_RETURN(context, nullptr);
95     auto themeManager = context->GetThemeManager();
96     CHECK_NULL_RETURN(themeManager, nullptr);
97     auto dialogTheme = themeManager->GetTheme<DialogTheme>();
98     CHECK_NULL_RETURN(dialogTheme, nullptr);
99     textPickerPattern->SetBackgroundColor(dialogTheme->GetBackgroundColor());
100     auto pickerTheme = themeManager->GetTheme<PickerTheme>();
101     CHECK_NULL_RETURN(pickerTheme, nullptr);
102     auto pickerNodeLayout = textPickerNode->GetLayoutProperty<TextPickerLayoutProperty>();
103     CHECK_NULL_RETURN(pickerNodeLayout, nullptr);
104     pickerNodeLayout->UpdateUserDefinedIdealSize(
105         CalcSize(NG::CalcLength(Dimension(1.0, DimensionUnit::PERCENT)), std::nullopt));
106     pickerNodeLayout->UpdateCanLoop(settingData.canLoop);
107     uint32_t showCount = pickerTheme->GetShowOptionCount() + BUFFER_NODE_NUMBER;
108     OptionsCreateNode(textPickerPattern, settingData, textPickerNode, showCount, 1, pickerTheme);
109     SetDefaultPickerItemHeight(settingData.height);
110     SetTextProperties(pickerTheme, settingData.properties);
111     auto changeEvent = dialogEvent["changeId"];
112     SetDialogChange(textPickerNode, std::move(changeEvent));
113     auto scrollStopEvent = dialogEvent["scrollStopId"];
114     SetDialogScrollStop(textPickerNode, std::move(scrollStopEvent));
115     ViewStackProcessor::GetInstance()->Finish();
116     textPickerNode->MountToParent(contentColumn);
117     auto dialogNode = DialogView::CreateDialogNode(dialogProperties, contentColumn);
118     CHECK_NULL_RETURN(dialogNode, nullptr);
119     auto dialogPattern = dialogNode->GetPattern<DialogPattern>();
120     CHECK_NULL_RETURN(dialogPattern, nullptr);
121     dialogPattern->SetIsPickerDialog(true);
122     auto closeDialogEvent = CloseDialogEvent(textPickerPattern, dialogNode);
123     auto closeCallback = [func = std::move(closeDialogEvent)](const GestureEvent& /* info */) {
124         func();
125     };
126 
127     auto contentRow =
128         CreateButtonNode(textPickerNode, buttonInfos, dialogEvent, std::move(dialogCancelEvent), closeCallback);
129     textPickerPattern->SetContentRowNode(contentRow);
130     contentRow->SetNeedCallChildrenUpdate(false);
131     contentRow->AddChild(CreateDividerNode(textPickerNode), 1);
132     contentRow->MountToParent(contentColumn);
133     auto focusHub = contentColumn->GetFocusHub();
134     CHECK_NULL_RETURN(focusHub, nullptr);
135     InitOnKeyEvent(focusHub);
136     dialogNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
137     dialogNode_ = dialogNode;
138     return dialogNode;
139 }
140 
CloseDialogEvent(const RefPtr<TextPickerPattern> & textPickerPattern,const RefPtr<FrameNode> & dialogNode)141 std::function<void()> TextPickerDialogView::CloseDialogEvent(const RefPtr<TextPickerPattern>& textPickerPattern,
142     const RefPtr<FrameNode>& dialogNode)
143 {
144     auto event = [weak = WeakPtr<FrameNode>(dialogNode),
145         weakPattern = WeakPtr<TextPickerPattern>(textPickerPattern)]() {
146         auto dialogNode = weak.Upgrade();
147         CHECK_NULL_VOID(dialogNode);
148         auto dialogPattern = dialogNode->GetPattern<DialogPattern>();
149         CHECK_NULL_VOID(dialogPattern);
150         dialogPattern->SetIsPickerDialog(false);
151         auto textPickerPattern = weakPattern.Upgrade();
152         CHECK_NULL_VOID(textPickerPattern);
153         if (textPickerPattern->GetIsShowInDialog()) {
154             auto pipeline = dialogNode->GetContext();
155             CHECK_NULL_VOID(pipeline);
156             auto overlayManager = pipeline->GetOverlayManager();
157             CHECK_NULL_VOID(overlayManager);
158             overlayManager->CloseDialog(dialogNode);
159             textPickerPattern->SetIsShowInDialog(false);
160         }
161     };
162     textPickerPattern->updateFontConfigurationEvent(event);
163     return event;
164 }
165 
OptionsCreateNode(const RefPtr<TextPickerPattern> & textPickerPattern,const TextPickerSettingData & settingData,const RefPtr<FrameNode> & textPickerNode,uint32_t showCount,uint32_t columnCount,RefPtr<PickerTheme> pickerTheme)166 void TextPickerDialogView::OptionsCreateNode(const RefPtr<TextPickerPattern>& textPickerPattern,
167     const TextPickerSettingData& settingData, const RefPtr<FrameNode>& textPickerNode, uint32_t showCount,
168     uint32_t columnCount, RefPtr<PickerTheme> pickerTheme)
169 {
170     totalPageNum_ = columnCount;
171     if (textPickerNode->GetChildren().empty()) {
172         for (size_t i = 0; i < columnCount; i++) {
173             auto columnNode = CreateColumnNode(settingData.columnKind,
174                 showCount, pickerTheme);
175             auto stackNode = CreateStackNode(pickerTheme);
176             auto buttonNode = CreateButtonNode();
177             auto columnBlendNode = CreateColumnNode();
178             buttonNode->MountToParent(stackNode);
179             columnNode->MountToParent(columnBlendNode);
180             columnBlendNode->MountToParent(stackNode);
181             columnNode->MarkModifyDone();
182             columnNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
183             auto layoutProperty = stackNode->GetLayoutProperty<LayoutProperty>();
184             layoutProperty->UpdateAlignment(Alignment::CENTER);
185             layoutProperty->UpdateLayoutWeight(1);
186             stackNode->MountToParent(textPickerNode);
187         }
188     }
189     if (settingData.options.size() > 0) {
190         SetSelectedValues(textPickerPattern, settingData.selectedValues);
191         SetValues(textPickerPattern, settingData.values);
192     } else {
193         SetRange(textPickerPattern, settingData.rangeVector);
194         SetSelected(textPickerPattern, settingData.selected);
195     }
196 }
197 
OptionsShowInternal(const RefPtr<TextPickerPattern> & textPickerPattern,const TextPickerSettingData & settingData,const RefPtr<FrameNode> & textPickerNode,uint32_t showCount,RefPtr<PickerTheme> pickerTheme)198 void TextPickerDialogView::OptionsShowInternal(const RefPtr<TextPickerPattern>& textPickerPattern,
199     const TextPickerSettingData& settingData, const RefPtr<FrameNode>& textPickerNode, uint32_t showCount,
200     RefPtr<PickerTheme> pickerTheme)
201 {
202     textPickerPattern->SetIsCascade(settingData.attr.isCascade);
203     textPickerPattern->SetHasSelectAttr(settingData.attr.isHasSelectAttr);
204     textPickerPattern->SetColumnsKind(settingData.columnKind);
205     if (settingData.attr.isCascade) {
206         std::vector<NG::TextCascadePickerOptions> reOptions;
207         uint32_t columnCount = settingData.options.empty() ? 0 : 1;
208         // Caculate max depth
209         for (size_t i = 0; i < settingData.options.size(); i++) {
210             size_t tmp = textPickerPattern->ProcessCascadeOptionDepth(settingData.options[i]);
211             if (tmp > columnCount) {
212                 columnCount = tmp;
213             }
214         }
215         OptionsCreateNode(textPickerPattern, settingData, textPickerNode, showCount, columnCount, pickerTheme);
216         textPickerPattern->ProcessCascadeOptions(settingData.options, reOptions, 0);
217         if (reOptions.size() < columnCount) {
218             auto differ = columnCount - reOptions.size();
219             for (uint32_t i = 0; i < differ; i++) {
220                 NG::TextCascadePickerOptions differOption;
221                 memset_s(&differOption, sizeof(differOption), 0, sizeof(differOption));
222                 reOptions.emplace_back(differOption);
223             }
224         }
225         textPickerPattern->SetCascadeOptions(settingData.options, reOptions);
226     } else {
227         OptionsCreateNode(
228             textPickerPattern, settingData, textPickerNode, showCount, settingData.options.size(), pickerTheme);
229         textPickerPattern->SetCascadeOptions(settingData.options, settingData.options);
230     }
231 }
232 
OptionsShow(const DialogProperties & dialogProperties,const TextPickerSettingData & settingData,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogTextEvent> & dialogEvent,std::map<std::string,NG::DialogGestureEvent> & dialogCancelEvent)233 RefPtr<FrameNode> TextPickerDialogView::OptionsShow(const DialogProperties& dialogProperties,
234     const TextPickerSettingData& settingData, const std::vector<ButtonInfo>& buttonInfos,
235     std::map<std::string, NG::DialogTextEvent>& dialogEvent,
236     std::map<std::string, NG::DialogGestureEvent>& dialogCancelEvent)
237 {
238     auto contentColumn = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
239         AceType::MakeRefPtr<LinearLayoutPattern>(true));
240     auto textNodeId = ElementRegister::GetInstance()->MakeUniqueId();
241     auto textPickerNode = FrameNode::GetOrCreateFrameNode(
242         V2::TEXT_PICKER_ETS_TAG, textNodeId, []() { return AceType::MakeRefPtr<TextPickerPattern>(); });
243     ViewStackProcessor::GetInstance()->Push(textPickerNode);
244     auto textPickerPattern = textPickerNode->GetPattern<TextPickerPattern>();
245     CHECK_NULL_RETURN(textPickerPattern, nullptr);
246     textPickerPattern->SetIsShowInDialog(true);
247     textPickerPattern->SetPickerTag(false);
248     textPickerPattern->SetTextProperties(settingData.properties);
249     auto context = textPickerNode->GetContext();
250     CHECK_NULL_RETURN(context, nullptr);
251     auto themeManager = context->GetThemeManager();
252     CHECK_NULL_RETURN(themeManager, nullptr);
253     auto dialogTheme = themeManager->GetTheme<DialogTheme>();
254     CHECK_NULL_RETURN(dialogTheme, nullptr);
255     textPickerPattern->SetBackgroundColor(dialogTheme->GetBackgroundColor());
256     auto pickerTheme = themeManager->GetTheme<PickerTheme>();
257     CHECK_NULL_RETURN(pickerTheme, nullptr);
258     auto pickerNodeLayout = textPickerNode->GetLayoutProperty<TextPickerLayoutProperty>();
259     CHECK_NULL_RETURN(pickerNodeLayout, nullptr);
260     pickerNodeLayout->UpdateUserDefinedIdealSize(
261         CalcSize(NG::CalcLength(Dimension(1.0, DimensionUnit::PERCENT)), std::nullopt));
262     pickerNodeLayout->UpdateCanLoop(settingData.canLoop);
263     uint32_t showCount = pickerTheme->GetShowOptionCount() + BUFFER_NODE_NUMBER;
264     OptionsShowInternal(textPickerPattern, settingData, textPickerNode, showCount, pickerTheme);
265     SetDefaultPickerItemHeight(settingData.height);
266     SetTextProperties(pickerTheme, settingData.properties);
267     auto changeEvent = dialogEvent["changeId"];
268     SetDialogChange(textPickerNode, std::move(changeEvent));
269     auto scrollStopEvent = dialogEvent["scrollStopId"];
270     SetDialogScrollStop(textPickerNode, std::move(scrollStopEvent));
271 
272     ViewStackProcessor::GetInstance()->Finish();
273     textPickerNode->MountToParent(contentColumn);
274     auto dialogNode = DialogView::CreateDialogNode(dialogProperties, contentColumn);
275     CHECK_NULL_RETURN(dialogNode, nullptr);
276     auto dialogPattern = dialogNode->GetPattern<DialogPattern>();
277     CHECK_NULL_RETURN(dialogPattern, nullptr);
278     dialogPattern->SetIsPickerDialog(true);
279 
280     auto closeDialogEvent = CloseDialogEvent(textPickerPattern, dialogNode);
281     auto closeCallBack = [func = std::move(closeDialogEvent)](const GestureEvent& /* info */) {
282         func();
283     };
284 
285     auto pipeline = PipelineContext::GetCurrentContextSafely();
286     CHECK_NULL_RETURN(pipeline, nullptr);
287     float scale = pipeline->GetFontScale();
288     if (NeedAdaptForAging()) {
289         dialogNode = SeparatedOptionsShow(contentColumn, textPickerNode, buttonInfos, settingData,
290             dialogEvent, dialogCancelEvent, scale, closeCallBack, dialogNode);
291         return dialogNode;
292     }
293 
294     auto contentRow =
295         CreateButtonNode(textPickerNode, buttonInfos, dialogEvent, std::move(dialogCancelEvent), closeCallBack);
296     contentRow->AddChild(CreateDividerNode(textPickerNode), 1);
297     contentRow->MountToParent(contentColumn);
298     dialogNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
299     return dialogNode;
300 }
301 
CreateIconItemNode(RefPtr<PickerTheme> pickerTheme)302 RefPtr<FrameNode> TextPickerDialogView::CreateIconItemNode(RefPtr<PickerTheme> pickerTheme)
303 {
304     auto row = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
305         AceType::MakeRefPtr<LinearLayoutPattern>(false));
306     CHECK_NULL_RETURN(row, nullptr);
307     auto layoutProps = row->GetLayoutProperty<LinearLayoutProperty>();
308     CHECK_NULL_RETURN(layoutProps, nullptr);
309     layoutProps->UpdateMainAxisAlign(FlexAlign::CENTER);
310     layoutProps->UpdateCrossAxisAlign(FlexAlign::CENTER);
311 
312     MarginProperty marginProperty;
313     marginProperty.left = CalcLength(pickerTheme->GetPaddingHorizontal());
314     marginProperty.right = CalcLength(pickerTheme->GetPaddingHorizontal());
315     layoutProps->UpdateMargin(marginProperty);
316 
317     auto imageNode = FrameNode::CreateFrameNode(
318         V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>());
319     CHECK_NULL_RETURN(imageNode, nullptr);
320     imageNode->MountToParent(row);
321 
322     return row;
323 }
CreateTextItemNode(RefPtr<PickerTheme> pickerTheme)324 RefPtr<FrameNode> TextPickerDialogView::CreateTextItemNode(RefPtr<PickerTheme> pickerTheme)
325 {
326     auto textNode = FrameNode::CreateFrameNode(
327         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
328     CHECK_NULL_RETURN(textNode, nullptr);
329     auto textLayout = textNode->GetLayoutProperty<TextLayoutProperty>();
330     MarginProperty marginProperty;
331     marginProperty.left = CalcLength(pickerTheme->GetPaddingHorizontal());
332     marginProperty.right = CalcLength(pickerTheme->GetPaddingHorizontal());
333     textLayout->UpdateMargin(marginProperty);
334     return textNode;
335 }
CreateMixtureItemNode(RefPtr<PickerTheme> pickerTheme)336 RefPtr<FrameNode> TextPickerDialogView::CreateMixtureItemNode(RefPtr<PickerTheme> pickerTheme)
337 {
338     auto row = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
339         AceType::MakeRefPtr<LinearLayoutPattern>(false));
340     CHECK_NULL_RETURN(row, nullptr);
341 
342     auto rowProperty = row->GetLayoutProperty<LinearLayoutProperty>();
343     MarginProperty marginProperty;
344     marginProperty.left = CalcLength(pickerTheme->GetPaddingHorizontal());
345     marginProperty.right = CalcLength(pickerTheme->GetPaddingHorizontal());
346     rowProperty->UpdateMargin(marginProperty);
347 
348     auto imageNode = FrameNode::CreateFrameNode(
349         V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>());
350     CHECK_NULL_RETURN(imageNode, nullptr);
351     imageNode->MountToParent(row);
352 
353     auto textNode = FrameNode::CreateFrameNode(
354         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
355     CHECK_NULL_RETURN(textNode, nullptr);
356     textNode->MountToParent(row);
357 
358     return row;
359 }
360 
CreateColumnNode(uint32_t columnKind,uint32_t showCount,RefPtr<PickerTheme> pickerTheme)361 RefPtr<FrameNode> TextPickerDialogView::CreateColumnNode(
362     uint32_t columnKind, uint32_t showCount, RefPtr<PickerTheme> pickerTheme)
363 {
364     auto columnNode =
365         FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
366             []() { return AceType::MakeRefPtr<TextPickerColumnPattern>(); });
367 
368     if (columnKind == ICON) {
369         for (uint32_t index = 0; index < showCount; index++) {
370             auto row = CreateIconItemNode(pickerTheme);
371             CHECK_NULL_RETURN(row, nullptr);
372             row->MountToParent(columnNode);
373         }
374     } else if (columnKind == TEXT) {
375         for (uint32_t index = 0; index < showCount; index++) {
376             auto textNode = CreateTextItemNode(pickerTheme);
377             CHECK_NULL_RETURN(textNode, nullptr);
378             textNode->MountToParent(columnNode);
379         }
380     } else if (columnKind == MIXTURE) {
381         for (uint32_t index = 0; index < showCount; index++) {
382             auto row = CreateMixtureItemNode(pickerTheme);
383             CHECK_NULL_RETURN(row, nullptr);
384             row->MountToParent(columnNode);
385         }
386     }
387     return columnNode;
388 }
389 
CreateStackNode(RefPtr<PickerTheme> pickerTheme)390 RefPtr<FrameNode> TextPickerDialogView::CreateStackNode(RefPtr<PickerTheme> pickerTheme)
391 {
392     auto stackId = ElementRegister::GetInstance()->MakeUniqueId();
393     auto stackNode = FrameNode::GetOrCreateFrameNode(
394         V2::STACK_ETS_TAG, stackId, []() { return AceType::MakeRefPtr<StackPattern>(); });
395 
396     auto stackLayout = stackNode->GetLayoutProperty<LayoutProperty>();
397     MarginProperty marginProperty;
398     marginProperty.top = CalcLength(pickerTheme->GetContentMarginVertical());
399     marginProperty.bottom = CalcLength(pickerTheme->GetContentMarginVertical());
400     stackLayout->UpdateMargin(marginProperty);
401     return stackNode;
402 }
403 
CreateColumnNode()404 RefPtr<FrameNode> TextPickerDialogView::CreateColumnNode()
405 {
406     auto columnId = ElementRegister::GetInstance()->MakeUniqueId();
407     return FrameNode::GetOrCreateFrameNode(
408         V2::COLUMN_ETS_TAG, columnId, []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
409 }
410 
CreateButtonNode()411 RefPtr<FrameNode> TextPickerDialogView::CreateButtonNode()
412 {
413     auto buttonId = ElementRegister::GetInstance()->MakeUniqueId();
414     return FrameNode::GetOrCreateFrameNode(
415         V2::BUTTON_ETS_TAG, buttonId, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
416 }
417 
CreateDividerNode(const RefPtr<FrameNode> & dateNode)418 RefPtr<FrameNode> TextPickerDialogView::CreateDividerNode(const RefPtr<FrameNode>& dateNode)
419 {
420     auto pipeline = PipelineContext::GetCurrentContext();
421     CHECK_NULL_RETURN(pipeline, nullptr);
422     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
423     auto dividerNode = FrameNode::GetOrCreateFrameNode(V2::DIVIDER_ETS_TAG,
424         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<DividerPattern>(); });
425     CHECK_NULL_RETURN(dividerNode, nullptr);
426 
427     auto dividerPaintProps = dividerNode->GetPaintProperty<DividerRenderProperty>();
428     CHECK_NULL_RETURN(dividerPaintProps, nullptr);
429     dividerPaintProps->UpdateDividerColor(dialogTheme->GetDividerColor());
430 
431     auto dividerLayoutProps = dividerNode->GetLayoutProperty<DividerLayoutProperty>();
432     CHECK_NULL_RETURN(dividerLayoutProps, nullptr);
433     dividerLayoutProps->UpdateVertical(true);
434     dividerLayoutProps->UpdateUserDefinedIdealSize(
435         CalcSize(CalcLength(dialogTheme->GetDividerWidth()), CalcLength(dialogTheme->GetDividerHeight())));
436     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
437         MarginProperty margin;
438         margin.top = CalcLength(dialogTheme->GetDividerHeight());
439         margin.bottom = CalcLength(dialogTheme->GetDividerPadding().Bottom());
440         dividerLayoutProps->UpdateMargin(margin);
441         dividerLayoutProps->UpdateUserDefinedIdealSize(
442             CalcSize(CalcLength(dialogTheme->GetDividerWidth()), CalcLength(dialogTheme->GetDividerHeight())));
443     } else {
444         auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
445         auto dividerWrapper = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG,
446             ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<LinearLayoutPattern>(false));
447         CHECK_NULL_RETURN(dividerWrapper, nullptr);
448         auto layoutProps = dividerWrapper->GetLayoutProperty<LinearLayoutProperty>();
449         CHECK_NULL_RETURN(layoutProps, nullptr);
450         MarginProperty margin;
451         margin.top = CalcLength(dialogTheme->GetActionsPadding().Top());
452         margin.bottom = CalcLength(dialogTheme->GetActionsPadding().Bottom());
453         layoutProps->UpdateMargin(margin);
454         layoutProps->UpdateMainAxisAlign(FlexAlign::SPACE_AROUND);
455         layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
456         layoutProps->UpdateUserDefinedIdealSize(CalcSize(
457             CalcLength(dialogTheme->GetActionsPadding().Bottom()), CalcLength(buttonTheme->GetHeight())));
458         dividerNode->MountToParent(dividerWrapper);
459         return dividerWrapper;
460     }
461 
462     return dividerNode;
463 }
464 
CreateButtonNode(const RefPtr<FrameNode> & frameNode,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogTextEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent,GestureEventFunc callback)465 RefPtr<FrameNode> TextPickerDialogView::CreateButtonNode(const RefPtr<FrameNode>& frameNode,
466     const std::vector<ButtonInfo>& buttonInfos, std::map<std::string, NG::DialogTextEvent> dialogEvent,
467     std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent, GestureEventFunc callback)
468 {
469     auto acceptEvent = dialogEvent["acceptId"];
470     auto cancelEvent = dialogCancelEvent["cancelId"];
471     auto contentRow = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
472         AceType::MakeRefPtr<LinearLayoutPattern>(false));
473     CHECK_NULL_RETURN(contentRow, nullptr);
474     auto layoutProps = contentRow->GetLayoutProperty<LinearLayoutProperty>();
475     CHECK_NULL_RETURN(layoutProps, nullptr);
476     layoutProps->UpdateMainAxisAlign(FlexAlign::SPACE_AROUND);
477     layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
478 
479     auto buttonCancelNode = CreateCancelNode(cancelEvent, frameNode, buttonInfos);
480     auto buttonConfirmNode = CreateConfirmNode(frameNode, frameNode, buttonInfos, acceptEvent);
481 
482     buttonCancelNode->MountToParent(contentRow);
483     buttonConfirmNode->MountToParent(contentRow);
484 
485     auto onClick = AceType::MakeRefPtr<NG::ClickEvent>(std::move(callback));
486     for (const auto& child : contentRow->GetChildren()) {
487         auto childNode = AceType::DynamicCast<FrameNode>(child);
488         CHECK_NULL_RETURN(childNode, nullptr);
489         auto gestureHub = childNode->GetOrCreateGestureEventHub();
490         CHECK_NULL_RETURN(gestureHub, nullptr);
491         gestureHub->AddClickEvent(onClick);
492     }
493 
494     return contentRow;
495 }
496 
UpdateButtonConfirmLayoutProperty(const RefPtr<FrameNode> & buttonConfirmNode,RefPtr<PickerTheme> pickerTheme)497 void TextPickerDialogView::UpdateButtonConfirmLayoutProperty(const RefPtr<FrameNode>& buttonConfirmNode,
498     RefPtr<PickerTheme> pickerTheme)
499 {
500     auto buttonConfirmLayoutProperty = buttonConfirmNode->GetLayoutProperty<ButtonLayoutProperty>();
501     CHECK_NULL_VOID(buttonConfirmLayoutProperty);
502     buttonConfirmLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.ok"));
503     buttonConfirmLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
504     buttonConfirmLayoutProperty->UpdateType(ButtonType::CAPSULE);
505     buttonConfirmLayoutProperty->UpdateFlexShrink(1.0);
506     auto pipeline = PipelineBase::GetCurrentContext();
507     CHECK_NULL_VOID(pipeline);
508     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
509     CHECK_NULL_VOID(dialogTheme);
510     UpdateConfirmButtonMargin(buttonConfirmNode, dialogTheme);
511     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
512         buttonConfirmLayoutProperty->UpdateUserDefinedIdealSize(
513             CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
514     } else {
515         auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
516         CHECK_NULL_VOID(buttonTheme);
517         buttonConfirmLayoutProperty->UpdateUserDefinedIdealSize(
518             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
519     }
520 }
521 
CreateConfirmNode(const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & textPickerNode,const std::vector<ButtonInfo> & buttonInfos,DialogEvent & acceptEvent)522 RefPtr<FrameNode> TextPickerDialogView::CreateConfirmNode(const RefPtr<FrameNode>& dateNode,
523     const RefPtr<FrameNode>& textPickerNode, const std::vector<ButtonInfo>& buttonInfos, DialogEvent& acceptEvent)
524 {
525     auto pipeline = PipelineContext::GetCurrentContext();
526     CHECK_NULL_RETURN(pipeline, nullptr);
527     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
528     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
529     auto buttonConfirmNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
530         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
531     auto textConfirmNode = FrameNode::CreateFrameNode(
532         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
533     CHECK_NULL_RETURN(buttonConfirmNode, nullptr);
534     CHECK_NULL_RETURN(textConfirmNode, nullptr);
535     UpdateConfirmButtonTextLayoutProperty(textConfirmNode, pickerTheme);
536     auto textPattern = textPickerNode->GetPattern<TextPickerPattern>();
537     textPattern->SetConfirmNode(buttonConfirmNode);
538     auto buttonConfirmEventHub = buttonConfirmNode->GetEventHub<ButtonEventHub>();
539     CHECK_NULL_RETURN(buttonConfirmEventHub, nullptr);
540     buttonConfirmEventHub->SetStateEffect(true);
541     UpdateButtonConfirmLayoutProperty(buttonConfirmNode, pickerTheme);
542     auto buttonConfirmRenderContext = buttonConfirmNode->GetRenderContext();
543     buttonConfirmRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
544     auto buttonConfirmLayoutProperty = buttonConfirmNode->GetLayoutProperty<ButtonLayoutProperty>();
545     CHECK_NULL_RETURN(buttonConfirmLayoutProperty, nullptr);
546     UpdateButtonStyles(buttonInfos, ACCEPT_BUTTON_INDEX, buttonConfirmLayoutProperty, buttonConfirmRenderContext);
547     UpdateButtonDefaultFocus(buttonInfos, buttonConfirmNode, true);
548 
549     textConfirmNode->MountToParent(buttonConfirmNode);
550     auto eventConfirmHub = buttonConfirmNode->GetOrCreateGestureEventHub();
551     CHECK_NULL_RETURN(eventConfirmHub, nullptr);
552     CHECK_NULL_RETURN(dateNode, nullptr);
553     SetDialogAcceptEvent(dateNode, std::move(acceptEvent));
554     auto clickCallback = [weak = WeakPtr<FrameNode>(dateNode)](const GestureEvent& /* info */) {
555         auto dateNode = weak.Upgrade();
556         CHECK_NULL_VOID(dateNode);
557         auto pickerPattern = dateNode->GetPattern<TextPickerPattern>();
558         CHECK_NULL_VOID(pickerPattern);
559         auto str = pickerPattern->GetSelectedObject(false);
560         auto textPickerEventHub = pickerPattern->GetEventHub<TextPickerEventHub>();
561         CHECK_NULL_VOID(textPickerEventHub);
562         textPickerEventHub->FireDialogAcceptEvent(str);
563         if (Recorder::EventRecorder::Get().IsComponentRecordEnable()) {
564             Recorder::EventParamsBuilder builder;
565             builder.SetType(dateNode->GetTag()).SetEventType(Recorder::EventType::DIALOG_ACCEPT).SetText(str);
566             Recorder::EventRecorder::Get().OnEvent(std::move(builder));
567         }
568     };
569     eventConfirmHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(clickCallback));
570     buttonConfirmNode->MarkModifyDone();
571     return buttonConfirmNode;
572 }
573 
UpdateConfirmButtonTextLayoutProperty(const RefPtr<FrameNode> & textConfirmNode,const RefPtr<PickerTheme> & pickerTheme)574 void TextPickerDialogView::UpdateConfirmButtonTextLayoutProperty(
575     const RefPtr<FrameNode>& textConfirmNode, const RefPtr<PickerTheme>& pickerTheme)
576 {
577     auto textLayoutProperty = textConfirmNode->GetLayoutProperty<TextLayoutProperty>();
578     CHECK_NULL_VOID(textLayoutProperty);
579     textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.ok"));
580     textLayoutProperty->UpdateTextColor(pickerTheme->GetOptionStyle(true, false).GetTextColor());
581     if (!NeedAdaptForAging()) {
582         textLayoutProperty->UpdateMaxFontScale(pickerTheme->GetNormalFontScale());
583     }
584     textLayoutProperty->UpdateFontSize(
585         ConvertFontScaleValue(pickerTheme->GetOptionStyle(false, false).GetFontSize()));
586     textLayoutProperty->UpdateFontWeight(pickerTheme->GetOptionStyle(true, false).GetFontWeight());
587 }
588 
UpdateCancelButtonTextLayoutProperty(const RefPtr<FrameNode> & textCancelNode,const RefPtr<PickerTheme> & pickerTheme)589 void TextPickerDialogView::UpdateCancelButtonTextLayoutProperty(
590     const RefPtr<FrameNode>& textCancelNode, const RefPtr<PickerTheme>& pickerTheme)
591 {
592     auto textCancelLayoutProperty = textCancelNode->GetLayoutProperty<TextLayoutProperty>();
593     CHECK_NULL_VOID(textCancelLayoutProperty);
594     textCancelLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.cancel"));
595     textCancelLayoutProperty->UpdateTextColor(pickerTheme->GetOptionStyle(true, false).GetTextColor());
596     if (!NeedAdaptForAging()) {
597         textCancelLayoutProperty->UpdateMaxFontScale(pickerTheme->GetNormalFontScale());
598     }
599     textCancelLayoutProperty->UpdateFontSize(
600         ConvertFontScaleValue(pickerTheme->GetOptionStyle(false, false).GetFontSize()));
601     textCancelLayoutProperty->UpdateFontWeight(pickerTheme->GetOptionStyle(true, false).GetFontWeight());
602 }
603 
UpdateForwardButtonTextLayoutProperty(const RefPtr<FrameNode> & textForwardNode,const RefPtr<PickerTheme> & pickerTheme)604 void TextPickerDialogView::UpdateForwardButtonTextLayoutProperty(
605     const RefPtr<FrameNode>& textForwardNode, const RefPtr<PickerTheme>& pickerTheme)
606 {
607     auto textForwardLayoutProperty = textForwardNode->GetLayoutProperty<TextLayoutProperty>();
608     CHECK_NULL_VOID(textForwardLayoutProperty);
609     auto pickerThemeOptionStyle = pickerTheme->GetOptionStyle(true, false);
610     textForwardLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.next"));
611     textForwardLayoutProperty->UpdateTextColor(pickerThemeOptionStyle.GetTextColor());
612     textForwardLayoutProperty->UpdateFontSize(
613         ConvertFontScaleValue(pickerTheme->GetOptionStyle(false, false).GetFontSize()));
614     textForwardLayoutProperty->UpdateFontWeight(pickerThemeOptionStyle.GetFontWeight());
615 }
616 
UpdateBackwardButtonTextLayoutProperty(const RefPtr<FrameNode> & textBackwardNode,const RefPtr<PickerTheme> & pickerTheme)617 void TextPickerDialogView::UpdateBackwardButtonTextLayoutProperty(
618     const RefPtr<FrameNode>& textBackwardNode, const RefPtr<PickerTheme>& pickerTheme)
619 {
620     auto textBackwardLayoutProperty = textBackwardNode->GetLayoutProperty<TextLayoutProperty>();
621     CHECK_NULL_VOID(textBackwardLayoutProperty);
622     auto pickerThemeOptionStyle = pickerTheme->GetOptionStyle(true, false);
623     textBackwardLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.prev"));
624     textBackwardLayoutProperty->UpdateTextColor(pickerThemeOptionStyle.GetTextColor());
625     textBackwardLayoutProperty->UpdateFontSize(
626         ConvertFontScaleValue(pickerTheme->GetOptionStyle(false, false).GetFontSize()));
627     textBackwardLayoutProperty->UpdateFontWeight(pickerThemeOptionStyle.GetFontWeight());
628 }
629 
UpdateConfirmButtonMargin(const RefPtr<FrameNode> & buttonConfirmNode,const RefPtr<DialogTheme> & dialogTheme)630 void TextPickerDialogView::UpdateConfirmButtonMargin(
631     const RefPtr<FrameNode>& buttonConfirmNode, const RefPtr<DialogTheme>& dialogTheme)
632 {
633     MarginProperty margin;
634     bool isRtl = AceApplicationInfo::GetInstance().IsRightToLeft();
635     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
636         margin.top = CalcLength(dialogTheme->GetDividerHeight());
637         margin.bottom = CalcLength(dialogTheme->GetDividerPadding().Bottom());
638         if (isRtl) {
639             margin.right = CalcLength(0.0_vp);
640             margin.left = CalcLength(dialogTheme->GetDividerPadding().Left());
641         } else {
642             margin.right = CalcLength(dialogTheme->GetDividerPadding().Right());
643             margin.left = CalcLength(0.0_vp);
644         }
645 
646     } else {
647         margin.top = CalcLength(dialogTheme->GetActionsPadding().Top());
648         margin.bottom = CalcLength(dialogTheme->GetActionsPadding().Bottom());
649         if (isRtl) {
650             margin.right = CalcLength(0.0_vp);
651             margin.left = CalcLength(dialogTheme->GetActionsPadding().Left());
652         } else {
653             margin.right = CalcLength(dialogTheme->GetActionsPadding().Right());
654             margin.left = CalcLength(0.0_vp);
655         }
656     }
657     buttonConfirmNode->GetLayoutProperty()->UpdateMargin(margin);
658 }
659 
UpdateCancelButtonMargin(const RefPtr<FrameNode> & buttonCancelNode,const RefPtr<DialogTheme> & dialogTheme)660 void TextPickerDialogView::UpdateCancelButtonMargin(
661     const RefPtr<FrameNode>& buttonCancelNode, const RefPtr<DialogTheme>& dialogTheme)
662 {
663     MarginProperty margin;
664     bool isRtl = AceApplicationInfo::GetInstance().IsRightToLeft();
665     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
666         margin.top = CalcLength(dialogTheme->GetDividerHeight());
667         margin.bottom = CalcLength(dialogTheme->GetDividerPadding().Bottom());
668         if (isRtl) {
669             margin.right = CalcLength(dialogTheme->GetDividerPadding().Right());
670             margin.left = CalcLength(0.0_vp);
671         } else {
672             margin.right = CalcLength(0.0_vp);
673             margin.left = CalcLength(dialogTheme->GetDividerPadding().Left());
674         }
675     } else {
676         margin.top = CalcLength(dialogTheme->GetActionsPadding().Top());
677         margin.bottom = CalcLength(dialogTheme->GetActionsPadding().Bottom());
678         if (isRtl) {
679             margin.right = CalcLength(dialogTheme->GetActionsPadding().Right());
680             margin.left = CalcLength(0.0_vp);
681         } else {
682             margin.right = CalcLength(0.0_vp);
683             margin.left = CalcLength(dialogTheme->GetActionsPadding().Left());
684         }
685     }
686     buttonCancelNode->GetLayoutProperty()->UpdateMargin(margin);
687 }
688 
UpdateForwardButtonMargin(const RefPtr<FrameNode> & buttonForwardNode,const RefPtr<DialogTheme> & dialogTheme)689 void TextPickerDialogView::UpdateForwardButtonMargin(
690     const RefPtr<FrameNode>& buttonForwardNode, const RefPtr<DialogTheme>& dialogTheme)
691 {
692     MarginProperty margin;
693     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
694         margin.right = CalcLength(dialogTheme->GetDividerPadding().Right());
695         margin.top = CalcLength(dialogTheme->GetDividerHeight());
696         margin.bottom = CalcLength(dialogTheme->GetDividerPadding().Bottom());
697         margin.left = CalcLength(0.0_vp);
698     } else {
699         margin.right = CalcLength(dialogTheme->GetDividerPadding().Right());
700         margin.top = CalcLength(dialogTheme->GetActionsPadding().Top());
701         margin.bottom = CalcLength(dialogTheme->GetActionsPadding().Bottom());
702         margin.left = CalcLength(0.0_vp);
703     }
704     buttonForwardNode->GetLayoutProperty()->UpdateMargin(margin);
705 }
706 
UpdateBackwardButtonMargin(const RefPtr<FrameNode> & buttonBackwardNode,const RefPtr<DialogTheme> & dialogTheme)707 void TextPickerDialogView::UpdateBackwardButtonMargin(
708     const RefPtr<FrameNode>& buttonBackwardNode, const RefPtr<DialogTheme>& dialogTheme)
709 {
710     MarginProperty margin;
711     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
712         margin.left = CalcLength(dialogTheme->GetDividerPadding().Left());
713         margin.top = CalcLength(dialogTheme->GetDividerHeight());
714         margin.bottom = CalcLength(dialogTheme->GetDividerPadding().Bottom());
715         margin.right = CalcLength(0.0_vp);
716     } else {
717         margin.left = CalcLength(dialogTheme->GetActionsPadding().Left());
718         margin.top = CalcLength(dialogTheme->GetActionsPadding().Top());
719         margin.bottom = CalcLength(dialogTheme->GetActionsPadding().Bottom());
720         margin.right = CalcLength(0.0_vp);
721     }
722     buttonBackwardNode->GetLayoutProperty()->UpdateMargin(margin);
723 }
724 
UpdateButtonStyles(const std::vector<ButtonInfo> & buttonInfos,size_t index,const RefPtr<ButtonLayoutProperty> & buttonLayoutProperty,const RefPtr<RenderContext> & buttonRenderContext)725 void TextPickerDialogView::UpdateButtonStyles(const std::vector<ButtonInfo>& buttonInfos, size_t index,
726     const RefPtr<ButtonLayoutProperty>& buttonLayoutProperty, const RefPtr<RenderContext>& buttonRenderContext)
727 {
728     if (index >= buttonInfos.size()) {
729         return;
730     }
731     CHECK_NULL_VOID(buttonLayoutProperty);
732     CHECK_NULL_VOID(buttonRenderContext);
733     auto pipeline = PipelineContext::GetCurrentContextSafelyWithCheck();
734     CHECK_NULL_VOID(pipeline);
735     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
736     CHECK_NULL_VOID(buttonTheme);
737     if (buttonInfos[index].type.has_value()) {
738         buttonLayoutProperty->UpdateType(buttonInfos[index].type.value());
739     }
740     UpdateButtonStyleAndRole(buttonInfos, index, buttonLayoutProperty, buttonRenderContext, buttonTheme);
741     if (buttonInfos[index].fontSize.has_value()) {
742         buttonLayoutProperty->UpdateFontSize(ConvertFontScaleValue(buttonInfos[index].fontSize.value()));
743     }
744     if (buttonInfos[index].fontColor.has_value()) {
745         buttonLayoutProperty->UpdateFontColor(buttonInfos[index].fontColor.value());
746     }
747     if (buttonInfos[index].fontWeight.has_value()) {
748         buttonLayoutProperty->UpdateFontWeight(buttonInfos[index].fontWeight.value());
749     }
750     if (buttonInfos[index].fontStyle.has_value()) {
751         buttonLayoutProperty->UpdateFontStyle(buttonInfos[index].fontStyle.value());
752     }
753     if (buttonInfos[index].fontFamily.has_value()) {
754         buttonLayoutProperty->UpdateFontFamily(buttonInfos[index].fontFamily.value());
755     }
756     if (buttonInfos[index].borderRadius.has_value()) {
757         buttonLayoutProperty->UpdateBorderRadius(buttonInfos[index].borderRadius.value());
758     }
759     if (buttonInfos[index].backgroundColor.has_value()) {
760         buttonRenderContext->UpdateBackgroundColor(buttonInfos[index].backgroundColor.value());
761     }
762 }
763 
UpdateButtonStyleAndRole(const std::vector<ButtonInfo> & buttonInfos,size_t index,const RefPtr<ButtonLayoutProperty> & buttonLayoutProperty,const RefPtr<RenderContext> & buttonRenderContext,const RefPtr<ButtonTheme> & buttonTheme)764 void TextPickerDialogView::UpdateButtonStyleAndRole(const std::vector<ButtonInfo>& buttonInfos, size_t index,
765     const RefPtr<ButtonLayoutProperty>& buttonLayoutProperty, const RefPtr<RenderContext>& buttonRenderContext,
766     const RefPtr<ButtonTheme>& buttonTheme)
767 {
768     if (index >= buttonInfos.size()) {
769         return;
770     }
771     CHECK_NULL_VOID(buttonLayoutProperty);
772     CHECK_NULL_VOID(buttonRenderContext);
773     CHECK_NULL_VOID(buttonTheme);
774     if (buttonInfos[index].role.has_value()) {
775         buttonLayoutProperty->UpdateButtonRole(buttonInfos[index].role.value());
776         ButtonStyleMode buttonStyleMode;
777         if (buttonInfos[index].buttonStyle.has_value()) {
778             buttonStyleMode = buttonInfos[index].buttonStyle.value();
779         } else {
780             buttonStyleMode = buttonLayoutProperty->GetButtonStyle().value_or(ButtonStyleMode::EMPHASIZE);
781         }
782         auto bgColor = buttonTheme->GetBgColor(buttonStyleMode, buttonInfos[index].role.value());
783         auto textColor = buttonTheme->GetTextColor(buttonStyleMode, buttonInfos[index].role.value());
784         buttonRenderContext->UpdateBackgroundColor(bgColor);
785         buttonLayoutProperty->UpdateFontColor(textColor);
786     }
787     if (buttonInfos[index].buttonStyle.has_value()) {
788         buttonLayoutProperty->UpdateButtonStyle(buttonInfos[index].buttonStyle.value());
789         ButtonRole buttonRole = buttonLayoutProperty->GetButtonRole().value_or(ButtonRole::NORMAL);
790         auto bgColor = buttonTheme->GetBgColor(buttonInfos[index].buttonStyle.value(), buttonRole);
791         auto textColor = buttonTheme->GetTextColor(buttonInfos[index].buttonStyle.value(), buttonRole);
792         buttonRenderContext->UpdateBackgroundColor(bgColor);
793         buttonLayoutProperty->UpdateFontColor(textColor);
794     }
795 }
796 
CreateCancelNode(NG::DialogGestureEvent & cancelEvent,const RefPtr<FrameNode> & textPickerNode,const std::vector<ButtonInfo> & buttonInfos)797 RefPtr<FrameNode> TextPickerDialogView::CreateCancelNode(NG::DialogGestureEvent& cancelEvent,
798     const RefPtr<FrameNode>& textPickerNode, const std::vector<ButtonInfo>& buttonInfos)
799 {
800     auto pipeline = PipelineContext::GetCurrentContext();
801     CHECK_NULL_RETURN(pipeline, nullptr);
802     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
803     auto buttonCancelNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
804         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
805     CHECK_NULL_RETURN(buttonCancelNode, nullptr);
806     auto textCancelNode = FrameNode::CreateFrameNode(
807         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
808     CHECK_NULL_RETURN(textCancelNode, nullptr);
809     auto textCancelLayoutProperty = textCancelNode->GetLayoutProperty<TextLayoutProperty>();
810     UpdateCancelButtonTextLayoutProperty(textCancelNode, pickerTheme);
811     auto textPattern = textPickerNode->GetPattern<TextPickerPattern>();
812     textPattern->SetCancelNode(buttonCancelNode);
813     textCancelNode->MountToParent(buttonCancelNode);
814     auto eventCancelHub = buttonCancelNode->GetOrCreateGestureEventHub();
815     CHECK_NULL_RETURN(eventCancelHub, nullptr);
816     eventCancelHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(std::move(cancelEvent)));
817     auto recordEvent = [](GestureEvent& info) {
818         if (Recorder::EventRecorder::Get().IsComponentRecordEnable()) {
819             Recorder::EventParamsBuilder builder;
820             builder.SetType("TextPickerDialog").SetEventType(Recorder::EventType::DIALOG_CANCEL);
821             Recorder::EventRecorder::Get().OnEvent(std::move(builder));
822         }
823     };
824     auto recordEventPtr = AceType::MakeRefPtr<ClickEvent>(std::move(recordEvent));
825     eventCancelHub->AddClickEvent(recordEventPtr);
826 
827     auto buttonCancelEventHub = buttonCancelNode->GetEventHub<ButtonEventHub>();
828     CHECK_NULL_RETURN(buttonCancelEventHub, nullptr);
829     buttonCancelEventHub->SetStateEffect(true);
830 
831     UpdateButtonCancelLayoutProperty(buttonCancelNode, pipeline);
832 
833     auto buttonCancelRenderContext = buttonCancelNode->GetRenderContext();
834     buttonCancelRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
835     auto buttonCancelLayoutProperty = buttonCancelNode->GetLayoutProperty<ButtonLayoutProperty>();
836     UpdateButtonStyles(buttonInfos, CANCEL_BUTTON_INDEX, buttonCancelLayoutProperty, buttonCancelRenderContext);
837     UpdateButtonDefaultFocus(buttonInfos, buttonCancelNode, false);
838 
839     buttonCancelNode->MarkModifyDone();
840     return buttonCancelNode;
841 }
842 
843 
UpdateButtonCancelLayoutProperty(const RefPtr<FrameNode> & buttonCancelNode,const RefPtr<PipelineContext> & pipeline)844 void TextPickerDialogView::UpdateButtonCancelLayoutProperty(
845     const RefPtr<FrameNode>& buttonCancelNode, const RefPtr<PipelineContext>& pipeline)
846 {
847     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
848     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
849     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
850     UpdateCancelButtonMargin(buttonCancelNode, dialogTheme);
851     auto buttonCancelLayoutProperty = buttonCancelNode->GetLayoutProperty<ButtonLayoutProperty>();
852     buttonCancelLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.cancel"));
853     buttonCancelLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
854     buttonCancelLayoutProperty->UpdateType(ButtonType::CAPSULE);
855     buttonCancelLayoutProperty->UpdateFlexShrink(1.0);
856     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
857         buttonCancelLayoutProperty->UpdateUserDefinedIdealSize(
858             CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
859     } else {
860         buttonCancelLayoutProperty->UpdateUserDefinedIdealSize(
861             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
862     }
863 }
864 
UpdateButtonForwardLayoutProperty(const RefPtr<FrameNode> & buttonForwardNode,const RefPtr<PipelineContext> & pipeline)865 void TextPickerDialogView::UpdateButtonForwardLayoutProperty(
866     const RefPtr<FrameNode>& buttonForwardNode, const RefPtr<PipelineContext>& pipeline)
867 {
868     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
869     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
870     CHECK_NULL_VOID(buttonTheme);
871     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
872     CHECK_NULL_VOID(pickerTheme);
873     UpdateForwardButtonMargin(buttonForwardNode, dialogTheme);
874     auto buttonForwardLayoutProperty = buttonForwardNode->GetLayoutProperty<ButtonLayoutProperty>();
875     buttonForwardLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.next"));
876     buttonForwardLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
877     buttonForwardLayoutProperty->UpdateType(ButtonType::CAPSULE);
878     buttonForwardLayoutProperty->UpdateFlexShrink(1.0);
879     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
880         buttonForwardLayoutProperty->UpdateUserDefinedIdealSize(
881             CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
882     } else {
883         buttonForwardLayoutProperty->UpdateUserDefinedIdealSize(
884             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
885     }
886 }
887 
UpdateButtonBackwardLayoutProperty(const RefPtr<FrameNode> & buttonBackwardNode,const RefPtr<PipelineContext> & pipeline)888 void TextPickerDialogView::UpdateButtonBackwardLayoutProperty(
889     const RefPtr<FrameNode>& buttonBackwardNode, const RefPtr<PipelineContext>& pipeline)
890 {
891     CHECK_NULL_VOID(pipeline);
892     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
893     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
894     CHECK_NULL_VOID(buttonTheme);
895     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
896     CHECK_NULL_VOID(pickerTheme);
897     UpdateBackwardButtonMargin(buttonBackwardNode, dialogTheme);
898     auto buttonBackwardLayoutProperty = buttonBackwardNode->GetLayoutProperty<ButtonLayoutProperty>();
899     buttonBackwardLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.prev"));
900     buttonBackwardLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
901     buttonBackwardLayoutProperty->UpdateType(ButtonType::CAPSULE);
902     buttonBackwardLayoutProperty->UpdateFlexShrink(1.0);
903     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
904         buttonBackwardLayoutProperty->UpdateUserDefinedIdealSize(
905             CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
906     } else {
907         buttonBackwardLayoutProperty->UpdateUserDefinedIdealSize(
908             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
909     }
910 }
911 
SetSelected(const RefPtr<TextPickerPattern> & textPickerPattern,uint32_t value)912 void TextPickerDialogView::SetSelected(const RefPtr<TextPickerPattern>& textPickerPattern, uint32_t value)
913 {
914     textPickerPattern->SetSelected(value);
915     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, Selected, value);
916 }
917 
SetSelectedValues(const RefPtr<TextPickerPattern> & textPickerPattern,const std::vector<uint32_t> & values)918 void TextPickerDialogView::SetSelectedValues(
919     const RefPtr<TextPickerPattern>& textPickerPattern, const std::vector<uint32_t>& values)
920 {
921     textPickerPattern->SetSelecteds(values);
922     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, Selecteds, values);
923 }
924 
SetValues(const RefPtr<TextPickerPattern> & textPickerPattern,const std::vector<std::string> & values)925 void TextPickerDialogView::SetValues(
926     const RefPtr<TextPickerPattern>& textPickerPattern, const std::vector<std::string>& values)
927 {
928     textPickerPattern->SetValues(values);
929     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, Values, values);
930 }
931 
SetRange(const RefPtr<TextPickerPattern> & textPickerPattern,const std::vector<NG::RangeContent> & value)932 void TextPickerDialogView::SetRange(
933     const RefPtr<TextPickerPattern>& textPickerPattern, const std::vector<NG::RangeContent>& value)
934 {
935     textPickerPattern->SetRange(value);
936 }
937 
SetTextProperties(const RefPtr<PickerTheme> & pickerTheme,const PickerTextProperties & properties)938 void TextPickerDialogView::SetTextProperties(
939     const RefPtr<PickerTheme>& pickerTheme, const PickerTextProperties& properties)
940 {
941     CHECK_NULL_VOID(pickerTheme);
942     auto selectedStyle = pickerTheme->GetOptionStyle(true, false);
943     auto normalStyle = pickerTheme->GetOptionStyle(false, false);
944 
945     SetTextDisappearProperties(pickerTheme, properties);
946 
947     if (properties.normalTextStyle_.fontSize.has_value() && properties.normalTextStyle_.fontSize->IsValid()) {
948         ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, FontSize,
949             ConvertFontScaleValue(properties.normalTextStyle_.fontSize.value(), normalTextStyleFont_, true));
950     } else {
951         ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, FontSize,
952             ConvertFontScaleValue(normalStyle.GetFontSize()));
953     }
954     ACE_UPDATE_LAYOUT_PROPERTY(
955         TextPickerLayoutProperty, Color, properties.normalTextStyle_.textColor.value_or(normalStyle.GetTextColor()));
956     ACE_UPDATE_LAYOUT_PROPERTY(
957         TextPickerLayoutProperty, Weight, properties.normalTextStyle_.fontWeight.value_or(normalStyle.GetFontWeight()));
958     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, FontFamily,
959         properties.normalTextStyle_.fontFamily.value_or(normalStyle.GetFontFamilies()));
960     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, FontStyle,
961         properties.normalTextStyle_.fontStyle.value_or(normalStyle.GetFontStyle()));
962 
963     if (properties.selectedTextStyle_.fontSize.has_value() && properties.selectedTextStyle_.fontSize->IsValid()) {
964         ACE_UPDATE_LAYOUT_PROPERTY(
965             TextPickerLayoutProperty, SelectedFontSize,
966             ConvertFontScaleValue(properties.selectedTextStyle_.fontSize.value(), selectedTextStyleFont_, true));
967     } else {
968         ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, SelectedFontSize,
969             ConvertFontScaleValue(selectedStyle.GetFontSize()));
970     }
971     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, SelectedColor,
972         properties.selectedTextStyle_.textColor.value_or(selectedStyle.GetTextColor()));
973     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, SelectedWeight,
974         properties.selectedTextStyle_.fontWeight.value_or(selectedStyle.GetFontWeight()));
975     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, SelectedFontFamily,
976         properties.selectedTextStyle_.fontFamily.value_or(selectedStyle.GetFontFamilies()));
977     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, SelectedFontStyle,
978         properties.selectedTextStyle_.fontStyle.value_or(selectedStyle.GetFontStyle()));
979 }
980 
SetTextDisappearProperties(const RefPtr<PickerTheme> & pickerTheme,const PickerTextProperties & properties)981 void TextPickerDialogView::SetTextDisappearProperties(
982     const RefPtr<PickerTheme>& pickerTheme, const PickerTextProperties& properties)
983 
984 {
985     CHECK_NULL_VOID(pickerTheme);
986     auto disappearStyle = pickerTheme->GetDisappearOptionStyle();
987     if (properties.disappearTextStyle_.fontSize.has_value() && properties.disappearTextStyle_.fontSize->IsValid()) {
988         ACE_UPDATE_LAYOUT_PROPERTY(
989             TextPickerLayoutProperty, DisappearFontSize,
990             ConvertFontScaleValue(properties.disappearTextStyle_.fontSize.value(), disappearTextStyleFont_, true));
991     } else {
992         ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, DisappearFontSize,
993             ConvertFontScaleValue(disappearStyle.GetFontSize()));
994     }
995     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, DisappearColor,
996         properties.disappearTextStyle_.textColor.value_or(disappearStyle.GetTextColor()));
997     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, DisappearWeight,
998         properties.disappearTextStyle_.fontWeight.value_or(disappearStyle.GetFontWeight()));
999     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, DisappearFontFamily,
1000         properties.disappearTextStyle_.fontFamily.value_or(disappearStyle.GetFontFamilies()));
1001     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, DisappearFontStyle,
1002         properties.disappearTextStyle_.fontStyle.value_or(disappearStyle.GetFontStyle()));
1003 }
1004 
SetDialogChange(const RefPtr<FrameNode> & frameNode,DialogTextEvent && onChange)1005 void TextPickerDialogView::SetDialogChange(const RefPtr<FrameNode>& frameNode, DialogTextEvent&& onChange)
1006 {
1007     CHECK_NULL_VOID(frameNode);
1008     auto eventHub = frameNode->GetEventHub<TextPickerEventHub>();
1009     CHECK_NULL_VOID(eventHub);
1010     eventHub->SetDialogChange(std::move(onChange));
1011 }
1012 
SetDialogScrollStop(const RefPtr<FrameNode> & frameNode,DialogTextEvent && onScrollStop)1013 void TextPickerDialogView::SetDialogScrollStop(const RefPtr<FrameNode>& frameNode, DialogTextEvent&& onScrollStop)
1014 {
1015     CHECK_NULL_VOID(frameNode);
1016     auto eventHub = frameNode->GetEventHub<TextPickerEventHub>();
1017     CHECK_NULL_VOID(eventHub);
1018     eventHub->SetDialogScrollStop(std::move(onScrollStop));
1019 }
1020 
SetDefaultPickerItemHeight(const Dimension & value)1021 void TextPickerDialogView::SetDefaultPickerItemHeight(const Dimension& value)
1022 {
1023     ACE_UPDATE_LAYOUT_PROPERTY(TextPickerLayoutProperty, DefaultPickerItemHeight, value);
1024 }
1025 
SetDialogAcceptEvent(const RefPtr<FrameNode> & frameNode,DialogTextEvent && onChange)1026 void TextPickerDialogView::SetDialogAcceptEvent(const RefPtr<FrameNode>& frameNode, DialogTextEvent&& onChange)
1027 {
1028     CHECK_NULL_VOID(frameNode);
1029     auto eventHub = frameNode->GetEventHub<TextPickerEventHub>();
1030     CHECK_NULL_VOID(eventHub);
1031     eventHub->SetDialogAcceptEvent(std::move(onChange));
1032 }
1033 
InitOnKeyEvent(const RefPtr<FocusHub> & focusHub)1034 void TextPickerDialogView::InitOnKeyEvent(const RefPtr<FocusHub>& focusHub)
1035 {
1036     auto onKeyEvent = [](const KeyEvent& event) -> bool { return TextPickerDialogView::OnKeyEvent(event); };
1037     focusHub->SetOnKeyEventInternal(std::move(onKeyEvent));
1038 }
OnKeyEvent(const KeyEvent & event)1039 bool TextPickerDialogView::OnKeyEvent(const KeyEvent& event)
1040 {
1041     if (event.action != KeyAction::DOWN) {
1042         return false;
1043     }
1044 
1045     if (event.code == KeyCode::KEY_ESCAPE) {
1046         auto dialogNode = dialogNode_.Upgrade();
1047         CHECK_NULL_RETURN(dialogNode, false);
1048         auto pipeline = dialogNode->GetContext();
1049         CHECK_NULL_RETURN(pipeline, false);
1050         auto overlayManager = pipeline->GetOverlayManager();
1051         CHECK_NULL_RETURN(overlayManager, false);
1052         overlayManager->CloseDialog(dialogNode);
1053         return true;
1054     }
1055 
1056     return false;
1057 }
1058 
UpdateButtonDefaultFocus(const std::vector<ButtonInfo> & buttonInfos,const RefPtr<FrameNode> & buttonNode,bool isConfirm)1059 void TextPickerDialogView::UpdateButtonDefaultFocus(const std::vector<ButtonInfo>& buttonInfos,
1060     const RefPtr<FrameNode>& buttonNode, bool isConfirm)
1061 {
1062     bool setDefaultFocus = false;
1063     if (buttonInfos.size() > CANCEL_BUTTON_INDEX) {
1064         if (buttonInfos[ACCEPT_BUTTON_INDEX].isPrimary && buttonInfos[CANCEL_BUTTON_INDEX].isPrimary) {
1065             return;
1066         }
1067         auto index = isConfirm ? ACCEPT_BUTTON_INDEX : CANCEL_BUTTON_INDEX;
1068         if (buttonInfos[index].isPrimary) {
1069             setDefaultFocus = true;
1070         }
1071     } else if (buttonInfos.size() == CANCEL_BUTTON_INDEX) {
1072         bool isAcceptButtonPrimary = (buttonInfos[0].isAcceptButton && isConfirm && buttonInfos[0].isPrimary);
1073         bool isCancelButtonPrimary = (!buttonInfos[0].isAcceptButton && !isConfirm && buttonInfos[0].isPrimary);
1074         if (isAcceptButtonPrimary || isCancelButtonPrimary) {
1075             setDefaultFocus = true;
1076         }
1077     }
1078     if (setDefaultFocus && buttonNode) {
1079         auto focusHub = buttonNode->GetOrCreateFocusHub();
1080         if (focusHub) {
1081             focusHub->SetIsDefaultFocus(true);
1082         }
1083     }
1084 }
1085 
CreateForwardNode(NG::DialogGestureEvent & moveForwardEvent,const RefPtr<FrameNode> & textPickerNode,const std::vector<ButtonInfo> & buttonInfos)1086 RefPtr<FrameNode> TextPickerDialogView::CreateForwardNode(NG::DialogGestureEvent& moveForwardEvent,
1087     const RefPtr<FrameNode>& textPickerNode, const std::vector<ButtonInfo>& buttonInfos)
1088 {
1089     CHECK_NULL_RETURN(textPickerNode, nullptr);
1090     auto pipeline = PipelineContext::GetCurrentContextSafely();
1091     CHECK_NULL_RETURN(pipeline, nullptr);
1092     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1093     CHECK_NULL_RETURN(pickerTheme, nullptr);
1094     auto buttonForwardNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
1095         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1096     CHECK_NULL_RETURN(buttonForwardNode, nullptr);
1097     auto textForwardNode = FrameNode::CreateFrameNode(
1098         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
1099     CHECK_NULL_RETURN(textForwardNode, nullptr);
1100     UpdateForwardButtonTextLayoutProperty(textForwardNode, pickerTheme);
1101     auto textPattern = textPickerNode->GetPattern<TextPickerPattern>();
1102     textPattern->SetForwardNode(buttonForwardNode);
1103     textForwardNode->MountToParent(buttonForwardNode);
1104     auto eventForwardHub = buttonForwardNode->GetOrCreateGestureEventHub();
1105     CHECK_NULL_RETURN(eventForwardHub, nullptr);
1106     eventForwardHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(std::move(moveForwardEvent)));
1107     auto recordEvent = [](GestureEvent& info) {
1108         if (Recorder::EventRecorder::Get().IsComponentRecordEnable()) {
1109             Recorder::EventParamsBuilder builder;
1110             builder.SetType("TextPickerDialog").SetEventType(Recorder::EventType::STEPPER_NEXT);
1111             Recorder::EventRecorder::Get().OnEvent(std::move(builder));
1112         }
1113     };
1114     auto recordEventPtr = AceType::MakeRefPtr<ClickEvent>(std::move(recordEvent));
1115     eventForwardHub->AddClickEvent(recordEventPtr);
1116 
1117     auto buttonForwardEventHub = buttonForwardNode->GetEventHub<ButtonEventHub>();
1118     CHECK_NULL_RETURN(buttonForwardEventHub, nullptr);
1119     buttonForwardEventHub->SetStateEffect(true);
1120 
1121     UpdateButtonForwardLayoutProperty(buttonForwardNode, pipeline);
1122 
1123     const auto& buttonForwardRenderContext = buttonForwardNode->GetRenderContext();
1124     buttonForwardRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
1125     auto buttonForwardLayoutProperty = buttonForwardNode->GetLayoutProperty<ButtonLayoutProperty>();
1126     UpdateButtonStyles(buttonInfos, ACCEPT_BUTTON_INDEX, buttonForwardLayoutProperty, buttonForwardRenderContext);
1127     UpdateButtonDefaultFocus(buttonInfos, buttonForwardNode, false);
1128 
1129     buttonForwardNode->MarkModifyDone();
1130     return buttonForwardNode;
1131 }
1132 
CreateBackwardNode(NG::DialogGestureEvent & moveBackwardEvent,const RefPtr<FrameNode> & textPickerNode,const std::vector<ButtonInfo> & buttonInfos)1133 RefPtr<FrameNode> TextPickerDialogView::CreateBackwardNode(NG::DialogGestureEvent& moveBackwardEvent,
1134     const RefPtr<FrameNode>& textPickerNode, const std::vector<ButtonInfo>& buttonInfos)
1135 {
1136     CHECK_NULL_RETURN(textPickerNode, nullptr);
1137     auto pipeline = PipelineContext::GetCurrentContextSafely();
1138     CHECK_NULL_RETURN(pipeline, nullptr);
1139     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1140     CHECK_NULL_RETURN(pickerTheme, nullptr);
1141     auto buttonBackwardNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
1142         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1143     CHECK_NULL_RETURN(buttonBackwardNode, nullptr);
1144     auto textBackwardNode = FrameNode::CreateFrameNode(
1145         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
1146     CHECK_NULL_RETURN(textBackwardNode, nullptr);
1147     UpdateBackwardButtonTextLayoutProperty(textBackwardNode, pickerTheme);
1148     auto textPattern = textPickerNode->GetPattern<TextPickerPattern>();
1149     textPattern->SetBackwardNode(buttonBackwardNode);
1150     textBackwardNode->MountToParent(buttonBackwardNode);
1151     auto eventBackwardHub = buttonBackwardNode->GetOrCreateGestureEventHub();
1152     CHECK_NULL_RETURN(eventBackwardHub, nullptr);
1153     eventBackwardHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(std::move(moveBackwardEvent)));
1154     auto recordEvent = [](GestureEvent& info) {
1155         if (Recorder::EventRecorder::Get().IsComponentRecordEnable()) {
1156             Recorder::EventParamsBuilder builder;
1157             builder.SetType("TextPickerDialog").SetEventType(Recorder::EventType::STEPPER_NEXT);
1158             Recorder::EventRecorder::Get().OnEvent(std::move(builder));
1159         }
1160     };
1161     auto recordEventPtr = AceType::MakeRefPtr<ClickEvent>(std::move(recordEvent));
1162     eventBackwardHub->AddClickEvent(recordEventPtr);
1163 
1164     auto buttonBackwardEventHub = buttonBackwardNode->GetEventHub<ButtonEventHub>();
1165     CHECK_NULL_RETURN(buttonBackwardEventHub, nullptr);
1166     buttonBackwardEventHub->SetStateEffect(true);
1167 
1168     UpdateButtonBackwardLayoutProperty(buttonBackwardNode, pipeline);
1169 
1170     const auto& buttonBackwardRenderContext = buttonBackwardNode->GetRenderContext();
1171     buttonBackwardRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
1172     auto buttonBackwardLayoutProperty = buttonBackwardNode->GetLayoutProperty<ButtonLayoutProperty>();
1173     UpdateButtonStyles(buttonInfos, CANCEL_BUTTON_INDEX, buttonBackwardLayoutProperty, buttonBackwardRenderContext);
1174     UpdateButtonDefaultFocus(buttonInfos, buttonBackwardNode, false);
1175 
1176     buttonBackwardNode->MarkModifyDone();
1177     return buttonBackwardNode;
1178 }
1179 
SetFirstDialogButtonActive(RefPtr<UINode> & contentRow)1180 void TextPickerDialogView::SetFirstDialogButtonActive(RefPtr<UINode>& contentRow)
1181 {
1182     CHECK_NULL_VOID(contentRow);
1183     auto buttonCancel = contentRow->GetFirstChild();
1184     auto buttonCancelNode = AceType::DynamicCast<FrameNode>(buttonCancel);
1185     CHECK_NULL_VOID(buttonCancelNode);
1186     auto buttonCancelLayoutProperty = buttonCancelNode->GetLayoutProperty<LayoutProperty>();
1187     CHECK_NULL_VOID(buttonCancelLayoutProperty);
1188     buttonCancelLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
1189 
1190     auto buttonForward = contentRow->GetChildAtIndex(FORWAED_BUTTON_DIVEDER_INDEX);
1191     auto buttonForwardNode = AceType::DynamicCast<FrameNode>(buttonForward);
1192     CHECK_NULL_VOID(buttonForwardNode);
1193     auto buttonForwardLayoutProperty = buttonForwardNode->GetLayoutProperty<LayoutProperty>();
1194     CHECK_NULL_VOID(buttonForwardLayoutProperty);
1195     buttonForwardLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
1196 
1197     auto buttonBackward = contentRow->GetChildAtIndex(BACKWARD_BUTTON_DIVEDER_INDEX);
1198     auto buttonBackwardNode = AceType::DynamicCast<FrameNode>(buttonBackward);
1199     CHECK_NULL_VOID(buttonBackwardNode);
1200     auto buttonBackwardLayoutProperty = buttonBackwardNode->GetLayoutProperty<LayoutProperty>();
1201     CHECK_NULL_VOID(buttonBackwardLayoutProperty);
1202     buttonBackwardLayoutProperty->UpdateVisibility(VisibleType::GONE);
1203 
1204     auto buttonConfirm = contentRow->GetChildAtIndex(CONFIRM_BUTTON_DIVEDER_INDEX);
1205     auto buttonConfirmNode = AceType::DynamicCast<FrameNode>(buttonConfirm);
1206     CHECK_NULL_VOID(buttonConfirmNode);
1207     auto buttonConfirmLayoutProperty = buttonConfirmNode->GetLayoutProperty<LayoutProperty>();
1208     CHECK_NULL_VOID(buttonConfirmLayoutProperty);
1209     buttonConfirmLayoutProperty->UpdateVisibility(VisibleType::GONE);
1210 }
1211 
SetSecondDialogButtonActive(RefPtr<UINode> & contentRow)1212 void TextPickerDialogView::SetSecondDialogButtonActive(RefPtr<UINode>& contentRow)
1213 {
1214     CHECK_NULL_VOID(contentRow);
1215     auto buttonCancel = contentRow->GetFirstChild();
1216     auto buttonCancelNode = AceType::DynamicCast<FrameNode>(buttonCancel);
1217     CHECK_NULL_VOID(buttonCancelNode);
1218     auto buttonCancelLayoutProperty = buttonCancelNode->GetLayoutProperty<LayoutProperty>();
1219     CHECK_NULL_VOID(buttonCancelLayoutProperty);
1220     buttonCancelLayoutProperty->UpdateVisibility(VisibleType::GONE);
1221 
1222     auto buttonForward = contentRow->GetChildAtIndex(FORWAED_BUTTON_DIVEDER_INDEX);
1223     auto buttonForwardNode = AceType::DynamicCast<FrameNode>(buttonForward);
1224     CHECK_NULL_VOID(buttonForwardNode);
1225     auto buttonForwardLayoutProperty = buttonForwardNode->GetLayoutProperty<LayoutProperty>();
1226     CHECK_NULL_VOID(buttonForwardLayoutProperty);
1227     buttonForwardLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
1228 
1229     auto buttonBackward = contentRow->GetChildAtIndex(BACKWARD_BUTTON_DIVEDER_INDEX);
1230     auto buttonBackwardNode = AceType::DynamicCast<FrameNode>(buttonBackward);
1231     CHECK_NULL_VOID(buttonBackwardNode);
1232     auto buttonBackwardLayoutProperty = buttonBackwardNode->GetLayoutProperty<LayoutProperty>();
1233     CHECK_NULL_VOID(buttonBackwardLayoutProperty);
1234     buttonBackwardLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
1235 
1236     auto buttonConfirm = contentRow->GetChildAtIndex(CONFIRM_BUTTON_DIVEDER_INDEX);
1237     auto buttonConfirmNode = AceType::DynamicCast<FrameNode>(buttonConfirm);
1238     CHECK_NULL_VOID(buttonConfirmNode);
1239     auto buttonConfirmLayoutProperty = buttonConfirmNode->GetLayoutProperty<LayoutProperty>();
1240     CHECK_NULL_VOID(buttonConfirmLayoutProperty);
1241     buttonConfirmLayoutProperty->UpdateVisibility(VisibleType::GONE);
1242 }
1243 
SetThirdDialogButtonActive(RefPtr<UINode> & contentRow)1244 void TextPickerDialogView::SetThirdDialogButtonActive(RefPtr<UINode>& contentRow)
1245 {
1246     CHECK_NULL_VOID(contentRow);
1247     auto buttonCancel = contentRow->GetFirstChild();
1248     auto buttonCancelNode = AceType::DynamicCast<FrameNode>(buttonCancel);
1249     CHECK_NULL_VOID(buttonCancelNode);
1250     auto buttonCancelLayoutProperty = buttonCancelNode->GetLayoutProperty<LayoutProperty>();
1251     CHECK_NULL_VOID(buttonCancelLayoutProperty);
1252     buttonCancelLayoutProperty->UpdateVisibility(VisibleType::GONE);
1253 
1254     auto buttonForward = contentRow->GetChildAtIndex(FORWAED_BUTTON_DIVEDER_INDEX);
1255     auto buttonForwardNode = AceType::DynamicCast<FrameNode>(buttonForward);
1256     CHECK_NULL_VOID(buttonForwardNode);
1257     auto buttonForwardLayoutProperty = buttonForwardNode->GetLayoutProperty<LayoutProperty>();
1258     CHECK_NULL_VOID(buttonForwardLayoutProperty);
1259     buttonForwardLayoutProperty->UpdateVisibility(VisibleType::GONE);
1260 
1261     auto buttonBackward = contentRow->GetChildAtIndex(BACKWARD_BUTTON_DIVEDER_INDEX);
1262     auto buttonBackwardNode = AceType::DynamicCast<FrameNode>(buttonBackward);
1263     CHECK_NULL_VOID(buttonBackwardNode);
1264     auto buttonBackwardLayoutProperty = buttonBackwardNode->GetLayoutProperty<LayoutProperty>();
1265     CHECK_NULL_VOID(buttonBackwardLayoutProperty);
1266     buttonBackwardLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
1267 
1268     auto buttonConfirm = contentRow->GetChildAtIndex(CONFIRM_BUTTON_DIVEDER_INDEX);
1269     auto buttonConfirmNode = AceType::DynamicCast<FrameNode>(buttonConfirm);
1270     CHECK_NULL_VOID(buttonConfirmNode);
1271     auto buttonConfirmLayoutProperty = buttonConfirmNode->GetLayoutProperty<LayoutProperty>();
1272     CHECK_NULL_VOID(buttonConfirmLayoutProperty);
1273     buttonConfirmLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
1274 }
1275 
SetDialogButtonActive(RefPtr<FrameNode> & contentColumn,const uint32_t & dialogNodePage,const uint32_t & columnCount)1276 void TextPickerDialogView::SetDialogButtonActive(RefPtr<FrameNode>& contentColumn,
1277     const uint32_t& dialogNodePage, const uint32_t& columnCount)
1278 {
1279     CHECK_NULL_VOID(contentColumn);
1280     auto contentRow = contentColumn->GetLastChild();
1281     if (dialogNodePage == 0) {
1282         SetFirstDialogButtonActive(contentRow);
1283         SetDividerNodeActive(contentRow, true, false, false);
1284     } else if (columnCount > 0 && dialogNodePage != (columnCount - 1)) {
1285         SetSecondDialogButtonActive(contentRow);
1286         SetDividerNodeActive(contentRow, false, true, false);
1287     } else {
1288         SetThirdDialogButtonActive(contentRow);
1289         SetDividerNodeActive(contentRow, false, false, true);
1290     }
1291 }
1292 
SetDividerNodeActive(RefPtr<UINode> & contentRow,bool firstDividerActive,bool secondDividerActive,bool thirdDividerActive)1293 void TextPickerDialogView::SetDividerNodeActive(RefPtr<UINode>& contentRow, bool firstDividerActive,
1294     bool secondDividerActive, bool thirdDividerActive)
1295 {
1296     CHECK_NULL_VOID(contentRow);
1297     auto firstDivider = contentRow->GetChildAtIndex(1);
1298     auto firstDividerNode = AceType::DynamicCast<FrameNode>(firstDivider);
1299     CHECK_NULL_VOID(firstDividerNode);
1300     auto secondDivider = contentRow->GetChildAtIndex(SECOND_DIVEDER_NODE_INDEX);
1301     auto secondDividerNode = AceType::DynamicCast<FrameNode>(secondDivider);
1302     CHECK_NULL_VOID(secondDividerNode);
1303     auto thirdDivider = contentRow->GetChildAtIndex(THIRD_DIVEDER_NODE_INDEX);
1304     auto thirdDividerNode = AceType::DynamicCast<FrameNode>(thirdDivider);
1305     CHECK_NULL_VOID(thirdDividerNode);
1306 
1307     SetSingleDividerNodeActive(firstDividerNode, firstDividerActive);
1308     SetSingleDividerNodeActive(secondDividerNode, secondDividerActive);
1309     SetSingleDividerNodeActive(thirdDividerNode, thirdDividerActive);
1310 }
1311 
SetSingleDividerNodeActive(RefPtr<FrameNode> & dividerNode,bool dividerActive)1312 void TextPickerDialogView::SetSingleDividerNodeActive(RefPtr<FrameNode>& dividerNode, bool dividerActive)
1313 {
1314     CHECK_NULL_VOID(dividerNode);
1315     auto dividerLayoutProperty = dividerNode->GetLayoutProperty<LayoutProperty>();
1316     CHECK_NULL_VOID(dividerLayoutProperty);
1317     if (dividerActive) {
1318         dividerLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
1319     } else {
1320         dividerLayoutProperty->UpdateVisibility(VisibleType::GONE);
1321     }
1322 }
1323 
SetDialogNodePageActive(RefPtr<FrameNode> & contentColumn,RefPtr<FrameNode> & textPickerNode,const uint32_t & dialogNodePage,const uint32_t & columnCount)1324 void TextPickerDialogView::SetDialogNodePageActive(RefPtr<FrameNode>& contentColumn,
1325     RefPtr<FrameNode>& textPickerNode,
1326     const uint32_t& dialogNodePage, const uint32_t& columnCount)
1327 {
1328     CHECK_NULL_VOID(textPickerNode);
1329     for (uint32_t i = 0; i < columnCount; i++) {
1330         auto selectedStackNode = AceType::DynamicCast<FrameNode>(textPickerNode->GetChildAtIndex(i));
1331         CHECK_NULL_VOID(selectedStackNode);
1332         if (i != dialogNodePage) {
1333             auto layoutProperty = selectedStackNode->GetLayoutProperty<LayoutProperty>();
1334             CHECK_NULL_VOID(layoutProperty);
1335             layoutProperty->UpdateLayoutWeight(0);
1336             for (auto& child : selectedStackNode->GetChildren()) {
1337                 auto childNode = AceType::DynamicCast<FrameNode>(child);
1338                 CHECK_NULL_VOID(childNode);
1339                 auto childNodeProperty = childNode->GetLayoutProperty<LayoutProperty>();
1340                 CHECK_NULL_VOID(childNodeProperty);
1341                 childNodeProperty->UpdateVisibility(VisibleType::GONE);
1342             }
1343         } else {
1344             auto layoutProperty = selectedStackNode->GetLayoutProperty<LayoutProperty>();
1345             CHECK_NULL_VOID(layoutProperty);
1346             layoutProperty->UpdateLayoutWeight(1);
1347             for (auto& child : selectedStackNode->GetChildren()) {
1348                 auto childNode = AceType::DynamicCast<FrameNode>(child);
1349                 CHECK_NULL_VOID(childNode);
1350                 auto childNodeProperty = childNode->GetLayoutProperty<LayoutProperty>();
1351                 CHECK_NULL_VOID(childNodeProperty);
1352                 childNodeProperty->UpdateVisibility(VisibleType::VISIBLE);
1353             }
1354         }
1355     }
1356     SetDialogButtonActive(contentColumn, dialogNodePage, columnCount);
1357 }
1358 
CreateAgingButtonNode(RefPtr<FrameNode> & frameNode,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogTextEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent,std::map<std::string,NG::DialogGestureEvent> dialogMoveForwardEvent,std::map<std::string,NG::DialogGestureEvent> dialogMoveBackwardEvent,GestureEventFunc closeCallback,GestureEventFunc nextCallBack,GestureEventFunc previousCallBack)1359 RefPtr<FrameNode> TextPickerDialogView::CreateAgingButtonNode(
1360     RefPtr<FrameNode>& frameNode,
1361     const std::vector<ButtonInfo>& buttonInfos,
1362     std::map<std::string, NG::DialogTextEvent> dialogEvent,
1363     std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent,
1364     std::map<std::string, NG::DialogGestureEvent> dialogMoveForwardEvent,
1365     std::map<std::string, NG::DialogGestureEvent> dialogMoveBackwardEvent,
1366     GestureEventFunc closeCallback, GestureEventFunc nextCallBack, GestureEventFunc previousCallBack)
1367 {
1368     auto acceptEvent = dialogEvent["acceptId"];
1369     auto cancelEvent = dialogCancelEvent["cancelId"];
1370     auto moveForwardEvent = dialogMoveForwardEvent["moveForwardId"];
1371     auto moveBackwardEvent = dialogMoveBackwardEvent["moveBackwardId"];
1372 
1373     auto contentRow = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
1374         AceType::MakeRefPtr<LinearLayoutPattern>(false));
1375     CHECK_NULL_RETURN(contentRow, nullptr);
1376     auto layoutProps = contentRow->GetLayoutProperty<LinearLayoutProperty>();
1377     CHECK_NULL_RETURN(layoutProps, nullptr);
1378     layoutProps->UpdateMainAxisAlign(FlexAlign::CENTER);
1379     layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
1380 
1381     auto buttonCancelNode = CreateCancelNode(cancelEvent, frameNode, buttonInfos);
1382     CHECK_NULL_RETURN(buttonCancelNode, nullptr);
1383     auto buttonConfirmNode = CreateConfirmNode(frameNode, frameNode, buttonInfos, acceptEvent);
1384     CHECK_NULL_RETURN(buttonConfirmNode, nullptr);
1385     auto buttonForwardNode = CreateForwardNode(moveForwardEvent, frameNode, buttonInfos);
1386     CHECK_NULL_RETURN(buttonForwardNode, nullptr);
1387     auto buttonBackwardNode = CreateBackwardNode(moveBackwardEvent, frameNode, buttonInfos);
1388     CHECK_NULL_RETURN(buttonBackwardNode, nullptr);
1389 
1390     buttonCancelNode->MountToParent(contentRow);
1391     buttonBackwardNode->MountToParent(contentRow);
1392     buttonForwardNode->MountToParent(contentRow);
1393     buttonConfirmNode->MountToParent(contentRow);
1394 
1395     auto closeClick = AceType::MakeRefPtr<NG::ClickEvent>(std::move(closeCallback));
1396     auto nextClick = AceType::MakeRefPtr<NG::ClickEvent>(std::move(nextCallBack));
1397     auto previousClick = AceType::MakeRefPtr<NG::ClickEvent>(std::move(previousCallBack));
1398 
1399     for (size_t i = 0; i < contentRow->GetChildren().size(); i++) {
1400         auto child = contentRow->GetChildAtIndex(i);
1401         auto childNode = AceType::DynamicCast<FrameNode>(child);
1402         CHECK_NULL_RETURN(childNode, nullptr);
1403         if (i == 0 || i == FORWAED_BUTTON_INDEX) {
1404             auto gestureHub = childNode->GetOrCreateGestureEventHub();
1405             CHECK_NULL_RETURN(gestureHub, nullptr);
1406             gestureHub->AddClickEvent(closeClick);
1407         } else if (i == BACKWARD_BUTTON_INDEX) {
1408             auto gestureHub = childNode->GetOrCreateGestureEventHub();
1409             CHECK_NULL_RETURN(gestureHub, nullptr);
1410             gestureHub->AddClickEvent(nextClick);
1411         } else if (i == 1) {
1412             auto gestureHub = childNode->GetOrCreateGestureEventHub();
1413             CHECK_NULL_RETURN(gestureHub, nullptr);
1414             gestureHub->AddClickEvent(previousClick);
1415         }
1416     }
1417     return contentRow;
1418 }
1419 
SeparatedOptionsShow(RefPtr<FrameNode> & contentColumn,RefPtr<FrameNode> & textPickerNode,const std::vector<ButtonInfo> & buttonInfos,const TextPickerSettingData & settingData,std::map<std::string,NG::DialogTextEvent> & dialogEvent,std::map<std::string,NG::DialogGestureEvent> & dialogCancelEvent,const float & scale,GestureEventFunc closeCallBack,RefPtr<FrameNode> & dialogNode)1420 RefPtr<FrameNode> TextPickerDialogView::SeparatedOptionsShow(
1421     RefPtr<FrameNode>& contentColumn, RefPtr<FrameNode>& textPickerNode,
1422     const std::vector<ButtonInfo>& buttonInfos,
1423     const TextPickerSettingData& settingData,
1424     std::map<std::string, NG::DialogTextEvent>& dialogEvent,
1425     std::map<std::string, NG::DialogGestureEvent>& dialogCancelEvent,
1426     const float& scale, GestureEventFunc closeCallBack, RefPtr<FrameNode>& dialogNode)
1427 {
1428     dialogNodePage = 0;
1429     auto moveForwardFunc = [](const GestureEvent& info) { (void)info; };
1430     std::map<std::string, NG::DialogGestureEvent> dialogMoveForwardEvent;
1431     dialogMoveForwardEvent["moveForwardId"] = moveForwardFunc;
1432     auto moveBackwardFunc = [](const GestureEvent& info) { (void)info; };
1433     std::map<std::string, NG::DialogGestureEvent> dialogMoveBackwardFunc;
1434     dialogMoveBackwardFunc["moveBackwardId"] = moveBackwardFunc;
1435 
1436     uint32_t columnCount = totalPageNum_;
1437     auto nextCallBack = [weak = WeakPtr<FrameNode>(dialogNode),
1438         weakText = WeakPtr<FrameNode>(textPickerNode),
1439         columnCount, weakColumn = WeakPtr<FrameNode>(contentColumn)](const GestureEvent& /* info */) {
1440     auto dialogNode = weak.Upgrade();
1441     auto textPickerNode = weakText.Upgrade();
1442     auto contentColumn = weakColumn.Upgrade();
1443     CHECK_NULL_VOID(dialogNode);
1444     if (dialogNodePage < (columnCount - 1)) {
1445         dialogNodePage++;
1446     }
1447     SetDialogNodePageActive(contentColumn, textPickerNode, dialogNodePage, columnCount);
1448     };
1449     auto previousCallBack = [weak = WeakPtr<FrameNode>(dialogNode),
1450         weakText = WeakPtr<FrameNode>(textPickerNode),
1451         columnCount, weakColumn = WeakPtr<FrameNode>(contentColumn)](const GestureEvent& /* info */) {
1452         auto dialogNode = weak.Upgrade();
1453         auto textPickerNode = weakText.Upgrade();
1454         auto contentColumn = weakColumn.Upgrade();
1455         CHECK_NULL_VOID(dialogNode);
1456         if (dialogNodePage > 0) {
1457             dialogNodePage--;
1458         }
1459         SetDialogNodePageActive(contentColumn, textPickerNode, dialogNodePage, columnCount);
1460     };
1461     auto contentRow =
1462         CreateAgingButtonNode(textPickerNode, buttonInfos, dialogEvent, std::move(dialogCancelEvent),
1463             std::move(dialogMoveForwardEvent), std::move(dialogMoveBackwardFunc),
1464             closeCallBack, nextCallBack, previousCallBack);
1465     CHECK_NULL_RETURN(contentRow, nullptr);
1466     contentRow->AddChild(CreateDividerNode(textPickerNode), 1);
1467     contentRow->AddChild(CreateDividerNode(textPickerNode), SECOND_DIVEDER_NODE_INDEX);
1468     contentRow->AddChild(CreateDividerNode(textPickerNode), THIRD_DIVEDER_NODE_INDEX);
1469     contentRow->MountToParent(contentColumn);
1470     SetDialogNodePageActive(contentColumn, textPickerNode, dialogNodePage, columnCount);
1471     dialogNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
1472     return dialogNode;
1473 }
1474 
NeedAdaptForAging()1475 bool TextPickerDialogView::NeedAdaptForAging()
1476 {
1477     auto pipeline = PipelineContext::GetCurrentContextSafelyWithCheck();
1478     CHECK_NULL_RETURN(pipeline, false);
1479     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1480     CHECK_NULL_RETURN(pickerTheme, false);
1481     if (GreatOrEqual(pipeline->GetFontScale(), pickerTheme->GetMaxOneFontScale()) &&
1482         Dimension(pipeline->GetRootHeight()).ConvertToVp() > pickerTheme->GetDeviceHeightLimit()) {
1483         return true;
1484     }
1485     return false;
1486 }
1487 
AdjustFontSizeScale(const Dimension & fontSizeValue,double fontScale)1488 const Dimension TextPickerDialogView::AdjustFontSizeScale(const Dimension& fontSizeValue, double fontScale)
1489 {
1490     auto pipeline = PipelineContext::GetCurrentContextSafely();
1491     CHECK_NULL_RETURN(pipeline, fontSizeValue);
1492     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1493     CHECK_NULL_RETURN(pickerTheme, fontSizeValue);
1494 
1495     auto adjustedScale = std::clamp(fontScale, pickerTheme->GetNormalFontScale(),
1496         pickerTheme->GetMaxTwoFontScale());
1497     return fontSizeValue * adjustedScale;
1498 }
1499 
ConvertFontScaleValue(const Dimension & fontSizeValue,const Dimension & fontSizeLimit,bool isUserSetFont)1500 const Dimension TextPickerDialogView::ConvertFontScaleValue(
1501     const Dimension& fontSizeValue, const Dimension& fontSizeLimit, bool isUserSetFont)
1502 {
1503     auto pipeline = PipelineContext::GetCurrentContextPtrSafelyWithCheck();
1504     CHECK_NULL_RETURN(pipeline, fontSizeValue);
1505     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1506     CHECK_NULL_RETURN(pickerTheme, fontSizeValue);
1507     float fontSizeScale = pipeline->GetFontScale();
1508     Dimension fontSizeValueResult = fontSizeValue;
1509 
1510     if (NeedAdaptForAging()) {
1511         if (fontSizeValue.Unit() == DimensionUnit::VP) {
1512             if (isUserSetFont) {
1513                 fontSizeValueResult = ConvertFontSizeLimit(fontSizeValue, fontSizeLimit, isUserSetFont);
1514             }
1515             fontSizeValueResult = AdjustFontSizeScale(fontSizeValueResult, fontSizeScale);
1516         } else {
1517             if (GreatOrEqualCustomPrecision(fontSizeScale, pickerTheme->GetMaxThirdFontScale())) {
1518                 fontSizeScale = pickerTheme->GetMaxTwoFontScale() / pickerTheme->GetMaxThirdFontScale();
1519                 fontSizeValueResult = fontSizeValue * fontSizeScale;
1520             }
1521             if (isUserSetFont) {
1522                 fontSizeValueResult = ConvertFontSizeLimit(fontSizeValueResult, fontSizeLimit, isUserSetFont);
1523             }
1524         }
1525     } else {
1526         if (isUserSetFont) {
1527             fontSizeValueResult = ConvertFontSizeLimit(fontSizeValue, fontSizeLimit, isUserSetFont);
1528         }
1529 
1530         if (GreatOrEqualCustomPrecision(fontSizeScale, pickerTheme->GetMaxOneFontScale()) &&
1531             fontSizeValueResult.Unit() != DimensionUnit::VP) {
1532             if (!NearZero(fontSizeScale)) {
1533                 fontSizeValueResult = fontSizeValueResult / fontSizeScale;
1534             }
1535         }
1536     }
1537     return fontSizeValueResult;
1538 }
1539 
ConvertFontSizeLimit(const Dimension & fontSizeValue,const Dimension & fontSizeLimit,bool isUserSetFont)1540 const Dimension TextPickerDialogView::ConvertFontSizeLimit(
1541     const Dimension& fontSizeValue, const Dimension& fontSizeLimit, bool isUserSetFont)
1542 {
1543     if (isUserSetFont == false) {
1544         return fontSizeValue;
1545     }
1546     Dimension fontSizeValueResult = fontSizeValue;
1547     if (fontSizeValue.Unit() == DimensionUnit::VP) {
1548         if (GreatOrEqualCustomPrecision(fontSizeValue.ConvertToPx(), fontSizeLimit.ConvertToPx() / MARGIN_HALF)) {
1549             fontSizeValueResult = fontSizeLimit / MARGIN_HALF;
1550         } else {
1551             fontSizeValueResult = fontSizeValue;
1552         }
1553     } else {
1554         if (GreatOrEqualCustomPrecision(fontSizeValue.ConvertToPx(), fontSizeLimit.ConvertToPx())) {
1555             fontSizeValueResult = fontSizeLimit;
1556         } else {
1557             fontSizeValueResult = fontSizeValue;
1558         }
1559     }
1560 
1561     return fontSizeValueResult;
1562 }
1563 
GetUserSettingLimit()1564 void TextPickerDialogView::GetUserSettingLimit()
1565 {
1566     auto pipeline = PipelineContext::GetCurrentContextSafely();
1567     CHECK_NULL_VOID(pipeline);
1568     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1569     CHECK_NULL_VOID(pickerTheme);
1570     selectedTextStyleFont_ = pickerTheme->GetUseSetSelectedTextStyle();
1571     normalTextStyleFont_ = pickerTheme->GetUserSetNormalTextStyle();
1572     disappearTextStyleFont_ = pickerTheme->GetUserSetDisappearTextStyle();
1573 }
1574 
1575 } // namespace OHOS::Ace::NG
1576