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 #include "core/components_ng/pattern/picker/datepicker_dialog_view.h"
16 
17 #include <utility>
18 
19 #include "base/geometry/dimension.h"
20 #include "base/i18n/date_time_sequence.h"
21 #include "base/memory/ace_type.h"
22 #include "base/utils/utils.h"
23 #include "core/components/theme/icon_theme.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/calendar/calendar_paint_property.h"
27 #include "core/components_ng/pattern/checkbox/checkbox_pattern.h"
28 #include "core/components_ng/pattern/dialog/dialog_view.h"
29 #include "core/components_ng/pattern/divider/divider_pattern.h"
30 #include "core/components_ng/pattern/dialog/dialog_pattern.h"
31 #include "core/components_ng/pattern/image/image_pattern.h"
32 #include "core/components_ng/pattern/picker/datepicker_pattern.h"
33 #include "core/components_ng/pattern/picker/datepicker_row_layout_property.h"
34 #include "core/components_ng/pattern/stack/stack_pattern.h"
35 #include "core/components_ng/property/measure_property.h"
36 #include "core/components_v2/inspector/inspector_constants.h"
37 #include "core/pipeline/pipeline_base.h"
38 
39 namespace OHOS::Ace::NG {
40 namespace {
41 const int32_t MARGIN_HALF = 2;
42 const int32_t NEXT_BUTTON_INDEX = 2;
43 const int32_t DIVIDER_ROWS_THREE = 3;
44 constexpr double MONTHDAYS_WIDTH_PERCENT_ONE = 0.4285;
45 constexpr double TIME_WIDTH_PERCENT_ONE = 0.5714;
46 constexpr double MONTHDAYS_WIDTH_PERCENT_TWO = 0.3636;
47 constexpr double TIME_WIDTH_PERCENT_TWO = 0.6363;
48 constexpr Dimension BUTTON_BOTTOM_TOP_MARGIN = 10.0_vp;
49 constexpr Dimension LUNARSWITCH_HEIGHT = 48.0_vp;
50 constexpr Dimension CHECKBOX_SIZE = 24.0_vp;
51 constexpr Dimension PICKER_DIALOG_MARGIN_FORM_EDGE = 24.0_vp;
52 constexpr Dimension TITLE_HEIGHT = 40.0_vp;
53 constexpr Dimension TITLE_BUTTON_HEIGHT = 32.0_vp;
54 constexpr Dimension TITLE_PADDING_HORIZONTAL = 16.0_vp;
55 constexpr Dimension PICKER_MARGIN_FROM_TITLE_AND_BUTTON = 8.0_vp;
56 constexpr int32_t HOVER_ANIMATION_DURATION = 250;
57 constexpr int32_t BUFFER_NODE_NUMBER = 2;
58 constexpr int32_t RATIO_SEVEN = 7;
59 constexpr int32_t RATIO_FOUR = 4;
60 constexpr int32_t RATIO_THREE = 3;
61 constexpr int32_t RATIO_TWO = 2;
62 constexpr size_t ACCEPT_BUTTON_INDEX = 0;
63 constexpr size_t CANCEL_BUTTON_INDEX = 1;
64 } // namespace
65 bool DatePickerDialogView::switchFlag_ = false;
66 bool DatePickerDialogView::switchTimePickerFlag_ = false;
67 bool DatePickerDialogView::switchDatePickerFlag_ = false;
68 bool DatePickerDialogView::isShowTime_ = false;
69 bool DatePickerDialogView::isUserSetFont_ = false;
70 Dimension DatePickerDialogView::selectedTextStyleFont_ = 40.0_vp;
71 Dimension DatePickerDialogView::normalTextStyleFont_ = 32.0_vp;
72 Dimension DatePickerDialogView::disappearTextStyleFont_ = 28.0_vp;
73 
Show(const DialogProperties & dialogProperties,const DatePickerSettingData & settingData,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)74 RefPtr<FrameNode> DatePickerDialogView::Show(const DialogProperties& dialogProperties,
75     const DatePickerSettingData& settingData, const std::vector<ButtonInfo>& buttonInfos,
76     std::map<std::string, NG::DialogEvent> dialogEvent, std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
77 {
78     ACE_LAYOUT_SCOPED_TRACE("Create[DatePickerDialogView]");
79     GetUserSettingLimit();
80     auto contentColumn = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
81         AceType::MakeRefPtr<LinearLayoutPattern>(true));
82     auto pickerStack = CreateStackNode();
83     auto dateNode = CreateAndMountDateNode(settingData, pickerStack);
84     auto pickerPattern = dateNode->GetPattern<DatePickerPattern>();
85     CHECK_NULL_RETURN(pickerPattern, nullptr);
86     DateTimeSequence sequence;
87     auto language = AceApplicationInfo::GetInstance().GetLanguage();
88     OrderResult orderResult = sequence.GetDateOrder(language);
89     if (language == "ug") {
90         pickerPattern->SetDateOrder("y-d-M");
91     } else {
92         auto dateOrder = orderResult.dateOrder;
93         pickerPattern->SetDateOrder(dateOrder);
94     }
95     pickerPattern->SetIsShowInDialog(true);
96     pickerPattern->SetTextProperties(settingData.properties);
97     auto buttonTitleNode = CreateAndMountButtonTitleNode(dateNode, contentColumn);
98     CHECK_NULL_RETURN(buttonTitleNode, nullptr);
99 
100     std::function<void(bool)> lunarChangeEvent = CreateLunarChangeEvent(dateNode);
101     RefPtr<FrameNode> acceptNode = dateNode;
102     RefPtr<FrameNode> timePickerNode = dateNode;
103     if (settingData.showTime) {
104         switchFlag_ = false;
105         switchTimePickerFlag_ = false;
106         auto pickerRow = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
107             AceType::MakeRefPtr<LinearLayoutPattern>(false));
108         CHECK_NULL_RETURN(pickerRow, nullptr);
109 
110         auto monthDaysNode = CreateAndMountMonthDaysNode(settingData, dateNode, pickerRow, std::move(lunarChangeEvent));
111         CHECK_NULL_RETURN(monthDaysNode, nullptr);
112         auto timeNode = CreateAndMountTimeNode(settingData, monthDaysNode, pickerRow);
113         CHECK_NULL_RETURN(timeNode, nullptr);
114         timePickerNode = timeNode;
115         isShowTime_ = true;
116         pickerRow->MountToParent(pickerStack);
117 
118         CreateTitleIconNode(buttonTitleNode);
119         SetTitleMouseHoverEvent(buttonTitleNode);
120         buttonTitleNode->MarkModifyDone();
121         auto titleSwitchEvent = CreateAndSetDialogSwitchEvent(pickerStack, contentColumn, settingData);
122         CreateAndAddTitleClickEvent(titleSwitchEvent, buttonTitleNode);
123         acceptNode = monthDaysNode;
124     } else {
125         isShowTime_ = false;
126     }
127     dateNode->MarkModifyDone();
128 
129     ViewStackProcessor::GetInstance()->Finish();
130     auto stackLayoutProperty = pickerStack->GetLayoutProperty();
131     CHECK_NULL_RETURN(stackLayoutProperty, nullptr);
132     stackLayoutProperty->UpdateUserDefinedIdealSize(
133         CalcSize(NG::CalcLength(Dimension(1, DimensionUnit::PERCENT)), std::nullopt));
134     UpdateContentPadding(pickerStack);
135     pickerStack->MountToParent(contentColumn);
136     // build lunarswitch Node
137     if (settingData.lunarswitch) {
138         CreateLunarswitchNode(contentColumn, dateNode, std::move(lunarChangeEvent), settingData.isLunar,
139             settingData.checkboxSettingData);
140     }
141     auto dialogNode = DialogView::CreateDialogNode(dialogProperties, contentColumn);
142     CHECK_NULL_RETURN(dialogNode, nullptr);
143     auto dialogPattern = dialogNode->GetPattern<DialogPattern>();
144     CHECK_NULL_RETURN(dialogPattern, nullptr);
145     dialogPattern->SetIsPickerDialog(true);
146     // build dialog accept and cancel button
147     if (NeedAdaptForAging()) {
148         BuildDialogAcceptAndCancelButtonForAging(buttonInfos, settingData, timePickerNode, acceptNode, dateNode,
149                                                  dialogNode, contentColumn, dialogEvent, dialogCancelEvent);
150     } else {
151         BuildDialogAcceptAndCancelButton(
152             buttonInfos, settingData, acceptNode, dateNode, dialogNode, contentColumn, dialogEvent, dialogCancelEvent);
153     }
154     dialogNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
155     return dialogNode;
156 }
157 
CreateLunarSwitchTextNode()158 RefPtr<FrameNode> DatePickerDialogView::CreateLunarSwitchTextNode()
159 {
160     auto pipeline = PipelineBase::GetCurrentContext();
161     CHECK_NULL_RETURN(pipeline, nullptr);
162     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
163     CHECK_NULL_RETURN(pickerTheme, nullptr);
164 
165     auto textNode = FrameNode::CreateFrameNode(
166         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
167     CHECK_NULL_RETURN(textNode, nullptr);
168     auto textLayoutProperty = textNode->GetLayoutProperty<TextLayoutProperty>();
169     CHECK_NULL_RETURN(textLayoutProperty, nullptr);
170     textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("datepicker.lunarSwitch"));
171     textLayoutProperty->UpdateFontSize(ConvertFontScaleValue(pickerTheme->GetLunarSwitchTextSize()));
172     textLayoutProperty->UpdateTextColor(pickerTheme->GetLunarSwitchTextColor());
173     textNode->MarkModifyDone();
174     return textNode;
175 }
176 
SetTimeNodeColumnWeight(const RefPtr<FrameNode> & timeNode,const DatePickerSettingData & settingData)177 void DatePickerDialogView::SetTimeNodeColumnWeight(
178     const RefPtr<FrameNode>& timeNode, const DatePickerSettingData& settingData)
179 {
180     auto timeLayoutProperty = timeNode->GetLayoutProperty();
181     CHECK_NULL_VOID(timeLayoutProperty);
182     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
183         timeLayoutProperty->UpdateLayoutWeight(settingData.useMilitary ? RATIO_FOUR : RATIO_SEVEN);
184         for (const auto& child : timeNode->GetChildren()) {
185             auto frameNodeChild = AceType::DynamicCast<NG::FrameNode>(child);
186             CHECK_NULL_VOID(frameNodeChild);
187             auto timeColumnLayoutProperty = frameNodeChild->GetLayoutProperty();
188             CHECK_NULL_VOID(timeColumnLayoutProperty);
189             timeColumnLayoutProperty->UpdateLayoutWeight(RATIO_TWO);
190         }
191         if (!settingData.useMilitary) {
192             auto child = timeNode->GetFirstChild();
193             CHECK_NULL_VOID(child);
194             auto frameNodeChild = AceType::DynamicCast<NG::FrameNode>(child);
195             CHECK_NULL_VOID(frameNodeChild);
196             auto timeColumnLayoutProperty = frameNodeChild->GetLayoutProperty();
197             CHECK_NULL_VOID(timeColumnLayoutProperty);
198             timeColumnLayoutProperty->UpdateLayoutWeight(RATIO_THREE);
199         }
200     } else {
201         timeLayoutProperty->UpdateUserDefinedIdealSize(
202             CalcSize(NG::CalcLength(Dimension(settingData.useMilitary ? TIME_WIDTH_PERCENT_ONE : TIME_WIDTH_PERCENT_TWO,
203                 DimensionUnit::PERCENT)),
204             std::nullopt));
205     }
206 }
207 
CreateStackNode()208 RefPtr<FrameNode> DatePickerDialogView::CreateStackNode()
209 {
210     auto stackId = ElementRegister::GetInstance()->MakeUniqueId();
211     return FrameNode::GetOrCreateFrameNode(
212         V2::STACK_ETS_TAG, stackId, []() { return AceType::MakeRefPtr<StackPattern>(); });
213 }
214 
CreateColumnNode()215 RefPtr<FrameNode> DatePickerDialogView::CreateColumnNode()
216 {
217     auto columnId = ElementRegister::GetInstance()->MakeUniqueId();
218     return FrameNode::GetOrCreateFrameNode(
219         V2::COLUMN_ETS_TAG, columnId, []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
220 }
221 
CreateButtonNode()222 RefPtr<FrameNode> DatePickerDialogView::CreateButtonNode()
223 {
224     auto buttonId = ElementRegister::GetInstance()->MakeUniqueId();
225     return FrameNode::GetOrCreateFrameNode(
226         V2::BUTTON_ETS_TAG, buttonId, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
227 }
228 
CreateTitleButtonNode(const RefPtr<FrameNode> & dateNode)229 RefPtr<FrameNode> DatePickerDialogView::CreateTitleButtonNode(const RefPtr<FrameNode>& dateNode)
230 {
231     auto pipeline = PipelineContext::GetCurrentContext();
232     CHECK_NULL_RETURN(pipeline, nullptr);
233     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
234     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
235     auto pickerPattern = dateNode->GetPattern<DatePickerPattern>();
236     CHECK_NULL_RETURN(pickerPattern, nullptr);
237     auto titleRow = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
238         AceType::MakeRefPtr<LinearLayoutPattern>(false));
239     CHECK_NULL_RETURN(titleRow, nullptr);
240     UpdateTitleRowLayoutProps(titleRow);
241 
242     auto buttonTitleNode = FrameNode::GetOrCreateFrameNode(
243         V2::BUTTON_ETS_TAG, pickerPattern->GetButtonTitleId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
244     CHECK_NULL_RETURN(buttonTitleNode, nullptr);
245     auto titleButtonRow = CreateTitleButtonRowNode();
246     CHECK_NULL_RETURN(titleButtonRow, nullptr);
247     auto textTitleNodeId = pickerPattern->GetTitleId();
248     auto textTitleNode =
249         FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, textTitleNodeId, AceType::MakeRefPtr<TextPattern>());
250     CHECK_NULL_RETURN(textTitleNode, nullptr);
251     auto textLayoutProperty = textTitleNode->GetLayoutProperty<TextLayoutProperty>();
252     CHECK_NULL_RETURN(textLayoutProperty, nullptr);
253     textLayoutProperty->UpdateContent("");
254     textLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
255     textLayoutProperty->UpdateTextColor(pickerTheme->GetTitleStyle().GetTextColor());
256     textLayoutProperty->UpdateFontSize(ConvertTitleFontScaleValue(pickerTheme->GetTitleStyle().GetFontSize()));
257     textLayoutProperty->UpdateFontWeight(pickerTheme->GetTitleStyle().GetFontWeight());
258     textLayoutProperty->UpdateTextOverflow(pickerTheme->GetTitleStyle().GetTextOverflow());
259     textLayoutProperty->UpdateMaxLines(pickerTheme->GetTitleStyle().GetMaxLines());
260     textLayoutProperty->UpdateFlexShrink(1.0);
261     auto buttonTitleRenderContext = buttonTitleNode->GetRenderContext();
262     CHECK_NULL_RETURN(buttonTitleRenderContext, nullptr);
263     buttonTitleRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
264     MarginProperty margin;
265     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
266         margin.left = CalcLength(dialogTheme->GetDividerPadding().Left());
267         margin.right = CalcLength(dialogTheme->GetDividerPadding().Right());
268         margin.top = CalcLength(dialogTheme->GetDividerHeight() / MARGIN_HALF);
269         margin.bottom = CalcLength(dialogTheme->GetDividerHeight() / MARGIN_HALF);
270         buttonTitleNode->GetLayoutProperty()->UpdateMargin(margin);
271     } else {
272         buttonTitleNode->GetLayoutProperty()->UpdateUserDefinedIdealSize(CalcSize(
273             CalcLength(Dimension(1.0, DimensionUnit::PERCENT)), CalcLength(TITLE_BUTTON_HEIGHT)));
274         titleButtonRow->GetLayoutProperty()->UpdateUserDefinedIdealSize(CalcSize(
275             CalcLength(Dimension(1.0, DimensionUnit::PERCENT)), CalcLength(TITLE_BUTTON_HEIGHT)));
276     }
277     textTitleNode->MountToParent(titleButtonRow);
278     titleButtonRow->MountToParent(buttonTitleNode);
279     buttonTitleNode->MountToParent(titleRow);
280     titleRow->SetNeedCallChildrenUpdate(false);
281     return titleRow;
282 }
283 
UpdateTitleRowLayoutProps(const RefPtr<FrameNode> & titleRow)284 void DatePickerDialogView::UpdateTitleRowLayoutProps(const RefPtr<FrameNode>& titleRow)
285 {
286     auto layoutProps = titleRow->GetLayoutProperty<LinearLayoutProperty>();
287     CHECK_NULL_VOID(layoutProps);
288     layoutProps->UpdateMainAxisAlign(FlexAlign::CENTER);
289     layoutProps->UpdateCrossAxisAlign(FlexAlign::CENTER);
290     layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
291 }
292 
CreateTitleButtonRowNode()293 RefPtr<FrameNode> DatePickerDialogView::CreateTitleButtonRowNode()
294 {
295     auto titleButtonRow = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
296         AceType::MakeRefPtr<LinearLayoutPattern>(false));
297     CHECK_NULL_RETURN(titleButtonRow, nullptr);
298     auto bottonRowlayoutProps = titleButtonRow->GetLayoutProperty<LinearLayoutProperty>();
299     CHECK_NULL_RETURN(bottonRowlayoutProps, nullptr);
300     bottonRowlayoutProps->UpdateMainAxisAlign(FlexAlign::CENTER);
301     bottonRowlayoutProps->UpdateCrossAxisAlign(FlexAlign::CENTER);
302     bottonRowlayoutProps->UpdateMeasureType(MeasureType::MATCH_CONTENT);
303     return titleButtonRow;
304 }
305 
CreateTitleIconNode(const RefPtr<FrameNode> & titleNode)306 void DatePickerDialogView::CreateTitleIconNode(const RefPtr<FrameNode>& titleNode)
307 {
308     auto pipeline = PipelineContext::GetCurrentContext();
309     CHECK_NULL_VOID(pipeline);
310     auto iconTheme = pipeline->GetTheme<IconTheme>();
311     CHECK_NULL_VOID(iconTheme);
312     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
313     CHECK_NULL_VOID(pickerTheme);
314     auto spinnerNode = FrameNode::CreateFrameNode(
315         V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>());
316     CHECK_NULL_VOID(spinnerNode);
317     ImageSourceInfo imageSourceInfo;
318     auto iconPath = iconTheme->GetIconPath(InternalResource::ResourceId::SPINNER);
319     imageSourceInfo.SetSrc(iconPath);
320     imageSourceInfo.SetFillColor(pickerTheme->GetTitleStyle().GetTextColor());
321     auto spinnerRenderProperty = spinnerNode->GetPaintProperty<ImageRenderProperty>();
322     CHECK_NULL_VOID(spinnerRenderProperty);
323     spinnerRenderProperty->UpdateSvgFillColor(pickerTheme->GetTitleStyle().GetTextColor());
324 
325     auto spinnerLayoutProperty = spinnerNode->GetLayoutProperty<ImageLayoutProperty>();
326     CHECK_NULL_VOID(spinnerLayoutProperty);
327     spinnerLayoutProperty->UpdateImageSourceInfo(imageSourceInfo);
328     CalcSize idealSize = { CalcLength(ConvertTitleFontScaleValue(pickerTheme->GetTitleStyle().GetFontSize())),
329         CalcLength(ConvertTitleFontScaleValue(pickerTheme->GetTitleStyle().GetFontSize())) };
330     MeasureProperty layoutConstraint;
331     layoutConstraint.selfIdealSize = idealSize;
332     spinnerLayoutProperty->UpdateCalcLayoutProperty(layoutConstraint);
333     spinnerNode->MarkModifyDone();
334     auto buttonNode = AceType::DynamicCast<FrameNode>(titleNode->GetFirstChild());
335     CHECK_NULL_VOID(buttonNode);
336     auto buttonRowNode = AceType::DynamicCast<FrameNode>(buttonNode->GetFirstChild());
337     CHECK_NULL_VOID(buttonRowNode);
338     spinnerNode->MountToParent(buttonRowNode);
339 }
340 
CreateDividerNode(const RefPtr<FrameNode> & dateNode,bool isCreateDivider)341 RefPtr<FrameNode> DatePickerDialogView::CreateDividerNode(const RefPtr<FrameNode>& dateNode, bool isCreateDivider)
342 {
343     auto pipeline = PipelineContext::GetCurrentContext();
344     CHECK_NULL_RETURN(pipeline, nullptr);
345     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
346     auto pickerPattern = dateNode->GetPattern<DatePickerPattern>();
347     CHECK_NULL_RETURN(pickerPattern, nullptr);
348 
349     int32_t dividerNodeId = 0;
350     if (isCreateDivider) {
351         dividerNodeId = ElementRegister::GetInstance()->MakeUniqueId();
352     } else {
353         dividerNodeId = pickerPattern->GetDividerId();
354     }
355 
356     auto dividerNode = FrameNode::GetOrCreateFrameNode(
357         V2::DIVIDER_ETS_TAG, dividerNodeId, []() { return AceType::MakeRefPtr<DividerPattern>(); });
358     CHECK_NULL_RETURN(dividerNode, nullptr);
359 
360     auto dividerPaintProps = dividerNode->GetPaintProperty<DividerRenderProperty>();
361     CHECK_NULL_RETURN(dividerPaintProps, nullptr);
362     dividerPaintProps->UpdateDividerColor(dialogTheme->GetDividerColor());
363 
364     auto dividerLayoutProps = dividerNode->GetLayoutProperty<DividerLayoutProperty>();
365     CHECK_NULL_RETURN(dividerLayoutProps, nullptr);
366     dividerLayoutProps->UpdateVertical(true);
367     dividerLayoutProps->UpdateUserDefinedIdealSize(
368         CalcSize(CalcLength(dialogTheme->GetDividerWidth()), CalcLength(dialogTheme->GetDividerHeight())));
369 
370     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
371         auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
372         CHECK_NULL_RETURN(buttonTheme, nullptr);
373         auto dividerWrapper = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG,
374             ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<LinearLayoutPattern>(false));
375         CHECK_NULL_RETURN(dividerWrapper, nullptr);
376         auto layoutProps = dividerWrapper->GetLayoutProperty<LinearLayoutProperty>();
377         CHECK_NULL_RETURN(layoutProps, nullptr);
378         layoutProps->UpdateMainAxisAlign(FlexAlign::SPACE_AROUND);
379         layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
380         layoutProps->UpdateUserDefinedIdealSize(
381             CalcSize(CalcLength(dialogTheme->GetActionsPadding().Bottom()), CalcLength(buttonTheme->GetHeight())));
382         dividerNode->MountToParent(dividerWrapper);
383         return dividerWrapper;
384     }
385     return dividerNode;
386 }
387 
CreateButtonNode(const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & datePickerNode,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)388 RefPtr<FrameNode> DatePickerDialogView::CreateButtonNode(const RefPtr<FrameNode>& dateNode,
389     const RefPtr<FrameNode>& datePickerNode, const std::vector<ButtonInfo>& buttonInfos,
390     std::map<std::string, NG::DialogEvent> dialogEvent, std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
391 {
392     auto acceptEvent = dialogEvent["acceptId"];
393     auto dateAcceptEvent = dialogEvent["dateAcceptId"];
394     auto cancelEvent = dialogCancelEvent["cancelId"];
395     auto contentRow = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
396         AceType::MakeRefPtr<LinearLayoutPattern>(false));
397     CHECK_NULL_RETURN(contentRow, nullptr);
398     auto layoutProps = contentRow->GetLayoutProperty<LinearLayoutProperty>();
399     CHECK_NULL_RETURN(layoutProps, nullptr);
400     layoutProps->UpdateMainAxisAlign(FlexAlign::SPACE_AROUND);
401     layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
402 
403     contentRow->SetNeedCallChildrenUpdate(false);
404     SetDialogDateAcceptEvent(dateNode, std::move(dateAcceptEvent));
405 
406     auto buttonCancelNode = CreateCancelNode(cancelEvent, datePickerNode, buttonInfos);
407     auto buttonConfirmNode = CreateConfirmNode(dateNode, datePickerNode, acceptEvent, buttonInfos);
408 
409     buttonCancelNode->MountToParent(contentRow);
410     buttonConfirmNode->MountToParent(contentRow);
411 
412     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
413     datePickerPattern->SetContentRowNode(contentRow);
414 
415     return contentRow;
416 }
417 
CreateAndSetTimePickerSwitchEvent(const RefPtr<FrameNode> & monthAndDayPickerNode,const RefPtr<FrameNode> & timePickerNode,const RefPtr<FrameNode> & contentRow)418 std::function<void()> DatePickerDialogView::CreateAndSetTimePickerSwitchEvent(
419     const RefPtr<FrameNode>& monthAndDayPickerNode, const RefPtr<FrameNode>& timePickerNode,
420     const RefPtr<FrameNode>& contentRow)
421 {
422     auto timePickerSwitchEvent = [weakTimePickerNode = AceType::WeakClaim(AceType::RawPtr(timePickerNode)),
423                                      weakMonthAndDayPickerNode =
424                                          AceType::WeakClaim(AceType::RawPtr(monthAndDayPickerNode)),
425                                      weakcontentRow = AceType::WeakClaim(AceType::RawPtr(contentRow))]() {
426         auto timePickerNode = weakTimePickerNode.Upgrade();
427         CHECK_NULL_VOID(timePickerNode);
428         auto monthAndDayPickerNode = weakMonthAndDayPickerNode.Upgrade();
429         CHECK_NULL_VOID(monthAndDayPickerNode);
430         auto contentRow = weakcontentRow.Upgrade();
431         CHECK_NULL_VOID(contentRow);
432         SwitchTimePickerPage(monthAndDayPickerNode, timePickerNode, contentRow);
433     };
434 
435     return timePickerSwitchEvent;
436 }
437 
SwitchTimePickerPage(const RefPtr<FrameNode> & monthAndDayPickerNode,const RefPtr<FrameNode> & timePickerNode,const RefPtr<FrameNode> & contentRow)438 void DatePickerDialogView::SwitchTimePickerPage(const RefPtr<FrameNode> &monthAndDayPickerNode,
439     const RefPtr<FrameNode> &timePickerNode, const RefPtr<FrameNode> &contentRow)
440 {
441     auto monthAndDayLayoutProperty = monthAndDayPickerNode->GetLayoutProperty<LayoutProperty>();
442     CHECK_NULL_VOID(monthAndDayLayoutProperty);
443     monthAndDayLayoutProperty->UpdateVisibility(switchTimePickerFlag_ ? VisibleType::VISIBLE : VisibleType::GONE);
444     monthAndDayLayoutProperty->UpdateLayoutWeight(switchTimePickerFlag_ ? RATIO_FOUR : 0);
445     monthAndDayPickerNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
446     SwitchFocusStatus(timePickerNode, monthAndDayPickerNode);
447     UpdateTimePickerChildrenStatus(timePickerNode);
448     auto buttonCancelNode = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(0));
449     CHECK_NULL_VOID(buttonCancelNode);
450     auto cancelButtonLayoutProperty = buttonCancelNode->GetLayoutProperty<LayoutProperty>();
451     CHECK_NULL_VOID(cancelButtonLayoutProperty);
452     cancelButtonLayoutProperty->UpdateVisibility(switchTimePickerFlag_ ? VisibleType::VISIBLE : VisibleType::GONE);
453     buttonCancelNode->MarkDirtyNode();
454     auto cancelNextDividerNode = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(1));
455     CHECK_NULL_VOID(cancelNextDividerNode);
456     auto cancelNextLayoutProperty = cancelNextDividerNode->GetLayoutProperty<LayoutProperty>();
457     CHECK_NULL_VOID(cancelNextLayoutProperty);
458     cancelNextLayoutProperty->UpdateVisibility(switchTimePickerFlag_ ? VisibleType::VISIBLE : VisibleType::GONE);
459     cancelNextDividerNode->MarkDirtyNode();
460     auto buttonConfirmNode = AceType::DynamicCast<FrameNode>(contentRow->GetLastChild());
461     CHECK_NULL_VOID(buttonConfirmNode);
462     auto confirmButtonLayoutProperty = buttonConfirmNode->GetLayoutProperty<LayoutProperty>();
463     CHECK_NULL_VOID(confirmButtonLayoutProperty);
464     confirmButtonLayoutProperty->UpdateVisibility(switchTimePickerFlag_ ? VisibleType::GONE : VisibleType::VISIBLE);
465     buttonConfirmNode->MarkDirtyNode();
466     auto nextConfirmDividerNode = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(DIVIDER_ROWS_THREE));
467     CHECK_NULL_VOID(nextConfirmDividerNode);
468     auto nextConfirmLayoutProperty = nextConfirmDividerNode->GetLayoutProperty<LayoutProperty>();
469     CHECK_NULL_VOID(nextConfirmLayoutProperty);
470     nextConfirmLayoutProperty->UpdateVisibility(switchTimePickerFlag_ ? VisibleType::GONE : VisibleType::VISIBLE);
471     nextConfirmDividerNode->MarkDirtyNode();
472     switchTimePickerFlag_ = !switchTimePickerFlag_;
473 }
474 
SwitchFocusStatus(const RefPtr<FrameNode> & timePickerNode,const RefPtr<FrameNode> & monthAndDayPickerNode)475 void DatePickerDialogView::SwitchFocusStatus(
476     const RefPtr<FrameNode>& timePickerNode, const RefPtr<FrameNode>& monthAndDayPickerNode)
477 {
478     auto timePickerPattern = timePickerNode->GetPattern<TimePickerRowPattern>();
479     CHECK_NULL_VOID(timePickerPattern);
480     auto monthAndDayPickerPattern = monthAndDayPickerNode->GetPattern<DatePickerPattern>();
481     CHECK_NULL_VOID(monthAndDayPickerPattern);
482     if (switchTimePickerFlag_) {
483         timePickerPattern->SetFocusDisable();
484         monthAndDayPickerPattern->SetFocusEnable();
485     } else {
486         timePickerPattern->SetFocusEnable();
487         monthAndDayPickerPattern->SetFocusDisable();
488     }
489 }
490 
SwitchDatePickerPage(const RefPtr<FrameNode> & dateNode,bool IsSwitchByTitle)491 void DatePickerDialogView::SwitchDatePickerPage(const RefPtr<FrameNode>& dateNode, bool IsSwitchByTitle)
492 {
493     for (uint32_t index = 0; index < dateNode->GetChildren().size(); index++) {
494         auto dateStackNode = AceType::DynamicCast<FrameNode>(dateNode->GetChildAtIndex(index));
495         CHECK_NULL_VOID(dateStackNode);
496         auto layoutProperty = dateStackNode->GetLayoutProperty<LayoutProperty>();
497         for (uint32_t k = 0; k < dateStackNode->GetChildren().size(); k++) {
498             auto dateChildNode = AceType::DynamicCast<FrameNode>(dateStackNode->GetChildAtIndex(k));
499             CHECK_NULL_VOID(dateChildNode);
500             auto dateChildNodeLayoutProperty = dateChildNode->GetLayoutProperty<LayoutProperty>();
501             CHECK_NULL_VOID(dateChildNodeLayoutProperty);
502             if ((!switchDatePickerFlag_ || IsSwitchByTitle)) {
503                 dateChildNodeLayoutProperty->UpdateVisibility((0 == index) ? VisibleType::VISIBLE : VisibleType::GONE);
504                 switchDatePickerFlag_ = false;
505                 layoutProperty->UpdateLayoutWeight((0 == index) ? RATIO_TWO : 0);
506             } else {
507                 dateChildNodeLayoutProperty->UpdateVisibility((0 == index) ? VisibleType::GONE : VisibleType::VISIBLE);
508                 layoutProperty->UpdateLayoutWeight((0 == index) ? 0 : 1);
509             }
510             dateChildNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF_AND_PARENT);
511         }
512     }
513     switchDatePickerFlag_ = !switchDatePickerFlag_;
514     dateNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
515 }
516 
UpdateTimePickerChildrenStatus(const RefPtr<FrameNode> & timePickerNode)517 void DatePickerDialogView::UpdateTimePickerChildrenStatus(const RefPtr<FrameNode>& timePickerNode)
518 {
519     auto layoutProperty = timePickerNode->GetLayoutProperty<LayoutProperty>();
520     CHECK_NULL_VOID(layoutProperty);
521     layoutProperty->UpdateVisibility(switchTimePickerFlag_ ? VisibleType::GONE : VisibleType::VISIBLE);
522     layoutProperty->UpdateLayoutWeight(switchTimePickerFlag_ ? 0 : RATIO_SEVEN);
523     for (uint32_t i = 0; i < timePickerNode->GetChildren().size(); i++) {
524         auto childStackNode = AceType::DynamicCast<FrameNode>(timePickerNode->GetChildAtIndex(i));
525         CHECK_NULL_VOID(childStackNode);
526         auto layoutProperty = childStackNode->GetLayoutProperty<LayoutProperty>();
527         layoutProperty->UpdateAlignment(Alignment::CENTER);
528         for (uint32_t j = 0; j < childStackNode->GetChildren().size(); j++) {
529             auto childNode = AceType::DynamicCast<FrameNode>(childStackNode->GetChildAtIndex(j));
530             CHECK_NULL_VOID(childNode);
531             auto childLayoutProperty = childNode->GetLayoutProperty<LayoutProperty>();
532             CHECK_NULL_VOID(childLayoutProperty);
533             childLayoutProperty->UpdateVisibility(switchTimePickerFlag_ ? VisibleType::GONE : VisibleType::VISIBLE);
534             layoutProperty->UpdateLayoutWeight(switchTimePickerFlag_ ? 0 : RATIO_TWO);
535             childNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF_AND_PARENT);
536         }
537     }
538 }
539 
HideContentChildrenButton(const RefPtr<FrameNode> & contentRow)540 void DatePickerDialogView::HideContentChildrenButton(const RefPtr<FrameNode>& contentRow)
541 {
542     CHECK_NULL_VOID(contentRow);
543     for (const auto& child : contentRow->GetChildren()) {
544         auto frameNodeChild = AceType::DynamicCast<NG::FrameNode>(child);
545         CHECK_NULL_VOID(frameNodeChild);
546         auto layoutProperty = frameNodeChild->GetLayoutProperty();
547         layoutProperty->UpdateVisibility(VisibleType::GONE);
548     }
549 }
550 
SwitchContentRowButton(const RefPtr<FrameNode> & contentRow,bool useMilitary)551 void DatePickerDialogView::SwitchContentRowButton(const RefPtr<FrameNode>& contentRow, bool useMilitary)
552 {
553     if (!NeedAdaptForAging()) {
554         return;
555     }
556     HideContentChildrenButton(contentRow);
557     auto nextButton = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(2));
558     CHECK_NULL_VOID(nextButton);
559     auto nextButtonLayoutProperty = nextButton->GetLayoutProperty<ButtonLayoutProperty>();
560     CHECK_NULL_VOID(nextButtonLayoutProperty);
561     auto textNextPrevNode = AceType::DynamicCast<FrameNode>(nextButton->GetFirstChild());
562     CHECK_NULL_VOID(textNextPrevNode);
563     auto textLayoutProperty = textNextPrevNode->GetLayoutProperty<TextLayoutProperty>();
564     CHECK_NULL_VOID(textLayoutProperty);
565     if (!switchFlag_) {
566         nextButtonLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
567         UpdateNextButtonMargin(nextButtonLayoutProperty);
568         textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.next"));
569         textNextPrevNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
570     } else {
571         auto cancelButton = AceType::DynamicCast<FrameNode>(contentRow->GetFirstChild());
572         CHECK_NULL_VOID(cancelButton);
573         auto cancelLayoutProperty = cancelButton->GetLayoutProperty<LayoutProperty>();
574         CHECK_NULL_VOID(cancelLayoutProperty);
575         cancelLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
576         auto divideNode = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(1));
577         CHECK_NULL_VOID(divideNode);
578         auto divideLayoutProperty = divideNode->GetLayoutProperty<LayoutProperty>();
579         CHECK_NULL_VOID(divideLayoutProperty);
580         divideLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
581         nextButtonLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
582         textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.next"));
583         auto pipeline = PipelineContext::GetCurrentContextSafely();
584         CHECK_NULL_VOID(pipeline);
585         auto dialogTheme = pipeline->GetTheme<DialogTheme>();
586         CHECK_NULL_VOID(dialogTheme);
587         UpdateConfirmButtonMargin(nextButtonLayoutProperty, dialogTheme);
588         textNextPrevNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
589     }
590     contentRow->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF_AND_CHILD);
591 }
592 
ShowContentRowButton(const RefPtr<FrameNode> & contentRow,bool isFirstPage)593 void DatePickerDialogView::ShowContentRowButton(const RefPtr<FrameNode>& contentRow, bool isFirstPage)
594 {
595     for (const auto& child : contentRow->GetChildren()) {
596         auto frameNodeChild = AceType::DynamicCast<NG::FrameNode>(child);
597         CHECK_NULL_VOID(frameNodeChild);
598         auto layoutProperty = frameNodeChild->GetLayoutProperty();
599         layoutProperty->UpdateVisibility(VisibleType::GONE);
600     }
601     if (isFirstPage) {
602         auto buttonCancelNode = AceType::DynamicCast<FrameNode>(contentRow->GetFirstChild());
603         CHECK_NULL_VOID(buttonCancelNode);
604         auto layoutProperty = buttonCancelNode->GetLayoutProperty<LayoutProperty>();
605         CHECK_NULL_VOID(layoutProperty);
606         layoutProperty->UpdateVisibility(VisibleType::VISIBLE);
607         auto divideNode = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(1));
608         CHECK_NULL_VOID(divideNode);
609         auto divideLayoutProperty = divideNode->GetLayoutProperty<LayoutProperty>();
610         CHECK_NULL_VOID(divideLayoutProperty);
611         divideLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
612         auto nextButton = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(NEXT_BUTTON_INDEX));
613         CHECK_NULL_VOID(nextButton);
614         auto nextButtonLayoutProperty = nextButton->GetLayoutProperty<LayoutProperty>();
615         CHECK_NULL_VOID(nextButtonLayoutProperty);
616         nextButtonLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
617         auto textNextPrevNode = AceType::DynamicCast<FrameNode>(nextButton->GetFirstChild());
618         CHECK_NULL_VOID(textNextPrevNode);
619         auto textLayoutProperty = textNextPrevNode->GetLayoutProperty<TextLayoutProperty>();
620         CHECK_NULL_VOID(textLayoutProperty);
621         textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.next"));
622         textNextPrevNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
623     } else {
624         auto nextButton = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(NEXT_BUTTON_INDEX));
625         CHECK_NULL_VOID(nextButton);
626         auto layoutProperty = nextButton->GetLayoutProperty<LayoutProperty>();
627         CHECK_NULL_VOID(layoutProperty);
628         layoutProperty->UpdateVisibility(VisibleType::VISIBLE);
629         auto divideNode = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(DIVIDER_ROWS_THREE));
630         CHECK_NULL_VOID(divideNode);
631         auto divideLayoutProperty = divideNode->GetLayoutProperty<LayoutProperty>();
632         CHECK_NULL_VOID(divideLayoutProperty);
633         divideLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
634         auto confirmButton = AceType::DynamicCast<FrameNode>(contentRow->GetLastChild());
635         CHECK_NULL_VOID(confirmButton);
636         auto confirmButtonLayoutProperty = confirmButton->GetLayoutProperty<LayoutProperty>();
637         CHECK_NULL_VOID(confirmButtonLayoutProperty);
638         confirmButtonLayoutProperty->UpdateVisibility(VisibleType::VISIBLE);
639     }
640 }
641 
CreateButtonNodeForAging(const DatePickerSettingData & settingData,const RefPtr<FrameNode> & timePickerNode,const RefPtr<FrameNode> & monthAndDayNode,const RefPtr<FrameNode> & datePickerNode,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)642 RefPtr<FrameNode> DatePickerDialogView::CreateButtonNodeForAging(const DatePickerSettingData& settingData,
643     const RefPtr<FrameNode>& timePickerNode, const RefPtr<FrameNode>& monthAndDayNode,
644     const RefPtr<FrameNode>& datePickerNode, const std::vector<ButtonInfo>& buttonInfos,
645     std::map<std::string, NG::DialogEvent> dialogEvent,
646     std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
647 {
648     auto acceptEvent = dialogEvent["acceptId"];
649     auto dateAcceptEvent = dialogEvent["dateAcceptId"];
650     auto cancelEvent = dialogCancelEvent["cancelId"];
651     auto contentRow = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
652         AceType::MakeRefPtr<LinearLayoutPattern>(false));
653     CHECK_NULL_RETURN(contentRow, nullptr);
654     auto layoutProps = contentRow->GetLayoutProperty<LinearLayoutProperty>();
655     CHECK_NULL_RETURN(layoutProps, nullptr);
656     layoutProps->UpdateMainAxisAlign(FlexAlign::SPACE_AROUND);
657     layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
658     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
659         MarginProperty margin;
660         margin.top = CalcLength(PICKER_MARGIN_FROM_TITLE_AND_BUTTON);
661         layoutProps->UpdateMargin(margin);
662     }
663 
664     contentRow->SetNeedCallChildrenUpdate(false);
665     SetDialogDateAcceptEvent(monthAndDayNode, std::move(dateAcceptEvent));
666 
667     auto buttonCancelNode = CreateCancelNode(cancelEvent, datePickerNode, buttonInfos);
668     CHECK_NULL_RETURN(buttonCancelNode, nullptr);
669     auto buttonConfirmNode = CreateConfirmNode(monthAndDayNode, datePickerNode, acceptEvent, buttonInfos);
670     CHECK_NULL_RETURN(buttonConfirmNode, nullptr);
671     auto cancelNextDividerNode = CreateDividerNode(datePickerNode, true);
672     CHECK_NULL_RETURN(cancelNextDividerNode, nullptr);
673     auto nextConfirmDividerNode = CreateDividerNode(datePickerNode, true);
674     CHECK_NULL_RETURN(nextConfirmDividerNode, nullptr);
675 
676     buttonCancelNode->MountToParent(contentRow);
677     buttonConfirmNode->MountToParent(contentRow);
678 
679     RefPtr<FrameNode> buttonNextPreNode = nullptr;
680 
681     auto timePickerSwitchEvent =
682         CreateAndSetTimePickerSwitchEvent(monthAndDayNode, timePickerNode, contentRow);
683     buttonNextPreNode = CreateNextPrevButtonNode(
684         timePickerSwitchEvent, datePickerNode, buttonInfos, contentRow);
685     CHECK_NULL_RETURN(buttonNextPreNode, nullptr);
686     contentRow->AddChild(buttonNextPreNode, 1);
687     contentRow->AddChild(cancelNextDividerNode, 1);
688     contentRow->AddChild(nextConfirmDividerNode, DIVIDER_ROWS_THREE);
689 
690     auto layoutProperty = buttonConfirmNode->GetLayoutProperty<LayoutProperty>();
691     CHECK_NULL_RETURN(layoutProperty, nullptr);
692     layoutProperty->UpdateVisibility(VisibleType::GONE);
693     auto nextConfirmDividerProperty = nextConfirmDividerNode->GetLayoutProperty<LayoutProperty>();
694     CHECK_NULL_RETURN(nextConfirmDividerProperty, nullptr);
695     nextConfirmDividerProperty->UpdateVisibility(VisibleType::GONE);
696 
697     auto datePickerPattern = monthAndDayNode->GetPattern<DatePickerPattern>();
698     datePickerPattern->SetContentRowNode(contentRow);
699 
700     return contentRow;
701 }
702 
CreateConfirmNode(const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & datePickerNode,DialogEvent & acceptEvent,const std::vector<ButtonInfo> & buttonInfos)703 RefPtr<FrameNode> DatePickerDialogView::CreateConfirmNode(const RefPtr<FrameNode>& dateNode,
704     const RefPtr<FrameNode>& datePickerNode, DialogEvent& acceptEvent, const std::vector<ButtonInfo>& buttonInfos)
705 {
706     auto pipeline = PipelineContext::GetCurrentContext();
707     CHECK_NULL_RETURN(pipeline, nullptr);
708     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
709     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
710 
711     auto buttonConfirmNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
712         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
713     auto textConfirmNode = FrameNode::CreateFrameNode(
714         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
715     CHECK_NULL_RETURN(buttonConfirmNode, nullptr);
716     CHECK_NULL_RETURN(textConfirmNode, nullptr);
717     auto textLayoutProperty = textConfirmNode->GetLayoutProperty<TextLayoutProperty>();
718     CHECK_NULL_RETURN(textLayoutProperty, nullptr);
719     UpdateConfirmButtonTextLayoutProperty(textLayoutProperty, pickerTheme);
720     auto datePickerPattern = datePickerNode->GetPattern<DatePickerPattern>();
721     datePickerPattern->SetConfirmNode(buttonConfirmNode);
722     auto buttonConfirmEventHub = buttonConfirmNode->GetEventHub<ButtonEventHub>();
723     CHECK_NULL_RETURN(buttonConfirmEventHub, nullptr);
724     buttonConfirmEventHub->SetStateEffect(true);
725 
726     auto buttonConfirmLayoutProperty = buttonConfirmNode->GetLayoutProperty<ButtonLayoutProperty>();
727     CHECK_NULL_RETURN(buttonConfirmLayoutProperty, nullptr);
728     UpdateButtonLayoutProperty(buttonConfirmLayoutProperty, pickerTheme);
729     auto buttonConfirmRenderContext = buttonConfirmNode->GetRenderContext();
730     buttonConfirmRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
731     UpdateButtonStyles(buttonInfos, ACCEPT_BUTTON_INDEX, buttonConfirmLayoutProperty, buttonConfirmRenderContext);
732     UpdateButtonDefaultFocus(buttonInfos, buttonConfirmNode, true);
733     textConfirmNode->MountToParent(buttonConfirmNode);
734     auto eventConfirmHub = buttonConfirmNode->GetOrCreateGestureEventHub();
735     CHECK_NULL_RETURN(eventConfirmHub, nullptr);
736     CHECK_NULL_RETURN(dateNode, nullptr);
737     SetDialogAcceptEvent(dateNode, std::move(acceptEvent));
738     auto clickCallback = [weak = WeakPtr<FrameNode>(dateNode)](const GestureEvent& /* info */) {
739         auto dateNode = weak.Upgrade();
740         CHECK_NULL_VOID(dateNode);
741         auto pickerPattern = dateNode->GetPattern<DatePickerPattern>();
742         CHECK_NULL_VOID(pickerPattern);
743         auto datePickerEventHub = pickerPattern->GetEventHub<DatePickerEventHub>();
744         CHECK_NULL_VOID(datePickerEventHub);
745         datePickerEventHub->FireDialogAcceptEvent(pickerPattern->GetSelectedObject(true));
746     };
747     eventConfirmHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(clickCallback));
748     buttonConfirmNode->MarkModifyDone();
749     return buttonConfirmNode;
750 }
751 
UpdateConfirmButtonTextLayoutProperty(const RefPtr<TextLayoutProperty> & textLayoutProperty,const RefPtr<PickerTheme> & pickerTheme)752 void DatePickerDialogView::UpdateConfirmButtonTextLayoutProperty(
753     const RefPtr<TextLayoutProperty>& textLayoutProperty, const RefPtr<PickerTheme>& pickerTheme)
754 {
755     CHECK_NULL_VOID(textLayoutProperty);
756     textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.ok"));
757     textLayoutProperty->UpdateTextColor(pickerTheme->GetOptionStyle(true, false).GetTextColor());
758     if (!NeedAdaptForAging()) {
759         textLayoutProperty->UpdateMaxFontScale(pickerTheme->GetNormalFontScale());
760     }
761     textLayoutProperty->UpdateFontSize(
762         ConvertFontScaleValue(pickerTheme->GetOptionStyle(false, false).GetFontSize()));
763     textLayoutProperty->UpdateFontWeight(pickerTheme->GetOptionStyle(true, false).GetFontWeight());
764 }
765 
UpdateCancelButtonTextLayoutProperty(const RefPtr<TextLayoutProperty> & textCancelLayoutProperty,const RefPtr<PickerTheme> & pickerTheme)766 void DatePickerDialogView::UpdateCancelButtonTextLayoutProperty(
767     const RefPtr<TextLayoutProperty>& textCancelLayoutProperty, const RefPtr<PickerTheme>& pickerTheme)
768 {
769     CHECK_NULL_VOID(textCancelLayoutProperty);
770     textCancelLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.cancel"));
771     textCancelLayoutProperty->UpdateTextColor(pickerTheme->GetOptionStyle(true, false).GetTextColor());
772     if (!NeedAdaptForAging()) {
773         textCancelLayoutProperty->UpdateMaxFontScale(pickerTheme->GetNormalFontScale());
774     }
775     textCancelLayoutProperty->UpdateFontSize(pickerTheme->GetOptionStyle(false, false).GetFontSize());
776     textCancelLayoutProperty->UpdateFontWeight(pickerTheme->GetOptionStyle(true, false).GetFontWeight());
777 }
778 
UpdateButtonLayoutProperty(const RefPtr<ButtonLayoutProperty> & buttonConfirmLayoutProperty,const RefPtr<PickerTheme> & pickerTheme)779 void DatePickerDialogView::UpdateButtonLayoutProperty(
780     const RefPtr<ButtonLayoutProperty>& buttonConfirmLayoutProperty, const RefPtr<PickerTheme>& pickerTheme)
781 {
782     CHECK_NULL_VOID(buttonConfirmLayoutProperty);
783     buttonConfirmLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.ok"));
784     buttonConfirmLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
785     buttonConfirmLayoutProperty->UpdateType(ButtonType::CAPSULE);
786     buttonConfirmLayoutProperty->UpdateFlexShrink(1.0);
787     auto pipeline = PipelineBase::GetCurrentContext();
788     CHECK_NULL_VOID(pipeline);
789     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
790     CHECK_NULL_VOID(dialogTheme);
791     UpdateConfirmButtonMargin(buttonConfirmLayoutProperty, dialogTheme);
792     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
793         buttonConfirmLayoutProperty->UpdateUserDefinedIdealSize(
794             CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
795     } else {
796         auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
797         CHECK_NULL_VOID(buttonTheme);
798         buttonConfirmLayoutProperty->UpdateUserDefinedIdealSize(
799             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
800     }
801 }
802 
UpdateConfirmButtonMargin(const RefPtr<ButtonLayoutProperty> & buttonConfirmLayoutProperty,const RefPtr<DialogTheme> & dialogTheme)803 void DatePickerDialogView::UpdateConfirmButtonMargin(
804     const RefPtr<ButtonLayoutProperty>& buttonConfirmLayoutProperty, const RefPtr<DialogTheme>& dialogTheme)
805 {
806     MarginProperty margin;
807     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
808         margin.right = CalcLength(dialogTheme->GetDividerPadding().Right());
809         margin.top = CalcLength(BUTTON_BOTTOM_TOP_MARGIN);
810         margin.bottom = CalcLength(BUTTON_BOTTOM_TOP_MARGIN);
811         margin.left = CalcLength(0.0_vp);
812     } else {
813         margin.right = CalcLength(TITLE_PADDING_HORIZONTAL);
814         margin.top = CalcLength(TITLE_PADDING_HORIZONTAL);
815         margin.bottom = CalcLength(TITLE_PADDING_HORIZONTAL);
816         margin.left = CalcLength(0.0_vp);
817     }
818     buttonConfirmLayoutProperty->UpdateMargin(margin);
819 }
820 
UpdateCancelButtonMargin(const RefPtr<ButtonLayoutProperty> & buttonCancelLayoutProperty,const RefPtr<DialogTheme> & dialogTheme)821 void DatePickerDialogView::UpdateCancelButtonMargin(
822     const RefPtr<ButtonLayoutProperty>& buttonCancelLayoutProperty, const RefPtr<DialogTheme>& dialogTheme)
823 {
824     MarginProperty margin;
825     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
826         margin.left = CalcLength(dialogTheme->GetDividerPadding().Left());
827         margin.top = CalcLength(BUTTON_BOTTOM_TOP_MARGIN);
828         margin.bottom = CalcLength(BUTTON_BOTTOM_TOP_MARGIN);
829         margin.right = CalcLength(0.0_vp);
830     } else {
831         margin.left = CalcLength(TITLE_PADDING_HORIZONTAL);
832         margin.top = CalcLength(TITLE_PADDING_HORIZONTAL);
833         margin.bottom = CalcLength(TITLE_PADDING_HORIZONTAL);
834         margin.right = CalcLength(0.0_vp);
835     }
836     buttonCancelLayoutProperty->UpdateMargin(margin);
837 }
838 
UpdateNextButtonMargin(const RefPtr<ButtonLayoutProperty> & buttonNextLayoutProperty)839 void DatePickerDialogView::UpdateNextButtonMargin(const RefPtr<ButtonLayoutProperty>& buttonNextLayoutProperty)
840 {
841     auto pipeline = PipelineContext::GetCurrentContextSafely();
842     CHECK_NULL_VOID(pipeline);
843     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
844     CHECK_NULL_VOID(dialogTheme);
845     MarginProperty margin;
846     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
847         margin.right = CalcLength(dialogTheme->GetDividerPadding().Left());
848         margin.left = CalcLength(dialogTheme->GetDividerPadding().Left());
849         margin.top = CalcLength(BUTTON_BOTTOM_TOP_MARGIN);
850         margin.bottom = CalcLength(BUTTON_BOTTOM_TOP_MARGIN);
851     } else {
852         margin.right = CalcLength(TITLE_PADDING_HORIZONTAL);
853         margin.left = CalcLength(TITLE_PADDING_HORIZONTAL);
854         margin.top = CalcLength(TITLE_PADDING_HORIZONTAL);
855         margin.bottom = CalcLength(TITLE_PADDING_HORIZONTAL);
856     }
857     buttonNextLayoutProperty->UpdateMargin(margin);
858 }
859 
UpdateButtonStyles(const std::vector<ButtonInfo> & buttonInfos,size_t index,const RefPtr<ButtonLayoutProperty> & buttonLayoutProperty,const RefPtr<RenderContext> & buttonRenderContext)860 void DatePickerDialogView::UpdateButtonStyles(const std::vector<ButtonInfo>& buttonInfos, size_t index,
861     const RefPtr<ButtonLayoutProperty>& buttonLayoutProperty, const RefPtr<RenderContext>& buttonRenderContext)
862 {
863     if (index >= buttonInfos.size()) {
864         return;
865     }
866     CHECK_NULL_VOID(buttonLayoutProperty);
867     CHECK_NULL_VOID(buttonRenderContext);
868     auto pipeline = PipelineContext::GetCurrentContextSafelyWithCheck();
869     CHECK_NULL_VOID(pipeline);
870     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
871     CHECK_NULL_VOID(buttonTheme);
872     if (buttonInfos[index].type.has_value()) {
873         buttonLayoutProperty->UpdateType(buttonInfos[index].type.value());
874     }
875     UpdateButtonStyleAndRole(buttonInfos, index, buttonLayoutProperty, buttonRenderContext, buttonTheme);
876     if (buttonInfos[index].fontSize.has_value()) {
877         buttonLayoutProperty->UpdateFontSize(ConvertFontScaleValue(buttonInfos[index].fontSize.value()));
878     }
879     if (buttonInfos[index].fontColor.has_value()) {
880         buttonLayoutProperty->UpdateFontColor(buttonInfos[index].fontColor.value());
881     }
882     if (buttonInfos[index].fontWeight.has_value()) {
883         buttonLayoutProperty->UpdateFontWeight(buttonInfos[index].fontWeight.value());
884     }
885     if (buttonInfos[index].fontStyle.has_value()) {
886         buttonLayoutProperty->UpdateFontStyle(buttonInfos[index].fontStyle.value());
887     }
888     if (buttonInfos[index].fontFamily.has_value()) {
889         buttonLayoutProperty->UpdateFontFamily(buttonInfos[index].fontFamily.value());
890     }
891     if (buttonInfos[index].borderRadius.has_value()) {
892         buttonLayoutProperty->UpdateBorderRadius(buttonInfos[index].borderRadius.value());
893     }
894     if (buttonInfos[index].backgroundColor.has_value()) {
895         buttonRenderContext->UpdateBackgroundColor(buttonInfos[index].backgroundColor.value());
896     }
897 }
898 
UpdateButtonStyleAndRole(const std::vector<ButtonInfo> & buttonInfos,size_t index,const RefPtr<ButtonLayoutProperty> & buttonLayoutProperty,const RefPtr<RenderContext> & buttonRenderContext,const RefPtr<ButtonTheme> & buttonTheme)899 void DatePickerDialogView::UpdateButtonStyleAndRole(const std::vector<ButtonInfo>& buttonInfos, size_t index,
900     const RefPtr<ButtonLayoutProperty>& buttonLayoutProperty, const RefPtr<RenderContext>& buttonRenderContext,
901     const RefPtr<ButtonTheme>& buttonTheme)
902 {
903     if (index >= buttonInfos.size()) {
904         return;
905     }
906     CHECK_NULL_VOID(buttonLayoutProperty);
907     CHECK_NULL_VOID(buttonRenderContext);
908     CHECK_NULL_VOID(buttonTheme);
909     if (buttonInfos[index].role.has_value()) {
910         buttonLayoutProperty->UpdateButtonRole(buttonInfos[index].role.value());
911         ButtonStyleMode buttonStyleMode;
912         if (buttonInfos[index].buttonStyle.has_value()) {
913             buttonStyleMode = buttonInfos[index].buttonStyle.value();
914         } else {
915             buttonStyleMode = buttonLayoutProperty->GetButtonStyle().value_or(ButtonStyleMode::EMPHASIZE);
916         }
917         auto bgColor = buttonTheme->GetBgColor(buttonStyleMode, buttonInfos[index].role.value());
918         auto textColor = buttonTheme->GetTextColor(buttonStyleMode, buttonInfos[index].role.value());
919         buttonRenderContext->UpdateBackgroundColor(bgColor);
920         buttonLayoutProperty->UpdateFontColor(textColor);
921     }
922     if (buttonInfos[index].buttonStyle.has_value()) {
923         buttonLayoutProperty->UpdateButtonStyle(buttonInfos[index].buttonStyle.value());
924         ButtonRole buttonRole = buttonLayoutProperty->GetButtonRole().value_or(ButtonRole::NORMAL);
925         auto bgColor = buttonTheme->GetBgColor(buttonInfos[index].buttonStyle.value(), buttonRole);
926         auto textColor = buttonTheme->GetTextColor(buttonInfos[index].buttonStyle.value(), buttonRole);
927         buttonRenderContext->UpdateBackgroundColor(bgColor);
928         buttonLayoutProperty->UpdateFontColor(textColor);
929     }
930 }
931 
CreateDateNode(int32_t dateNodeId,std::map<std::string,PickerDate> datePickerProperty,const PickerTextProperties & properties,bool isLunar,bool showTime)932 RefPtr<FrameNode> DatePickerDialogView::CreateDateNode(int32_t dateNodeId,
933     std::map<std::string, PickerDate> datePickerProperty, const PickerTextProperties& properties, bool isLunar,
934     bool showTime)
935 {
936     ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::DATE_PICKER_ETS_TAG, dateNodeId);
937     auto dateNode = FrameNode::GetOrCreateFrameNode(
938         V2::DATE_PICKER_ETS_TAG, dateNodeId, []() { return AceType::MakeRefPtr<DatePickerPattern>(); });
939     CHECK_NULL_RETURN(dateNode, nullptr);
940     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
941     CHECK_NULL_RETURN(datePickerPattern, nullptr);
942 
943     auto pipeline = PipelineBase::GetCurrentContext();
944     CHECK_NULL_RETURN(pipeline, nullptr);
945     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
946     CHECK_NULL_RETURN(dialogTheme, nullptr);
947     datePickerPattern->SetBackgroundColor(dialogTheme->GetBackgroundColor());
948     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
949     CHECK_NULL_RETURN(pickerTheme, nullptr);
950     uint32_t showCount = pickerTheme->GetShowOptionCount() + BUFFER_NODE_NUMBER;
951     datePickerPattern->SetShowCount(showCount);
952 
953     if (showTime) {
954         CreateSingleDateNode(dateNode, showCount);
955     } else {
956         CreateNormalDateNode(dateNode, showCount);
957     }
958 
959     PickerDate parseStartDate;
960     PickerDate parseEndDate;
961     PickerDate parseSelectedDate;
962     SetShowLunar(dateNode, isLunar);
963     SetDateTextProperties(dateNode, properties);
964     auto iterStart = datePickerProperty.find("start");
965     if (iterStart != datePickerProperty.end()) {
966         parseStartDate = iterStart->second;
967         SetStartDate(dateNode, parseStartDate);
968     }
969     auto iterEnd = datePickerProperty.find("end");
970     if (iterEnd != datePickerProperty.end()) {
971         parseEndDate = iterEnd->second;
972         SetEndDate(dateNode, parseEndDate);
973     }
974     auto iterSelected = datePickerProperty.find("selected");
975     if (iterSelected != datePickerProperty.end()) {
976         parseSelectedDate = iterSelected->second;
977         SetSelectedDate(dateNode, parseSelectedDate);
978     }
979     return dateNode;
980 }
981 
CreateColumnNode(int32_t nodeId,uint32_t showCount,bool isDate)982 RefPtr<FrameNode> DatePickerDialogView::CreateColumnNode(int32_t nodeId, uint32_t showCount, bool isDate)
983 {
984     RefPtr<FrameNode> columnNode;
985     if (isDate) {
986         columnNode = FrameNode::GetOrCreateFrameNode(
987             V2::COLUMN_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<DatePickerColumnPattern>(); });
988     } else {
989         columnNode = FrameNode::GetOrCreateFrameNode(
990             V2::COLUMN_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<TimePickerColumnPattern>(); });
991     }
992     CHECK_NULL_RETURN(columnNode, nullptr);
993     columnNode->Clean();
994     for (uint32_t index = 0; index < showCount; index++) {
995         auto textNode = FrameNode::CreateFrameNode(
996             V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
997         CHECK_NULL_RETURN(textNode, nullptr);
998         textNode->MountToParent(columnNode);
999     }
1000     columnNode->MarkModifyDone();
1001     return columnNode;
1002 }
1003 
CreateNormalDateNode(const RefPtr<FrameNode> & dateNode,uint32_t showCount)1004 void DatePickerDialogView::CreateNormalDateNode(const RefPtr<FrameNode>& dateNode, uint32_t showCount)
1005 {
1006     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
1007     CHECK_NULL_VOID(datePickerPattern);
1008     datePickerPattern->SetShowMonthDaysFlag(false);
1009 
1010     auto yearColumnNode = CreateColumnNode(datePickerPattern->GetYearId(), showCount);
1011     auto monthColumnNode = CreateColumnNode(datePickerPattern->GetMonthId(), showCount);
1012     auto dayColumnNode = CreateColumnNode(datePickerPattern->GetDayId(), showCount);
1013     CHECK_NULL_VOID(yearColumnNode);
1014     CHECK_NULL_VOID(monthColumnNode);
1015     CHECK_NULL_VOID(dayColumnNode);
1016     datePickerPattern->SetColumn(yearColumnNode);
1017     datePickerPattern->SetColumn(monthColumnNode);
1018     datePickerPattern->SetColumn(dayColumnNode);
1019 
1020     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1021         MountColumnNodeToPicker(yearColumnNode, dateNode, RATIO_THREE);
1022         MountColumnNodeToPicker(monthColumnNode, dateNode, RATIO_TWO);
1023         MountColumnNodeToPicker(dayColumnNode, dateNode, RATIO_TWO);
1024     } else {
1025         MountColumnNodeToPicker(yearColumnNode, dateNode);
1026         MountColumnNodeToPicker(monthColumnNode, dateNode);
1027         MountColumnNodeToPicker(dayColumnNode, dateNode);
1028     }
1029 }
1030 
CreateSingleDateNode(const RefPtr<FrameNode> & dateNode,uint32_t showCount)1031 void DatePickerDialogView::CreateSingleDateNode(const RefPtr<FrameNode>& dateNode, uint32_t showCount)
1032 {
1033     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
1034     CHECK_NULL_VOID(datePickerPattern);
1035     datePickerPattern->SetShowMonthDaysFlag(true);
1036 
1037     auto monthDaysColumnNode = CreateColumnNode(datePickerPattern->GetMonthDaysId(), showCount);
1038     auto yearColumnNode = CreateColumnNode(datePickerPattern->GetYearId(), showCount);
1039     CHECK_NULL_VOID(monthDaysColumnNode);
1040     CHECK_NULL_VOID(yearColumnNode);
1041     datePickerPattern->SetColumn(monthDaysColumnNode);
1042     datePickerPattern->SetColumn(yearColumnNode);
1043 
1044     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1045         MountColumnNodeToPicker(monthDaysColumnNode, dateNode, RATIO_FOUR);
1046     } else {
1047         MountColumnNodeToPicker(monthDaysColumnNode, dateNode);
1048     }
1049 
1050     {
1051         auto stackYearNode = CreateStackNode();
1052         auto blendYearNode = CreateColumnNode();
1053         auto buttonYearNode = CreateButtonNode();
1054         buttonYearNode->MountToParent(stackYearNode);
1055         yearColumnNode->MountToParent(blendYearNode);
1056         blendYearNode->MountToParent(stackYearNode);
1057         auto layoutProperty = stackYearNode->GetLayoutProperty<LayoutProperty>();
1058         layoutProperty->UpdateAlignment(Alignment::CENTER);
1059         if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1060             auto blendYearNodeLayoutProperty = blendYearNode->GetLayoutProperty<LayoutProperty>();
1061             CHECK_NULL_VOID(blendYearNodeLayoutProperty);
1062             blendYearNodeLayoutProperty->UpdateVisibility(VisibleType::GONE);
1063             auto buttonYearNodeLayoutProperty = buttonYearNode->GetLayoutProperty<LayoutProperty>();
1064             CHECK_NULL_VOID(buttonYearNodeLayoutProperty);
1065             buttonYearNodeLayoutProperty->UpdateVisibility(VisibleType::GONE);
1066         } else {
1067             layoutProperty->UpdateVisibility(VisibleType::GONE);
1068         }
1069         layoutProperty->UpdateLayoutWeight(0);
1070         stackYearNode->MountToParent(dateNode);
1071     }
1072 }
1073 
CreateTimeNode(std::map<std::string,PickerTime> timePickerProperty,const PickerTextProperties & properties,bool useMilitaryTime)1074 RefPtr<FrameNode> DatePickerDialogView::CreateTimeNode(
1075     std::map<std::string, PickerTime> timePickerProperty, const PickerTextProperties& properties, bool useMilitaryTime)
1076 {
1077     auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1078     ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::TIME_PICKER_ETS_TAG, nodeId);
1079     auto timePickerNode = FrameNode::GetOrCreateFrameNode(
1080         V2::TIME_PICKER_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<TimePickerRowPattern>(); });
1081     CHECK_NULL_RETURN(timePickerNode, nullptr);
1082     auto timePickerRowPattern = timePickerNode->GetPattern<TimePickerRowPattern>();
1083     CHECK_NULL_RETURN(timePickerRowPattern, nullptr);
1084 
1085     auto pipeline = PipelineBase::GetCurrentContext();
1086     CHECK_NULL_RETURN(pipeline, nullptr);
1087     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1088     CHECK_NULL_RETURN(pickerTheme, nullptr);
1089     uint32_t showCount = pickerTheme->GetShowOptionCount() + BUFFER_NODE_NUMBER;
1090     timePickerRowPattern->SetShowCount(showCount);
1091     timePickerRowPattern->SetIsShowInDatePickerDialog(true);
1092 
1093     auto hasHourNode = timePickerRowPattern->HasHourNode();
1094     auto hasMinuteNode = timePickerRowPattern->HasMinuteNode();
1095 
1096     auto hourColumnNode = CreateColumnNode(timePickerRowPattern->GetHourId(), showCount, false);
1097     auto minuteColumnNode = CreateColumnNode(timePickerRowPattern->GetMinuteId(), showCount, false);
1098     CHECK_NULL_RETURN(hourColumnNode, nullptr);
1099     CHECK_NULL_RETURN(minuteColumnNode, nullptr);
1100     timePickerRowPattern->SetColumn(hourColumnNode);
1101     timePickerRowPattern->SetColumn(minuteColumnNode);
1102 
1103     if (!hasHourNode) {
1104         MountColumnNodeToPicker(hourColumnNode, timePickerNode);
1105     }
1106     if (!hasMinuteNode) {
1107         MountColumnNodeToPicker(minuteColumnNode, timePickerNode);
1108     }
1109     auto it = timePickerProperty.find("selected");
1110     if (it != timePickerProperty.end()) {
1111         auto selectedTime = it->second;
1112         timePickerRowPattern->SetSelectedTime(selectedTime);
1113     }
1114     timePickerRowPattern->SetHour24(useMilitaryTime);
1115 
1116     SetTimeTextProperties(timePickerNode, properties);
1117     return timePickerNode;
1118 }
1119 
MountColumnNodeToPicker(const RefPtr<FrameNode> & columnNode,const RefPtr<FrameNode> & pickerNode,uint32_t columnWeight)1120 void DatePickerDialogView::MountColumnNodeToPicker(
1121     const RefPtr<FrameNode>& columnNode, const RefPtr<FrameNode>& pickerNode, uint32_t columnWeight)
1122 {
1123     auto stackNode = CreateStackNode();
1124     auto blendNode = CreateColumnNode();
1125     auto buttonNode = CreateButtonNode();
1126     buttonNode->MountToParent(stackNode);
1127     columnNode->MountToParent(blendNode);
1128     blendNode->MountToParent(stackNode);
1129     auto layoutProperty = stackNode->GetLayoutProperty<LayoutProperty>();
1130     layoutProperty->UpdateAlignment(Alignment::CENTER);
1131     layoutProperty->UpdateLayoutWeight(columnWeight);
1132     stackNode->MountToParent(pickerNode);
1133 }
1134 
CreateCancelNode(NG::DialogGestureEvent & cancelEvent,const RefPtr<FrameNode> & datePickerNode,const std::vector<ButtonInfo> & buttonInfos)1135 RefPtr<FrameNode> DatePickerDialogView::CreateCancelNode(NG::DialogGestureEvent& cancelEvent,
1136     const RefPtr<FrameNode>& datePickerNode, const std::vector<ButtonInfo>& buttonInfos)
1137 {
1138     auto pipeline = PipelineContext::GetCurrentContext();
1139     CHECK_NULL_RETURN(pipeline, nullptr);
1140     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
1141     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
1142     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1143     auto buttonCancelNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
1144         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1145     CHECK_NULL_RETURN(buttonCancelNode, nullptr);
1146     auto textCancelNode = FrameNode::CreateFrameNode(
1147         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
1148     CHECK_NULL_RETURN(textCancelNode, nullptr);
1149     auto textCancelLayoutProperty = textCancelNode->GetLayoutProperty<TextLayoutProperty>();
1150     CHECK_NULL_RETURN(textCancelLayoutProperty, nullptr);
1151     UpdateCancelButtonTextLayoutProperty(textCancelLayoutProperty, pickerTheme);
1152     auto datePickerPattern = datePickerNode->GetPattern<DatePickerPattern>();
1153     datePickerPattern->SetCancelNode(buttonCancelNode);
1154     textCancelNode->MountToParent(buttonCancelNode);
1155     auto eventCancelHub = buttonCancelNode->GetOrCreateGestureEventHub();
1156     CHECK_NULL_RETURN(eventCancelHub, nullptr);
1157     eventCancelHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(std::move(cancelEvent)));
1158 
1159     auto buttonCancelEventHub = buttonCancelNode->GetEventHub<ButtonEventHub>();
1160     CHECK_NULL_RETURN(buttonCancelEventHub, nullptr);
1161     buttonCancelEventHub->SetStateEffect(true);
1162 
1163     auto buttonCancelLayoutProperty = buttonCancelNode->GetLayoutProperty<ButtonLayoutProperty>();
1164     buttonCancelLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.cancel"));
1165     buttonCancelLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
1166     buttonCancelLayoutProperty->UpdateType(ButtonType::CAPSULE);
1167     buttonCancelLayoutProperty->UpdateFlexShrink(1.0);
1168     UpdateCancelButtonMargin(buttonCancelLayoutProperty, dialogTheme);
1169     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1170         buttonCancelLayoutProperty->UpdateUserDefinedIdealSize(
1171             CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
1172     } else {
1173         buttonCancelLayoutProperty->UpdateUserDefinedIdealSize(
1174             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
1175     }
1176 
1177     auto buttonCancelRenderContext = buttonCancelNode->GetRenderContext();
1178     buttonCancelRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
1179     UpdateButtonStyles(buttonInfos, CANCEL_BUTTON_INDEX, buttonCancelLayoutProperty, buttonCancelRenderContext);
1180     UpdateButtonDefaultFocus(buttonInfos, buttonCancelNode, false);
1181     buttonCancelNode->MarkModifyDone();
1182     return buttonCancelNode;
1183 }
1184 
UpdateCheckboxPaintProperty(const RefPtr<CheckBoxPaintProperty> & checkboxPaintProps,bool isLunar,const CheckboxSettingData & checkboxSettingData)1185 void DatePickerDialogView::UpdateCheckboxPaintProperty(const RefPtr<CheckBoxPaintProperty>& checkboxPaintProps,
1186     bool isLunar, const CheckboxSettingData& checkboxSettingData)
1187 {
1188     checkboxPaintProps->UpdateCheckBoxSelect(isLunar);
1189     if (checkboxSettingData.selectedColor.has_value()) {
1190         checkboxPaintProps->UpdateCheckBoxSelectedColor(checkboxSettingData.selectedColor.value());
1191     }
1192     if (checkboxSettingData.unselectedColor.has_value()) {
1193         checkboxPaintProps->UpdateCheckBoxUnSelectedColor(checkboxSettingData.unselectedColor.value());
1194     }
1195     if (checkboxSettingData.strokeColor.has_value()) {
1196         checkboxPaintProps->UpdateCheckBoxCheckMarkColor(checkboxSettingData.strokeColor.value());
1197     }
1198 }
1199 
CreateLunarswitchNode(const RefPtr<FrameNode> & contentColumn,const RefPtr<FrameNode> & dateNode,std::function<void (const bool)> && changeEvent,bool isLunar,const CheckboxSettingData & checkboxSettingData)1200 void DatePickerDialogView::CreateLunarswitchNode(const RefPtr<FrameNode>& contentColumn,
1201     const RefPtr<FrameNode>& dateNode, std::function<void(const bool)>&& changeEvent, bool isLunar,
1202     const CheckboxSettingData& checkboxSettingData)
1203 {
1204     auto pipeline = PipelineBase::GetCurrentContext();
1205     CHECK_NULL_VOID(pipeline);
1206     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1207     CHECK_NULL_VOID(pickerTheme);
1208     auto contentRow = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
1209         AceType::MakeRefPtr<LinearLayoutPattern>(false));
1210     CHECK_NULL_VOID(contentRow);
1211     auto layoutProps = contentRow->GetLayoutProperty<LinearLayoutProperty>();
1212     CHECK_NULL_VOID(layoutProps);
1213     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1214         MarginProperty margin;
1215         margin.bottom = CalcLength(PICKER_MARGIN_FROM_TITLE_AND_BUTTON);
1216         layoutProps->UpdateMargin(margin);
1217     }
1218     layoutProps->UpdateUserDefinedIdealSize(
1219         CalcSize(CalcLength(Dimension(1.0, DimensionUnit::PERCENT)), CalcLength(LUNARSWITCH_HEIGHT)));
1220 
1221     auto checkbox = FrameNode::CreateFrameNode(
1222         V2::CHECK_BOX_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<CheckBoxPattern>());
1223     CHECK_NULL_VOID(checkbox);
1224     auto eventHub = checkbox->GetEventHub<CheckBoxEventHub>();
1225     CHECK_NULL_VOID(eventHub);
1226     eventHub->SetOnChange(std::move(changeEvent));
1227     auto checkboxPaintProps = checkbox->GetPaintProperty<CheckBoxPaintProperty>();
1228     CHECK_NULL_VOID(checkboxPaintProps);
1229     UpdateCheckboxPaintProperty(checkboxPaintProps, isLunar, checkboxSettingData);
1230     auto checkboxPattern = checkbox->GetPattern<CheckBoxPattern>();
1231     checkboxPattern->SaveCheckboxSettingData(checkboxSettingData);
1232     auto checkboxLayoutProps = checkbox->GetLayoutProperty<LayoutProperty>();
1233     CHECK_NULL_VOID(checkboxLayoutProps);
1234     MarginProperty marginCheckbox;
1235     marginCheckbox.left = CalcLength(PICKER_DIALOG_MARGIN_FORM_EDGE);
1236     marginCheckbox.right = CalcLength(PICKER_MARGIN_FROM_TITLE_AND_BUTTON);
1237     checkboxLayoutProps->UpdateMargin(marginCheckbox);
1238     checkboxLayoutProps->UpdateUserDefinedIdealSize(CalcSize(CalcLength(CHECKBOX_SIZE), CalcLength(CHECKBOX_SIZE)));
1239     checkbox->MarkModifyDone();
1240     checkbox->MountToParent(contentRow);
1241 
1242     auto textNode = CreateLunarSwitchTextNode();
1243     CHECK_NULL_VOID(textNode);
1244     textNode->MountToParent(contentRow);
1245     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
1246     CHECK_NULL_VOID(datePickerPattern);
1247     datePickerPattern->SetLunarSwitchTextNode(textNode);
1248 
1249     contentRow->MountToParent(contentColumn);
1250 }
1251 
SetStartDate(const RefPtr<FrameNode> & frameNode,const PickerDate & value)1252 void DatePickerDialogView::SetStartDate(const RefPtr<FrameNode>& frameNode, const PickerDate& value)
1253 {
1254     auto datePickerPattern = frameNode->GetPattern<DatePickerPattern>();
1255     CHECK_NULL_VOID(datePickerPattern);
1256     datePickerPattern->SetStartDate(value);
1257     auto pickerProperty = frameNode->GetLayoutProperty<DataPickerRowLayoutProperty>();
1258     CHECK_NULL_VOID(pickerProperty);
1259     pickerProperty->UpdateStartDate(datePickerPattern->GetStartDateLunar());
1260 }
1261 
SetEndDate(const RefPtr<FrameNode> & frameNode,const PickerDate & value)1262 void DatePickerDialogView::SetEndDate(const RefPtr<FrameNode>& frameNode, const PickerDate& value)
1263 {
1264     auto datePickerPattern = frameNode->GetPattern<DatePickerPattern>();
1265     CHECK_NULL_VOID(datePickerPattern);
1266     datePickerPattern->SetEndDate(value);
1267     auto pickerProperty = frameNode->GetLayoutProperty<DataPickerRowLayoutProperty>();
1268     CHECK_NULL_VOID(pickerProperty);
1269     pickerProperty->UpdateEndDate(datePickerPattern->GetEndDateLunar());
1270 }
1271 
SetSelectedDate(const RefPtr<FrameNode> & frameNode,const PickerDate & value)1272 void DatePickerDialogView::SetSelectedDate(const RefPtr<FrameNode>& frameNode, const PickerDate& value)
1273 {
1274     auto datePickerPattern = frameNode->GetPattern<DatePickerPattern>();
1275     CHECK_NULL_VOID(datePickerPattern);
1276     datePickerPattern->SetSelectDate(value);
1277     auto pickerProperty = frameNode->GetLayoutProperty<DataPickerRowLayoutProperty>();
1278     CHECK_NULL_VOID(pickerProperty);
1279     pickerProperty->UpdateSelectedDate(datePickerPattern->GetSelectDate());
1280 }
1281 
SetShowLunar(const RefPtr<FrameNode> & frameNode,bool lunar)1282 void DatePickerDialogView::SetShowLunar(const RefPtr<FrameNode>& frameNode, bool lunar)
1283 {
1284     auto pickerProperty = frameNode->GetLayoutProperty<DataPickerRowLayoutProperty>();
1285     CHECK_NULL_VOID(pickerProperty);
1286     pickerProperty->UpdateLunar(lunar);
1287 }
1288 
SetDialogChange(const RefPtr<FrameNode> & frameNode,DialogEvent && onChange)1289 void DatePickerDialogView::SetDialogChange(const RefPtr<FrameNode>& frameNode, DialogEvent&& onChange)
1290 {
1291     CHECK_NULL_VOID(frameNode);
1292     auto eventHub = frameNode->GetEventHub<DatePickerEventHub>();
1293     CHECK_NULL_VOID(eventHub);
1294     eventHub->SetDialogChange(std::move(onChange));
1295 }
1296 
SetDialogDateChange(const RefPtr<FrameNode> & frameNode,DialogEvent && onChange)1297 void DatePickerDialogView::SetDialogDateChange(const RefPtr<FrameNode>& frameNode, DialogEvent&& onChange)
1298 {
1299     CHECK_NULL_VOID(frameNode);
1300     auto eventHub = frameNode->GetEventHub<DatePickerEventHub>();
1301     CHECK_NULL_VOID(eventHub);
1302     eventHub->SetDialogDateChange(std::move(onChange));
1303 }
1304 
SetDialogAcceptEvent(const RefPtr<FrameNode> & frameNode,DialogEvent && onChange)1305 void DatePickerDialogView::SetDialogAcceptEvent(const RefPtr<FrameNode>& frameNode, DialogEvent&& onChange)
1306 {
1307     CHECK_NULL_VOID(frameNode);
1308     auto eventHub = frameNode->GetEventHub<DatePickerEventHub>();
1309     CHECK_NULL_VOID(eventHub);
1310     eventHub->SetDialogAcceptEvent(std::move(onChange));
1311 }
1312 
SetDialogDateAcceptEvent(const RefPtr<FrameNode> & frameNode,DialogEvent && onChange)1313 void DatePickerDialogView::SetDialogDateAcceptEvent(const RefPtr<FrameNode>& frameNode, DialogEvent&& onChange)
1314 {
1315     CHECK_NULL_VOID(frameNode);
1316     auto eventHub = frameNode->GetEventHub<DatePickerEventHub>();
1317     CHECK_NULL_VOID(eventHub);
1318     eventHub->SetDialogDateAcceptEvent(std::move(onChange));
1319 }
1320 
SetDialogSwitchEvent(std::function<bool ()> switchEvent,const RefPtr<FrameNode> & pickerStack)1321 void DatePickerDialogView::SetDialogSwitchEvent(std::function<bool()> switchEvent, const RefPtr<FrameNode>& pickerStack)
1322 {
1323     CHECK_NULL_VOID(pickerStack);
1324     auto pipeline = pickerStack->GetContext();
1325     CHECK_NULL_VOID(pipeline);
1326     auto overlayManger = pipeline->GetOverlayManager();
1327     CHECK_NULL_VOID(overlayManger);
1328     overlayManger->SetBackPressEvent(switchEvent);
1329 }
1330 
SetDateTextProperties(const RefPtr<FrameNode> & frameNode,const PickerTextProperties & properties)1331 void DatePickerDialogView::SetDateTextProperties(
1332     const RefPtr<FrameNode>& frameNode, const PickerTextProperties& properties)
1333 {
1334     auto pipeline = PipelineContext::GetCurrentContext();
1335     CHECK_NULL_VOID(pipeline);
1336     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1337     CHECK_NULL_VOID(pickerTheme);
1338     auto selectedStyle = pickerTheme->GetOptionStyle(true, false);
1339     auto disappearStyle = pickerTheme->GetDisappearOptionStyle();
1340     auto normalStyle = pickerTheme->GetOptionStyle(false, false);
1341     auto pickerProperty = frameNode->GetLayoutProperty<DataPickerRowLayoutProperty>();
1342     CHECK_NULL_VOID(pickerProperty);
1343 
1344     if (properties.disappearTextStyle_.fontSize.has_value() && properties.disappearTextStyle_.fontSize->IsValid()) {
1345         pickerProperty->UpdateDisappearFontSize(
1346             ConvertFontScaleValue(properties.disappearTextStyle_.fontSize.value(), disappearTextStyleFont_, true));
1347     } else {
1348         pickerProperty->UpdateDisappearFontSize(ConvertFontScaleValue(disappearStyle.GetFontSize()));
1349     }
1350     pickerProperty->UpdateDisappearColor(
1351         properties.disappearTextStyle_.textColor.value_or(disappearStyle.GetTextColor()));
1352     pickerProperty->UpdateDisappearWeight(
1353         properties.disappearTextStyle_.fontWeight.value_or(disappearStyle.GetFontWeight()));
1354     pickerProperty->UpdateDisappearFontFamily(
1355         properties.disappearTextStyle_.fontFamily.value_or(disappearStyle.GetFontFamilies()));
1356     pickerProperty->UpdateDisappearFontStyle(
1357         properties.disappearTextStyle_.fontStyle.value_or(disappearStyle.GetFontStyle()));
1358 
1359     if (properties.normalTextStyle_.fontSize.has_value() && properties.normalTextStyle_.fontSize->IsValid()) {
1360         pickerProperty->UpdateFontSize(
1361             ConvertFontScaleValue(properties.normalTextStyle_.fontSize.value(), normalTextStyleFont_, true));
1362     } else {
1363         pickerProperty->UpdateFontSize(ConvertFontScaleValue(normalStyle.GetFontSize()));
1364     }
1365     pickerProperty->UpdateColor(properties.normalTextStyle_.textColor.value_or(normalStyle.GetTextColor()));
1366     pickerProperty->UpdateWeight(properties.normalTextStyle_.fontWeight.value_or(normalStyle.GetFontWeight()));
1367     pickerProperty->UpdateFontFamily(properties.normalTextStyle_.fontFamily.value_or(normalStyle.GetFontFamilies()));
1368     pickerProperty->UpdateFontStyle(properties.normalTextStyle_.fontStyle.value_or(normalStyle.GetFontStyle()));
1369 
1370     if (properties.selectedTextStyle_.fontSize.has_value() && properties.selectedTextStyle_.fontSize->IsValid()) {
1371         pickerProperty->UpdateSelectedFontSize(
1372             ConvertFontScaleValue(properties.selectedTextStyle_.fontSize.value(), selectedTextStyleFont_, true));
1373     } else {
1374         pickerProperty->UpdateSelectedFontSize(ConvertFontScaleValue(selectedStyle.GetFontSize()));
1375     }
1376     pickerProperty->UpdateSelectedColor(properties.selectedTextStyle_.textColor.value_or(selectedStyle.GetTextColor()));
1377     pickerProperty->UpdateSelectedWeight(
1378         properties.selectedTextStyle_.fontWeight.value_or(selectedStyle.GetFontWeight()));
1379     pickerProperty->UpdateSelectedFontFamily(
1380         properties.selectedTextStyle_.fontFamily.value_or(selectedStyle.GetFontFamilies()));
1381     pickerProperty->UpdateSelectedFontStyle(
1382         properties.selectedTextStyle_.fontStyle.value_or(selectedStyle.GetFontStyle()));
1383 }
1384 
SetTimeTextProperties(const RefPtr<FrameNode> & frameNode,const PickerTextProperties & properties)1385 void DatePickerDialogView::SetTimeTextProperties(
1386     const RefPtr<FrameNode>& frameNode, const PickerTextProperties& properties)
1387 {
1388     auto pipeline = PipelineContext::GetCurrentContext();
1389     CHECK_NULL_VOID(pipeline);
1390     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1391     CHECK_NULL_VOID(pickerTheme);
1392     auto selectedStyle = pickerTheme->GetOptionStyle(true, false);
1393     auto disappearStyle = pickerTheme->GetDisappearOptionStyle();
1394     auto normalStyle = pickerTheme->GetOptionStyle(false, false);
1395     auto pickerProperty = frameNode->GetLayoutProperty<TimePickerLayoutProperty>();
1396     CHECK_NULL_VOID(pickerProperty);
1397 
1398     if (properties.disappearTextStyle_.fontSize.has_value() && properties.disappearTextStyle_.fontSize->IsValid()) {
1399         pickerProperty->UpdateDisappearFontSize(
1400             ConvertFontScaleValue(properties.disappearTextStyle_.fontSize.value(), disappearTextStyleFont_, true));
1401     } else {
1402         pickerProperty->UpdateDisappearFontSize(ConvertFontScaleValue(disappearStyle.GetFontSize()));
1403     }
1404     pickerProperty->UpdateDisappearColor(
1405         properties.disappearTextStyle_.textColor.value_or(disappearStyle.GetTextColor()));
1406     pickerProperty->UpdateDisappearWeight(
1407         properties.disappearTextStyle_.fontWeight.value_or(disappearStyle.GetFontWeight()));
1408 
1409     if (properties.normalTextStyle_.fontSize.has_value() && properties.normalTextStyle_.fontSize->IsValid()) {
1410         pickerProperty->UpdateFontSize(
1411             ConvertFontScaleValue(properties.normalTextStyle_.fontSize.value(), normalTextStyleFont_, true));
1412     } else {
1413         pickerProperty->UpdateFontSize(ConvertFontScaleValue(normalStyle.GetFontSize()));
1414     }
1415     pickerProperty->UpdateColor(properties.normalTextStyle_.textColor.value_or(normalStyle.GetTextColor()));
1416     pickerProperty->UpdateWeight(properties.normalTextStyle_.fontWeight.value_or(normalStyle.GetFontWeight()));
1417 
1418     if (properties.selectedTextStyle_.fontSize.has_value() && properties.selectedTextStyle_.fontSize->IsValid()) {
1419         pickerProperty->UpdateSelectedFontSize(
1420             ConvertFontScaleValue(properties.selectedTextStyle_.fontSize.value(), selectedTextStyleFont_, true));
1421     } else {
1422         pickerProperty->UpdateSelectedFontSize(ConvertFontScaleValue(selectedStyle.GetFontSize()));
1423     }
1424     pickerProperty->UpdateSelectedColor(properties.selectedTextStyle_.textColor.value_or(selectedStyle.GetTextColor()));
1425     pickerProperty->UpdateSelectedWeight(
1426         properties.selectedTextStyle_.fontWeight.value_or(selectedStyle.GetFontWeight()));
1427 }
1428 
SetTitleMouseHoverEvent(const RefPtr<FrameNode> & titleRow)1429 void DatePickerDialogView::SetTitleMouseHoverEvent(const RefPtr<FrameNode>& titleRow)
1430 {
1431     auto titleButtonNode = AceType::DynamicCast<FrameNode>(titleRow->GetFirstChild());
1432     CHECK_NULL_VOID(titleButtonNode);
1433     auto eventHub = titleButtonNode->GetEventHub<EventHub>();
1434     CHECK_NULL_VOID(eventHub);
1435     auto inputHub = eventHub->GetOrCreateInputEventHub();
1436     auto mouseTask = [weak = WeakPtr<FrameNode>(titleButtonNode)](bool isHover) {
1437         auto titleButtonNode = weak.Upgrade();
1438         CHECK_NULL_VOID(titleButtonNode);
1439         HandleMouseEvent(titleButtonNode, isHover);
1440     };
1441     auto mouseEvent = AceType::MakeRefPtr<InputEvent>(std::move(mouseTask));
1442     CHECK_NULL_VOID(mouseEvent);
1443     inputHub->AddOnHoverEvent(mouseEvent);
1444 }
1445 
HandleMouseEvent(const RefPtr<FrameNode> & titleButton,bool isHover)1446 void DatePickerDialogView::HandleMouseEvent(const RefPtr<FrameNode>& titleButton, bool isHover)
1447 {
1448     if (isHover) {
1449         auto pipeline = PipelineBase::GetCurrentContext();
1450         CHECK_NULL_VOID(pipeline);
1451         auto theme = pipeline->GetTheme<PickerTheme>();
1452         CHECK_NULL_VOID(theme);
1453         PlayHoverAnimation(titleButton, theme->GetHoverColor());
1454     } else {
1455         PlayHoverAnimation(titleButton, Color::TRANSPARENT);
1456     }
1457 }
1458 
PlayHoverAnimation(const RefPtr<FrameNode> & titleButton,const Color & color)1459 void DatePickerDialogView::PlayHoverAnimation(const RefPtr<FrameNode>& titleButton, const Color& color)
1460 {
1461     AnimationOption option = AnimationOption();
1462     option.SetDuration(HOVER_ANIMATION_DURATION);
1463     option.SetCurve(Curves::FRICTION);
1464     option.SetFillMode(FillMode::FORWARDS);
1465     AnimationUtils::Animate(option, [weak = WeakPtr<FrameNode>(titleButton), color]() {
1466         auto titleButton = weak.Upgrade();
1467         auto buttonTitleNode = AceType::DynamicCast<FrameNode>(titleButton);
1468         CHECK_NULL_VOID(buttonTitleNode);
1469         auto buttonTitleRenderContext = buttonTitleNode->GetRenderContext();
1470         buttonTitleRenderContext->UpdateBackgroundColor(color);
1471         buttonTitleNode->MarkDirtyNode();
1472     });
1473 }
1474 
CreateAndMountDateNode(const DatePickerSettingData & settingData,const RefPtr<FrameNode> & pickerStack)1475 RefPtr<FrameNode> DatePickerDialogView::CreateAndMountDateNode(
1476     const DatePickerSettingData& settingData, const RefPtr<FrameNode>& pickerStack)
1477 {
1478     auto dateNodeId = ElementRegister::GetInstance()->MakeUniqueId();
1479     auto dateNode =
1480         CreateDateNode(dateNodeId, settingData.datePickerProperty, settingData.properties, settingData.isLunar, false);
1481     ViewStackProcessor::GetInstance()->Push(dateNode);
1482     dateNode->MountToParent(pickerStack);
1483     return dateNode;
1484 }
1485 
CreateAndMountButtonTitleNode(const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & contentColumn)1486 RefPtr<FrameNode> DatePickerDialogView::CreateAndMountButtonTitleNode(
1487     const RefPtr<FrameNode>& dateNode, const RefPtr<FrameNode>& contentColumn)
1488 {
1489     // create title node and bind title text id to date picker, then mark picker node modify done
1490     auto buttonTitleNode = CreateTitleButtonNode(dateNode);
1491     CHECK_NULL_RETURN(buttonTitleNode, nullptr);
1492 
1493     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
1494     datePickerPattern->SetbuttonTitleNode(buttonTitleNode);
1495 
1496     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1497         auto layoutProps = buttonTitleNode->GetLayoutProperty<LinearLayoutProperty>();
1498         CHECK_NULL_RETURN(layoutProps, nullptr);
1499         PaddingProperty padding;
1500         padding.left = CalcLength(TITLE_PADDING_HORIZONTAL);
1501         padding.right = CalcLength(TITLE_PADDING_HORIZONTAL);
1502         layoutProps->UpdatePadding(padding);
1503         MarginProperty margin;
1504         margin.top = CalcLength(PICKER_MARGIN_FROM_TITLE_AND_BUTTON);
1505         margin.bottom = CalcLength(PICKER_MARGIN_FROM_TITLE_AND_BUTTON);
1506         layoutProps->UpdateMargin(margin);
1507         layoutProps->UpdateUserDefinedIdealSize(
1508             CalcSize(CalcLength(Dimension(1.0, DimensionUnit::PERCENT)), CalcLength(TITLE_HEIGHT)));
1509     }
1510 
1511     buttonTitleNode->MountToParent(contentColumn);
1512     return buttonTitleNode;
1513 }
1514 
CreateLunarChangeEvent(const RefPtr<FrameNode> & dateNode)1515 std::function<void(bool)> DatePickerDialogView::CreateLunarChangeEvent(const RefPtr<FrameNode>& dateNode)
1516 {
1517     return [weak = AceType::WeakClaim(AceType::RawPtr(dateNode))](bool selected) {
1518         auto datePicker = weak.Upgrade();
1519         CHECK_NULL_VOID(datePicker);
1520         auto datePickerPattern = datePicker->GetPattern<DatePickerPattern>();
1521         CHECK_NULL_VOID(datePickerPattern);
1522         SetSelectedDate(datePicker, datePickerPattern->GetCurrentDate());
1523         auto layoutProp = datePicker->GetLayoutProperty<DataPickerRowLayoutProperty>();
1524         CHECK_NULL_VOID(layoutProp);
1525         layoutProp->UpdateLunar(selected);
1526         datePicker->MarkModifyDone();
1527     };
1528 }
1529 
CreateAndMountMonthDaysNode(const DatePickerSettingData & settingData,const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & pickerRow,std::function<void (bool)> && lunarChangeEvent)1530 RefPtr<FrameNode> DatePickerDialogView::CreateAndMountMonthDaysNode(const DatePickerSettingData& settingData,
1531     const RefPtr<FrameNode>& dateNode, const RefPtr<FrameNode>& pickerRow, std::function<void(bool)>&& lunarChangeEvent)
1532 {
1533     auto layoutProperty = dateNode->GetLayoutProperty<LayoutProperty>();
1534     CHECK_NULL_RETURN(layoutProperty, nullptr);
1535     layoutProperty->UpdateVisibility(VisibleType::INVISIBLE);
1536     auto monthDaysNodeId = ElementRegister::GetInstance()->MakeUniqueId();
1537     auto monthDaysNode = CreateDateNode(
1538         monthDaysNodeId, settingData.datePickerProperty, settingData.properties, settingData.isLunar, true);
1539     lunarChangeEvent = [monthDaysNodeWeak = AceType::WeakClaim(AceType::RawPtr(monthDaysNode)),
1540                            dateNodeWeak = AceType::WeakClaim(AceType::RawPtr(dateNode))](bool selected) {
1541         auto monthDaysNode = monthDaysNodeWeak.Upgrade();
1542         auto dateNode = dateNodeWeak.Upgrade();
1543         CHECK_NULL_VOID(monthDaysNode);
1544         CHECK_NULL_VOID(dateNode);
1545         auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
1546         CHECK_NULL_VOID(datePickerPattern);
1547         auto monthDaysPattern = monthDaysNode->GetPattern<DatePickerPattern>();
1548         CHECK_NULL_VOID(monthDaysPattern);
1549         PickerDate selectedDate =
1550             switchFlag_ ? datePickerPattern->GetCurrentDate() : monthDaysPattern->GetCurrentDate();
1551         SetSelectedDate(dateNode, selectedDate);
1552         SetSelectedDate(monthDaysNode, selectedDate);
1553         SetShowLunar(monthDaysNode, selected);
1554         SetShowLunar(dateNode, selected);
1555         monthDaysNode->MarkModifyDone();
1556         dateNode->MarkModifyDone();
1557     };
1558     auto monthDaysPickerPattern = monthDaysNode->GetPattern<DatePickerPattern>();
1559     CHECK_NULL_RETURN(monthDaysPickerPattern, nullptr);
1560     auto pickerPattern = dateNode->GetPattern<DatePickerPattern>();
1561     CHECK_NULL_RETURN(pickerPattern, nullptr);
1562     monthDaysPickerPattern->SetTitleId(pickerPattern->GetTitleId());
1563     monthDaysPickerPattern->SetShowTimeFlag(true);
1564     monthDaysPickerPattern->SetTextProperties(settingData.properties);
1565     pickerPattern->SetShowTimeFlag(true);
1566     auto monthDaysLayoutProperty = monthDaysNode->GetLayoutProperty();
1567     CHECK_NULL_RETURN(monthDaysLayoutProperty, nullptr);
1568     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1569         monthDaysLayoutProperty->UpdateLayoutWeight(settingData.useMilitary ? RATIO_THREE : RATIO_FOUR);
1570     } else {
1571         monthDaysLayoutProperty->UpdateUserDefinedIdealSize(
1572             CalcSize(NG::CalcLength(
1573                 Dimension(settingData.useMilitary ? MONTHDAYS_WIDTH_PERCENT_ONE : MONTHDAYS_WIDTH_PERCENT_TWO,
1574                 DimensionUnit::PERCENT)), std::nullopt));
1575     }
1576     monthDaysNode->MarkModifyDone();
1577     monthDaysNode->MountToParent(pickerRow);
1578     return monthDaysNode;
1579 }
1580 
CreateAndMountTimeNode(const DatePickerSettingData & settingData,const RefPtr<FrameNode> & monthDaysNode,const RefPtr<FrameNode> & pickerRow)1581 RefPtr<FrameNode> DatePickerDialogView::CreateAndMountTimeNode(const DatePickerSettingData& settingData,
1582     const RefPtr<FrameNode>& monthDaysNode, const RefPtr<FrameNode>& pickerRow)
1583 {
1584     auto timeNode = CreateTimeNode(settingData.timePickerProperty, settingData.properties, settingData.useMilitary);
1585     auto timePickerEventHub = timeNode->GetEventHub<TimePickerEventHub>();
1586     CHECK_NULL_RETURN(timePickerEventHub, nullptr);
1587     auto timePickerRowPattern = timeNode->GetPattern<TimePickerRowPattern>();
1588     CHECK_NULL_RETURN(timePickerRowPattern, nullptr);
1589     timePickerRowPattern->SetTextProperties(settingData.properties);
1590     auto timePickerLayout = timeNode->GetLayoutProperty<TimePickerLayoutProperty>();
1591     CHECK_NULL_RETURN(timePickerLayout, nullptr);
1592     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1593         ZeroPrefixType hourOptions = settingData.dateTimeOptions.hourType;
1594         ZeroPrefixType minuteOptions = settingData.dateTimeOptions.minuteType;
1595         if ((timePickerRowPattern->GetPrefixHour() != hourOptions) ||
1596             (timePickerRowPattern->GetPrefixMinute() != minuteOptions)) {
1597             timePickerRowPattern->SetDateTimeOptionUpdate(true);
1598         }
1599         timePickerRowPattern->SetPrefixHour(hourOptions);
1600         timePickerRowPattern->SetPrefixMinute(minuteOptions);
1601         timePickerLayout->UpdatePrefixHour(static_cast<int32_t>(hourOptions));
1602         timePickerLayout->UpdatePrefixMinute(static_cast<int32_t>(minuteOptions));
1603     }
1604     auto onChangeCallback = [weak = WeakPtr<FrameNode>(monthDaysNode)]() {
1605         auto monthDaysNode = weak.Upgrade();
1606         CHECK_NULL_VOID(monthDaysNode);
1607         auto pickerPattern = monthDaysNode->GetPattern<DatePickerPattern>();
1608         CHECK_NULL_VOID(pickerPattern);
1609         auto str = pickerPattern->GetSelectedObject(true);
1610         auto datePickerEventHub = pickerPattern->GetEventHub<DatePickerEventHub>();
1611         CHECK_NULL_VOID(datePickerEventHub);
1612         datePickerEventHub->FireDialogChangeEvent(str);
1613     };
1614     timePickerEventHub->SetOnChangeForDatePicker(std::move(onChangeCallback));
1615     timeNode->MarkModifyDone();
1616     SetTimeNodeColumnWeight(timeNode, settingData);
1617     timeNode->MountToParent(pickerRow);
1618     if (NeedAdaptForAging()) {
1619         timePickerLayout->UpdateVisibility(VisibleType::GONE);
1620     }
1621     return timeNode;
1622 }
1623 
CreateAndSetDialogSwitchEvent(const RefPtr<FrameNode> & pickerStack,const RefPtr<FrameNode> & contentColumn,const DatePickerSettingData & settingData)1624 std::function<void()> DatePickerDialogView::CreateAndSetDialogSwitchEvent(const RefPtr<FrameNode>& pickerStack,
1625     const RefPtr<FrameNode>& contentColumn, const DatePickerSettingData& settingData)
1626 {
1627     RefPtr<DateTimeAnimationController> animationController = AceType::MakeRefPtr<DateTimeAnimationController>();
1628     auto titleSwitchEvent = [weakContentColumn = AceType::WeakClaim(AceType::RawPtr(contentColumn)),
1629                                 weakPickerStack = AceType::WeakClaim(AceType::RawPtr(pickerStack)),
1630                                 animationController,
1631                                 useMilitary = settingData.useMilitary]() {
1632         auto contentColumn = weakContentColumn.Upgrade();
1633         CHECK_NULL_VOID(contentColumn);
1634         auto pickerStack = weakPickerStack.Upgrade();
1635         CHECK_NULL_VOID(pickerStack);
1636         // switch picker page.
1637         SwitchPickerPage(pickerStack, contentColumn, animationController, useMilitary);
1638     };
1639     auto switchEvent = [func = titleSwitchEvent]() {
1640         if (switchFlag_) {
1641             func();
1642             return true;
1643         }
1644         return false;
1645     };
1646     SetDialogSwitchEvent(switchEvent, pickerStack);
1647     return titleSwitchEvent;
1648 }
1649 
SwitchPickerPage(const RefPtr<FrameNode> & pickerStack,const RefPtr<FrameNode> & contentColumn,const RefPtr<DateTimeAnimationController> & animationController,bool useMilitary)1650 void DatePickerDialogView::SwitchPickerPage(const RefPtr<FrameNode>& pickerStack,
1651     const RefPtr<FrameNode>& contentColumn, const RefPtr<DateTimeAnimationController>& animationController,
1652     bool useMilitary)
1653 {
1654     auto pickerRow = pickerStack->GetLastChild();
1655     CHECK_NULL_VOID(pickerRow);
1656     auto dateNode = AceType::DynamicCast<FrameNode>(pickerStack->GetChildAtIndex(0));
1657     CHECK_NULL_VOID(dateNode);
1658     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
1659     CHECK_NULL_VOID(datePickerPattern);
1660     auto monthDaysNode = AceType::DynamicCast<FrameNode>(pickerRow->GetChildAtIndex(0));
1661     auto timeNode = AceType::DynamicCast<FrameNode>(pickerRow->GetChildAtIndex(1));
1662     CHECK_NULL_VOID(monthDaysNode);
1663     CHECK_NULL_VOID(timeNode);
1664     auto timePickerPattern = timeNode->GetPattern<TimePickerRowPattern>();
1665     CHECK_NULL_VOID(timePickerPattern);
1666     auto monthDaysPickerPattern = monthDaysNode->GetPattern<DatePickerPattern>();
1667     CHECK_NULL_VOID(monthDaysPickerPattern);
1668     PickerDate selectedDate =
1669         switchFlag_ ? datePickerPattern->GetCurrentDate() : monthDaysPickerPattern->GetCurrentDate();
1670     SetSelectedDate(switchFlag_ ? monthDaysNode : dateNode, selectedDate);
1671     animationController->SetDatePickerButtonHide(false);
1672     auto contentRow = AceType::DynamicCast<FrameNode>(contentColumn->GetLastChild());
1673     if (switchFlag_) {
1674         if (NeedAdaptForAging()) {
1675             switchTimePickerFlag_ = true;
1676             SwitchTimePickerPage(monthDaysNode, timeNode, contentRow);
1677         }
1678         datePickerPattern->SetFocusDisable();
1679         timePickerPattern->SetFocusDisable();
1680         monthDaysPickerPattern->SetFocusEnable();
1681         monthDaysNode->MarkModifyDone();
1682     } else {
1683         monthDaysPickerPattern->SetFocusDisable();
1684         timePickerPattern->SetFocusDisable();
1685         datePickerPattern->SetFocusEnable();
1686         if (NeedAdaptForAging()) {
1687             SwitchDatePickerPage(dateNode, true);
1688             animationController->SetDatePickerButtonHide(true);
1689         }
1690         dateNode->MarkModifyDone();
1691     }
1692     SwitchContentRowButton(contentRow, useMilitary);
1693     SetAnimationProperty(pickerStack, contentColumn, animationController);
1694     switchFlag_ = !switchFlag_;
1695     animationController->Play(switchFlag_);
1696 }
1697 
SetAnimationProperty(const RefPtr<FrameNode> & pickerStack,const RefPtr<FrameNode> & contentColumn,const RefPtr<DateTimeAnimationController> & animationController)1698 void DatePickerDialogView::SetAnimationProperty(const RefPtr<FrameNode>& pickerStack,
1699     const RefPtr<FrameNode>& contentColumn, const RefPtr<DateTimeAnimationController>& animationController)
1700 {
1701     auto pickerRow = pickerStack->GetLastChild();
1702     CHECK_NULL_VOID(pickerRow);
1703     auto dateNode = AceType::DynamicCast<FrameNode>(pickerStack->GetChildAtIndex(0));
1704     CHECK_NULL_VOID(dateNode);
1705     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
1706     CHECK_NULL_VOID(datePickerPattern);
1707     auto monthDaysNode = AceType::DynamicCast<FrameNode>(pickerRow->GetChildAtIndex(0));
1708     auto timeNode = AceType::DynamicCast<FrameNode>(pickerRow->GetChildAtIndex(1));
1709     CHECK_NULL_VOID(monthDaysNode);
1710     CHECK_NULL_VOID(timeNode);
1711     auto titleRow = AceType::DynamicCast<FrameNode>(contentColumn->GetChildAtIndex(0));
1712     CHECK_NULL_VOID(titleRow);
1713     auto titleButtonNode = AceType::DynamicCast<FrameNode>(titleRow->GetFirstChild());
1714     CHECK_NULL_VOID(titleButtonNode);
1715     auto titleButtonRowNode = AceType::DynamicCast<FrameNode>(titleButtonNode->GetFirstChild());
1716     CHECK_NULL_VOID(titleButtonRowNode);
1717     auto spinnerNode = AceType::DynamicCast<FrameNode>(titleButtonRowNode->GetLastChild());
1718     CHECK_NULL_VOID(spinnerNode);
1719     auto contentRow = AceType::DynamicCast<FrameNode>(contentColumn->GetLastChild());
1720     CHECK_NULL_VOID(contentRow);
1721     animationController->SetButtonIcon(spinnerNode);
1722     animationController->SetMonthDays(monthDaysNode);
1723     animationController->SetDatePicker(dateNode);
1724     animationController->SetTimePicker(timeNode);
1725     animationController->SetButtonRow(contentRow);
1726 }
1727 
CreateAndAddTitleClickEvent(std::function<void ()> & titleSwitchEvent,const RefPtr<FrameNode> & buttonTitleNode)1728 void DatePickerDialogView::CreateAndAddTitleClickEvent(
1729     std::function<void()>& titleSwitchEvent, const RefPtr<FrameNode>& buttonTitleNode)
1730 {
1731     auto titleClickEvent = [func = std::move(titleSwitchEvent)](const GestureEvent& /* info */) { func(); };
1732     auto titleButtonNode = AceType::DynamicCast<FrameNode>(buttonTitleNode->GetFirstChild());
1733     CHECK_NULL_VOID(titleButtonNode);
1734     auto titleEventHub = titleButtonNode->GetOrCreateGestureEventHub();
1735     auto onClick = AceType::MakeRefPtr<NG::ClickEvent>(std::move(titleClickEvent));
1736     titleEventHub->AddClickEvent(onClick);
1737 }
1738 
BuildDialogAcceptAndCancelButton(const std::vector<ButtonInfo> & buttonInfos,const DatePickerSettingData & settingData,const RefPtr<FrameNode> & acceptNode,const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & dialogNode,const RefPtr<FrameNode> & contentColumn,std::map<std::string,NG::DialogEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)1739 void DatePickerDialogView::BuildDialogAcceptAndCancelButton(const std::vector<ButtonInfo>& buttonInfos,
1740     const DatePickerSettingData& settingData, const RefPtr<FrameNode>& acceptNode, const RefPtr<FrameNode>& dateNode,
1741     const RefPtr<FrameNode>& dialogNode, const RefPtr<FrameNode>& contentColumn,
1742     std::map<std::string, NG::DialogEvent> dialogEvent, std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
1743 {
1744     auto changeEvent = dialogEvent["changeId"];
1745     auto dateChangeEvent = dialogEvent["dateChangeId"];
1746     if (settingData.showTime) {
1747         auto changeEventSame = changeEvent;
1748         auto dateChangeEventSame = dateChangeEvent;
1749         SetDialogChange(acceptNode, std::move(changeEventSame));
1750         SetDialogDateChange(acceptNode, std::move(dateChangeEventSame));
1751     }
1752     SetDialogChange(dateNode, std::move(changeEvent));
1753     SetDialogDateChange(dateNode, std::move(dateChangeEvent));
1754     auto contentRow = CreateButtonNode(acceptNode, dateNode, buttonInfos, dialogEvent, std::move(dialogCancelEvent));
1755     CHECK_NULL_VOID(contentRow);
1756     auto closeDiaglogEvent = CloseDialogEvent(dateNode, dialogNode);
1757     auto event = [func = std::move(closeDiaglogEvent)](const GestureEvent& /* info */) {
1758         func();
1759     };
1760     for (const auto& child : contentRow->GetChildren()) {
1761         auto firstChild = AceType::DynamicCast<FrameNode>(child);
1762         auto gesturHub = firstChild->GetOrCreateGestureEventHub();
1763         auto onClick = AceType::MakeRefPtr<NG::ClickEvent>(event);
1764         gesturHub->AddClickEvent(onClick);
1765     }
1766     contentRow->AddChild(CreateDividerNode(dateNode), 1);
1767     contentRow->MountToParent(contentColumn);
1768 }
1769 
CloseDialogEvent(const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & dialogNode)1770 std::function<void()> DatePickerDialogView::CloseDialogEvent(const RefPtr<FrameNode>& dateNode,
1771     const RefPtr<FrameNode>& dialogNode)
1772 {
1773     auto datePickerPattern = dateNode->GetPattern<DatePickerPattern>();
1774     auto event = [weak = WeakPtr<FrameNode>(dialogNode),
1775         weakDatePickerPattern = WeakPtr<DatePickerPattern>(datePickerPattern)]() {
1776         auto dialogNode = weak.Upgrade();
1777         CHECK_NULL_VOID(dialogNode);
1778         auto dialogPattern = dialogNode->GetPattern<DialogPattern>();
1779         CHECK_NULL_VOID(dialogPattern);
1780         dialogPattern->SetIsPickerDialog(false);
1781         auto datePickerPattern = weakDatePickerPattern.Upgrade();
1782         CHECK_NULL_VOID(datePickerPattern);
1783 
1784         if (datePickerPattern->GetIsShowInDialog()) {
1785             auto pipeline = dialogNode->GetContext();
1786             CHECK_NULL_VOID(pipeline);
1787             auto overlayManager = pipeline->GetOverlayManager();
1788             CHECK_NULL_VOID(overlayManager);
1789             overlayManager->CloseDialog(dialogNode);
1790             datePickerPattern->SetIsShowInDialog(false);
1791         }
1792     };
1793     datePickerPattern->updateFontConfigurationEvent(event);
1794     return event;
1795 }
1796 
BuildDialogAcceptAndCancelButtonForAging(const std::vector<ButtonInfo> & buttonInfos,const DatePickerSettingData & settingData,const RefPtr<FrameNode> & timePickerNode,const RefPtr<FrameNode> & acceptNode,const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & dialogNode,const RefPtr<FrameNode> & contentColumn,std::map<std::string,NG::DialogEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)1797 void DatePickerDialogView::BuildDialogAcceptAndCancelButtonForAging(const std::vector<ButtonInfo>& buttonInfos,
1798     const DatePickerSettingData& settingData, const RefPtr<FrameNode>& timePickerNode,
1799     const RefPtr<FrameNode>& acceptNode, const RefPtr<FrameNode>& dateNode, const RefPtr<FrameNode>& dialogNode,
1800     const RefPtr<FrameNode>& contentColumn, std::map<std::string, NG::DialogEvent> dialogEvent,
1801     std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
1802 {
1803     auto changeEvent = dialogEvent["changeId"];
1804     auto dateChangeEvent = dialogEvent["dateChangeId"];
1805     if (settingData.showTime) {
1806         auto changeEventSame = changeEvent;
1807         auto dateChangeEventSame = dateChangeEvent;
1808         SetDialogChange(acceptNode, std::move(changeEventSame));
1809         SetDialogDateChange(acceptNode, std::move(dateChangeEventSame));
1810     }
1811     SetDialogChange(dateNode, std::move(changeEvent));
1812     SetDialogDateChange(dateNode, std::move(dateChangeEvent));
1813     auto contentRow = CreateButtonNodeForAging(settingData, timePickerNode, acceptNode,
1814         dateNode, buttonInfos, dialogEvent, std::move(dialogCancelEvent));
1815     if (!isShowTime_) {
1816         SwitchDatePickerPage(dateNode, true);
1817         ShowContentRowButton(contentRow, true);
1818     }
1819     CHECK_NULL_VOID(contentRow);
1820     auto event = [weak = WeakPtr<FrameNode>(dialogNode)](const GestureEvent& /* info */) {
1821         auto dialogNode = weak.Upgrade();
1822         CHECK_NULL_VOID(dialogNode);
1823         auto pipeline = dialogNode->GetContext();
1824         CHECK_NULL_VOID(pipeline);
1825         auto overlayManager = pipeline->GetOverlayManager();
1826         CHECK_NULL_VOID(overlayManager);
1827         overlayManager->CloseDialog(dialogNode);
1828     };
1829 
1830     auto onClick = AceType::MakeRefPtr<NG::ClickEvent>(event);
1831     auto cancelButtonNode = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(0));
1832     CHECK_NULL_VOID(cancelButtonNode);
1833     auto cancelButtonGestureHub = cancelButtonNode->GetOrCreateGestureEventHub();
1834     cancelButtonGestureHub->AddClickEvent(onClick);
1835     auto confirmButtonNode = AceType::DynamicCast<FrameNode>(contentRow->GetLastChild());
1836     CHECK_NULL_VOID(confirmButtonNode);
1837     auto confirmButtonGestureHub = confirmButtonNode->GetOrCreateGestureEventHub();
1838     confirmButtonGestureHub->AddClickEvent(onClick);
1839     contentRow->MountToParent(contentColumn);
1840 }
1841 
UpdateContentPadding(const RefPtr<FrameNode> & contentColumn)1842 void DatePickerDialogView::UpdateContentPadding(const RefPtr<FrameNode>& contentColumn)
1843 {
1844     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1845         PaddingProperty contentPadding;
1846         contentPadding.left = CalcLength(PICKER_DIALOG_MARGIN_FORM_EDGE);
1847         contentPadding.right = CalcLength(PICKER_DIALOG_MARGIN_FORM_EDGE);
1848         contentColumn->GetLayoutProperty()->UpdatePadding(contentPadding);
1849     }
1850 }
1851 
UpdateButtonDefaultFocus(const std::vector<ButtonInfo> & buttonInfos,const RefPtr<FrameNode> & buttonNode,bool isConfirm)1852 void DatePickerDialogView::UpdateButtonDefaultFocus(
1853     const std::vector<ButtonInfo>& buttonInfos, const RefPtr<FrameNode>& buttonNode, bool isConfirm)
1854 {
1855     bool setDefaultFocus = false;
1856     if (buttonInfos.size() > CANCEL_BUTTON_INDEX) {
1857         if (buttonInfos[ACCEPT_BUTTON_INDEX].isPrimary && buttonInfos[CANCEL_BUTTON_INDEX].isPrimary) {
1858             return;
1859         }
1860         auto index = isConfirm ? ACCEPT_BUTTON_INDEX : CANCEL_BUTTON_INDEX;
1861         if (buttonInfos[index].isPrimary) {
1862             setDefaultFocus = true;
1863         }
1864     } else if (buttonInfos.size() == CANCEL_BUTTON_INDEX) {
1865         bool isAcceptButtonPrimary = (buttonInfos[0].isAcceptButton && isConfirm && buttonInfos[0].isPrimary);
1866         bool isCancelButtonPrimary = (!buttonInfos[0].isAcceptButton && !isConfirm && buttonInfos[0].isPrimary);
1867         if (isAcceptButtonPrimary || isCancelButtonPrimary) {
1868             setDefaultFocus = true;
1869         }
1870     }
1871     if (setDefaultFocus && buttonNode) {
1872         auto focusHub = buttonNode->GetOrCreateFocusHub();
1873         if (focusHub) {
1874             focusHub->SetIsDefaultFocus(true);
1875         }
1876     }
1877 }
1878 
CreateNextPrevButtonNode(std::function<void ()> & switchEvent,const RefPtr<FrameNode> & dateNode,const std::vector<ButtonInfo> & buttonInfos,const RefPtr<FrameNode> & contentRow)1879 RefPtr<FrameNode> DatePickerDialogView::CreateNextPrevButtonNode(std::function<void()>& switchEvent,
1880     const RefPtr<FrameNode>& dateNode, const std::vector<ButtonInfo>& buttonInfos, const RefPtr<FrameNode>& contentRow)
1881 {
1882     auto pipeline = PipelineContext::GetCurrentContext();
1883     CHECK_NULL_RETURN(pipeline, nullptr);
1884     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
1885     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1886     auto nextPrevButtonNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
1887         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1888     CHECK_NULL_RETURN(nextPrevButtonNode, nullptr);
1889     auto textNextPrevNode = FrameNode::CreateFrameNode(
1890         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
1891     CHECK_NULL_RETURN(textNextPrevNode, nullptr);
1892     auto textLayoutProperty = textNextPrevNode->GetLayoutProperty<TextLayoutProperty>();
1893     CHECK_NULL_RETURN(textLayoutProperty, nullptr);
1894     textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.next"));
1895     textLayoutProperty->UpdateTextColor(pickerTheme->GetOptionStyle(true, false).GetTextColor());
1896     textLayoutProperty->UpdateFontSize(
1897         ConvertFontScaleValue(pickerTheme->GetOptionStyle(false, false).GetFontSize()));
1898     textLayoutProperty->UpdateFontWeight(pickerTheme->GetOptionStyle(true, false).GetFontWeight());
1899     textNextPrevNode->MountToParent(nextPrevButtonNode);
1900     auto nextPrevEventHub = nextPrevButtonNode->GetEventHub<ButtonEventHub>();
1901     CHECK_NULL_RETURN(nextPrevEventHub, nullptr);
1902     nextPrevEventHub->SetStateEffect(true);
1903     auto buttonNextPrevLayoutProperty = nextPrevButtonNode->GetLayoutProperty<ButtonLayoutProperty>();
1904     buttonNextPrevLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.next"));
1905     buttonNextPrevLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
1906     buttonNextPrevLayoutProperty->UpdateType(ButtonType::CAPSULE);
1907     buttonNextPrevLayoutProperty->UpdateFlexShrink(1.0);
1908     UpdateConfirmButtonMargin(buttonNextPrevLayoutProperty, dialogTheme);
1909     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
1910         buttonNextPrevLayoutProperty->UpdateUserDefinedIdealSize(
1911             CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
1912     } else {
1913         auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
1914         CHECK_NULL_RETURN(buttonTheme, nullptr);
1915         buttonNextPrevLayoutProperty->UpdateUserDefinedIdealSize(
1916             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
1917     }
1918     auto eventNextPrevmHub = nextPrevButtonNode->GetOrCreateGestureEventHub();
1919     CHECK_NULL_RETURN(eventNextPrevmHub, nullptr);
1920     auto onClickCallback = CreateNextPrevClickEvent(textNextPrevNode, nextPrevButtonNode, dialogTheme, dateNode,
1921         switchEvent, contentRow);
1922     eventNextPrevmHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(onClickCallback));
1923     auto buttonNextPrevRenderContext = nextPrevButtonNode->GetRenderContext();
1924     buttonNextPrevRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
1925     UpdateButtonStyles(buttonInfos, CANCEL_BUTTON_INDEX, buttonNextPrevLayoutProperty, buttonNextPrevRenderContext);
1926     UpdateButtonDefaultFocus(buttonInfos, nextPrevButtonNode, false);
1927     nextPrevButtonNode->MarkModifyDone();
1928     return nextPrevButtonNode;
1929 }
1930 
CreateNextPrevClickEvent(const RefPtr<FrameNode> & textNextPrevNode,const RefPtr<FrameNode> & nextPrevButtonNode,const RefPtr<DialogTheme> & dialogTheme,const RefPtr<FrameNode> & dateNode,std::function<void ()> & switchEvent,const RefPtr<FrameNode> & contentRow)1931 std::function<void(const GestureEvent&)> DatePickerDialogView::CreateNextPrevClickEvent(
1932     const RefPtr<FrameNode>& textNextPrevNode, const RefPtr<FrameNode>& nextPrevButtonNode,
1933     const RefPtr<DialogTheme>& dialogTheme, const RefPtr<FrameNode>& dateNode,
1934     std::function<void()>& switchEvent, const RefPtr<FrameNode>& contentRow)
1935 {
1936     auto onClickCallback = [textWeak = WeakPtr<FrameNode>(textNextPrevNode),
1937                             nextPrevButtonNodeWeak = WeakPtr<FrameNode>(nextPrevButtonNode),
1938                             dialogThemeWeak = WeakPtr<DialogTheme>(dialogTheme),
1939                                dateWeak = WeakPtr<FrameNode>(dateNode),
1940                                func = std::move(switchEvent),
1941                                contentWeak = WeakPtr<FrameNode>(contentRow)](const GestureEvent& /* info */) {
1942         auto dateNode = dateWeak.Upgrade();
1943         CHECK_NULL_VOID(dateNode);
1944         auto textNode = textWeak.Upgrade();
1945         CHECK_NULL_VOID(textNode);
1946         auto textLayoutProperty = textNode->GetLayoutProperty<TextLayoutProperty>();
1947         CHECK_NULL_VOID(textLayoutProperty);
1948         auto contentRow = contentWeak.Upgrade();
1949         CHECK_NULL_VOID(contentRow);
1950         auto nextPrevButtonNode = nextPrevButtonNodeWeak.Upgrade();
1951         CHECK_NULL_VOID(nextPrevButtonNode);
1952         auto dialogTheme = dialogThemeWeak.Upgrade();
1953         CHECK_NULL_VOID(dialogTheme);
1954         auto buttonNextPrevLayoutProperty
1955                                 = nextPrevButtonNode->GetLayoutProperty<ButtonLayoutProperty>();
1956         if (!switchFlag_ && isShowTime_) {
1957             func();
1958         } else {
1959             SwitchDatePickerPage(dateNode);
1960         }
1961         if (textLayoutProperty->GetContent() == Localization::GetInstance()->GetEntryLetters("common.next")) {
1962             if (!isShowTime_) {
1963                 ShowContentRowButton(contentRow, false);
1964             }
1965             UpdateCancelButtonMargin(buttonNextPrevLayoutProperty, dialogTheme);
1966             textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.prev"));
1967         } else {
1968             if (!isShowTime_) {
1969                 ShowContentRowButton(contentRow, true);
1970             }
1971             UpdateConfirmButtonMargin(buttonNextPrevLayoutProperty, dialogTheme);
1972             textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.next"));
1973         }
1974         if (switchFlag_ && isShowTime_) {
1975             UpdateNextButtonMargin(buttonNextPrevLayoutProperty);
1976         }
1977         textNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
1978     };
1979     return onClickCallback;
1980 }
1981 
GetIsUserSetTextProperties(const PickerTextProperties & properties)1982 bool DatePickerDialogView::GetIsUserSetTextProperties(const PickerTextProperties& properties)
1983 {
1984     if (properties.disappearTextStyle_.fontSize.has_value() && properties.disappearTextStyle_.fontSize->IsValid()) {
1985         isUserSetFont_ = true;
1986         return true;
1987     }
1988 
1989     if (properties.normalTextStyle_.fontSize.has_value() && properties.normalTextStyle_.fontSize->IsValid()) {
1990         isUserSetFont_ = true;
1991         return true;
1992     }
1993 
1994     if (properties.selectedTextStyle_.fontSize.has_value() && properties.selectedTextStyle_.fontSize->IsValid()) {
1995         isUserSetFont_ = true;
1996         return true;
1997     }
1998     isUserSetFont_ = false;
1999     return false;
2000 }
2001 
NeedAdaptForAging()2002 bool DatePickerDialogView::NeedAdaptForAging()
2003 {
2004     auto pipeline = PipelineContext::GetCurrentContext();
2005     CHECK_NULL_RETURN(pipeline, false);
2006     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
2007     CHECK_NULL_RETURN(pickerTheme, false);
2008     if (GreatOrEqual(pipeline->GetFontScale(), pickerTheme->GetMaxOneFontScale()) &&
2009         Dimension(pipeline->GetRootHeight()).ConvertToVp() > pickerTheme->GetDeviceHeightLimit()) {
2010         return true;
2011     }
2012     return false;
2013 }
2014 
AdjustFontSizeScale(const Dimension & fontSizeValue,double fontScale)2015 const Dimension DatePickerDialogView::AdjustFontSizeScale(const Dimension& fontSizeValue, double fontScale)
2016 {
2017     auto pipeline = PipelineContext::GetCurrentContextSafely();
2018     CHECK_NULL_RETURN(pipeline, fontSizeValue);
2019     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
2020     CHECK_NULL_RETURN(pickerTheme, fontSizeValue);
2021 
2022     auto adjustedScale = std::clamp(fontScale, pickerTheme->GetNormalFontScale(),
2023         pickerTheme->GetMaxTwoFontScale());
2024     return fontSizeValue * adjustedScale;
2025 }
2026 
ConvertFontScaleValue(const Dimension & fontSizeValue,const Dimension & fontSizeLimit,bool isUserSetFont)2027 const Dimension DatePickerDialogView::ConvertFontScaleValue(
2028     const Dimension& fontSizeValue, const Dimension& fontSizeLimit, bool isUserSetFont)
2029 {
2030     auto pipeline = PipelineContext::GetCurrentContextPtrSafelyWithCheck();
2031     CHECK_NULL_RETURN(pipeline, fontSizeValue);
2032     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
2033     CHECK_NULL_RETURN(pickerTheme, fontSizeValue);
2034     float fontSizeScale = pipeline->GetFontScale();
2035     Dimension fontSizeValueResult = fontSizeValue;
2036 
2037     if (NeedAdaptForAging()) {
2038         if (fontSizeValue.Unit() == DimensionUnit::VP) {
2039             if (isUserSetFont) {
2040                 fontSizeValueResult = ConvertFontSizeLimit(fontSizeValue, fontSizeLimit, isUserSetFont);
2041             }
2042             fontSizeValueResult = AdjustFontSizeScale(fontSizeValueResult, fontSizeScale);
2043         } else {
2044             if (GreatOrEqualCustomPrecision(fontSizeScale, pickerTheme->GetMaxThirdFontScale())) {
2045                 fontSizeScale = pickerTheme->GetMaxTwoFontScale() / pickerTheme->GetMaxThirdFontScale();
2046                 fontSizeValueResult = fontSizeValue * fontSizeScale;
2047             }
2048             if (isUserSetFont) {
2049                 fontSizeValueResult = ConvertFontSizeLimit(fontSizeValueResult, fontSizeLimit, isUserSetFont);
2050             }
2051         }
2052     } else {
2053         if (isUserSetFont) {
2054             fontSizeValueResult = ConvertFontSizeLimit(fontSizeValue, fontSizeLimit, isUserSetFont);
2055         }
2056 
2057         if (GreatOrEqualCustomPrecision(fontSizeScale, pickerTheme->GetMaxOneFontScale()) &&
2058             fontSizeValueResult.Unit() != DimensionUnit::VP) {
2059             if (!NearZero(fontSizeScale)) {
2060                 fontSizeValueResult = fontSizeValueResult / fontSizeScale;
2061             }
2062         }
2063     }
2064     return fontSizeValueResult;
2065 }
2066 
ConvertFontSizeLimit(const Dimension & fontSizeValue,const Dimension & fontSizeLimit,bool isUserSetFont)2067 const Dimension DatePickerDialogView::ConvertFontSizeLimit(
2068     const Dimension& fontSizeValue, const Dimension& fontSizeLimit, bool isUserSetFont)
2069 {
2070     if (isUserSetFont == false) {
2071         return fontSizeValue;
2072     }
2073     Dimension fontSizeValueResult = fontSizeValue;
2074     if (fontSizeValue.Unit() == DimensionUnit::VP) {
2075         if (GreatOrEqualCustomPrecision(fontSizeValue.ConvertToPx(), fontSizeLimit.ConvertToPx() / MARGIN_HALF)) {
2076             fontSizeValueResult = fontSizeLimit / MARGIN_HALF;
2077         } else {
2078             fontSizeValueResult = fontSizeValue;
2079         }
2080     } else {
2081         if (GreatOrEqualCustomPrecision(fontSizeValue.ConvertToPx(), fontSizeLimit.ConvertToPx())) {
2082             fontSizeValueResult = fontSizeLimit;
2083         } else {
2084             fontSizeValueResult = fontSizeValue;
2085         }
2086     }
2087 
2088     return fontSizeValueResult;
2089 }
2090 
ConvertTitleFontScaleValue(const Dimension & fontSizeValue)2091 const Dimension DatePickerDialogView::ConvertTitleFontScaleValue(const Dimension& fontSizeValue)
2092 {
2093     auto pipeline = PipelineContext::GetCurrentContextSafely();
2094     CHECK_NULL_RETURN(pipeline, fontSizeValue);
2095     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
2096     CHECK_NULL_RETURN(pickerTheme, fontSizeValue);
2097 
2098     double fontScale = pipeline->GetFontScale();
2099     auto adjustedScale =
2100         std::clamp(fontScale, pickerTheme->GetNormalFontScale(), pickerTheme->GetTitleFontScaleLimit());
2101 
2102     if (NeedAdaptForAging()) {
2103         if (fontSizeValue.Unit() == DimensionUnit::VP) {
2104             return (fontSizeValue * adjustedScale);
2105         } else {
2106             if (GreatOrEqualCustomPrecision(pipeline->GetFontScale(), pickerTheme->GetTitleFontScaleLimit())) {
2107                 auto fontSizeScale = pickerTheme->GetTitleFontScaleLimit() / pipeline->GetFontScale();
2108                 return (fontSizeValue * fontSizeScale);
2109             }
2110         }
2111     } else {
2112         if (GreatOrEqualCustomPrecision(fontScale, pickerTheme->GetMaxOneFontScale()) &&
2113             fontSizeValue.Unit() != DimensionUnit::VP) {
2114             return (fontSizeValue / pipeline->GetFontScale());
2115         }
2116     }
2117     return fontSizeValue;
2118 }
2119 
GetUserSettingLimit()2120 void DatePickerDialogView::GetUserSettingLimit()
2121 {
2122     auto pipeline = PipelineContext::GetCurrentContextSafely();
2123     CHECK_NULL_VOID(pipeline);
2124     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
2125     CHECK_NULL_VOID(pickerTheme);
2126     selectedTextStyleFont_ = pickerTheme->GetUseSetSelectedTextStyle();
2127     normalTextStyleFont_ = pickerTheme->GetUserSetNormalTextStyle();
2128     disappearTextStyleFont_ = pickerTheme->GetUserSetDisappearTextStyle();
2129 }
2130 
2131 } // namespace OHOS::Ace::NG
2132