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/time_picker/timepicker_dialog_view.h"
16 
17 #include "base/utils/utils.h"
18 #include "core/components_ng/base/view_stack_processor.h"
19 #include "core/components_ng/pattern/button/button_pattern.h"
20 #include "core/components_ng/pattern/dialog/dialog_view.h"
21 #include "core/components_ng/pattern/dialog/dialog_pattern.h"
22 #include "core/components_ng/pattern/divider/divider_pattern.h"
23 #include "core/components_ng/pattern/stack/stack_pattern.h"
24 #include "core/components_ng/pattern/text/text_pattern.h"
25 #include "core/components_ng/pattern/time_picker/timepicker_event_hub.h"
26 #include "core/components_ng/pattern/time_picker/timepicker_layout_property.h"
27 #include "core/components_ng/pattern/time_picker/timepicker_row_pattern.h"
28 #include "core/components_v2/inspector/inspector_constants.h"
29 #include "core/pipeline_ng/pipeline_context.h"
30 
31 namespace OHOS::Ace::NG {
32 namespace {
33 const int32_t DIVIDER_ROWS_THREE = 3;
34 const int32_t MARGIN_HALF = 2;
35 const int32_t BUFFER_NODE_NUMBER = 2;
36 constexpr Dimension PICKER_DIALOG_MARGIN_FORM_EDGE = 24.0_vp;
37 constexpr Dimension TITLE_BUTTON_HEIGHT = 32.0_vp;
38 constexpr size_t ACCEPT_BUTTON_INDEX = 0;
39 constexpr size_t CANCEL_BUTTON_INDEX = 1;
40 } // namespace
41 bool TimePickerDialogView::switchFlag_ = false;
42 Dimension TimePickerDialogView::selectedTextStyleFont_ = 40.0_vp;
43 Dimension TimePickerDialogView::normalTextStyleFont_ = 32.0_vp;
44 Dimension TimePickerDialogView::disappearTextStyleFont_ = 28.0_vp;
45 
Show(const DialogProperties & dialogProperties,const TimePickerSettingData & settingData,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,PickerTime> timePickerProperty,std::map<std::string,NG::DialogEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)46 RefPtr<FrameNode> TimePickerDialogView::Show(const DialogProperties& dialogProperties,
47     const TimePickerSettingData& settingData, const std::vector<ButtonInfo>& buttonInfos,
48     std::map<std::string, PickerTime> timePickerProperty, std::map<std::string, NG::DialogEvent> dialogEvent,
49     std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
50 {
51     auto isNeedAging = (NeedAdaptForAging() && (!settingData.isUseMilitaryTime));
52     GetUserSettingLimit();
53     auto contentColumn = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
54         AceType::MakeRefPtr<LinearLayoutPattern>(true));
55     auto timeNodeId = ElementRegister::GetInstance()->MakeUniqueId();
56     ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::TIME_PICKER_ETS_TAG, timeNodeId);
57     auto timePickerNode = FrameNode::GetOrCreateFrameNode(
58         V2::TIME_PICKER_ETS_TAG, timeNodeId, []() { return AceType::MakeRefPtr<TimePickerRowPattern>(); });
59     ViewStackProcessor::GetInstance()->Push(timePickerNode);
60     auto context = timePickerNode->GetContext();
61     CHECK_NULL_RETURN(context, nullptr);
62     auto themeManager = context->GetThemeManager();
63     CHECK_NULL_RETURN(themeManager, nullptr);
64     auto dialogTheme = themeManager->GetTheme<DialogTheme>();
65     CHECK_NULL_RETURN(dialogTheme, nullptr);
66     auto pickerTheme = themeManager->GetTheme<PickerTheme>();
67     CHECK_NULL_RETURN(pickerTheme, nullptr);
68 
69     uint32_t showCount = pickerTheme->GetShowOptionCount() + BUFFER_NODE_NUMBER;
70     auto timePickerRowPattern = timePickerNode->GetPattern<TimePickerRowPattern>();
71     CHECK_NULL_RETURN(timePickerRowPattern, nullptr);
72     timePickerRowPattern->SetIsShowInDialog(true);
73     timePickerRowPattern->SetShowCount(showCount);
74     timePickerRowPattern->SetBackgroundColor(dialogTheme->GetBackgroundColor());
75     timePickerRowPattern->SetTextProperties(settingData.properties);
76     auto timePickerLayout = timePickerNode->GetLayoutProperty<TimePickerLayoutProperty>();
77     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
78         ZeroPrefixType hourOptions = settingData.dateTimeOptions.hourType;
79         ZeroPrefixType minuteOptions = settingData.dateTimeOptions.minuteType;
80         if ((timePickerRowPattern->GetPrefixHour() != hourOptions) ||
81             (timePickerRowPattern->GetPrefixMinute() != minuteOptions)) {
82             timePickerRowPattern->SetDateTimeOptionUpdate(true);
83         }
84         timePickerRowPattern->SetPrefixHour(hourOptions);
85         timePickerRowPattern->SetPrefixMinute(minuteOptions);
86         timePickerLayout->UpdatePrefixHour(static_cast<int32_t>(hourOptions));
87         timePickerLayout->UpdatePrefixMinute(static_cast<int32_t>(minuteOptions));
88     }
89 
90     auto hasHourNode = timePickerRowPattern->HasHourNode();
91     auto hasMinuteNode = timePickerRowPattern->HasMinuteNode();
92 
93     auto hourId = timePickerRowPattern->GetHourId();
94     auto minuteId = timePickerRowPattern->GetMinuteId();
95 
96     auto hourColumnNode = FrameNode::GetOrCreateFrameNode(
97         V2::COLUMN_ETS_TAG, hourId, []() { return AceType::MakeRefPtr<TimePickerColumnPattern>(); });
98     CHECK_NULL_RETURN(hourColumnNode, nullptr);
99     if (!hasHourNode) {
100         for (uint32_t index = 0; index < showCount; index++) {
101             auto textNode = FrameNode::CreateFrameNode(
102                 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
103             CHECK_NULL_RETURN(textNode, nullptr);
104             textNode->MountToParent(hourColumnNode);
105         }
106         hourColumnNode->MarkModifyDone();
107         timePickerRowPattern->SetColumn(hourColumnNode);
108     }
109 
110     auto minuteColumnNode = FrameNode::GetOrCreateFrameNode(
111         V2::COLUMN_ETS_TAG, minuteId, []() { return AceType::MakeRefPtr<TimePickerColumnPattern>(); });
112     CHECK_NULL_RETURN(minuteColumnNode, nullptr);
113     if (!hasMinuteNode) {
114         for (uint32_t index = 0; index < showCount; index++) {
115             auto textNode = FrameNode::CreateFrameNode(
116                 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
117             CHECK_NULL_RETURN(textNode, nullptr);
118             textNode->MountToParent(minuteColumnNode);
119         }
120         minuteColumnNode->MarkModifyDone();
121         timePickerRowPattern->SetColumn(minuteColumnNode);
122     }
123     if (!hasHourNode) {
124         auto stackHourNode = CreateStackNode();
125         auto columnBlendNode = CreateColumnNode();
126         auto buttonYearNode = CreateButtonNode();
127         buttonYearNode->MountToParent(stackHourNode);
128         hourColumnNode->MountToParent(columnBlendNode);
129         columnBlendNode->MountToParent(stackHourNode);
130         auto layoutProperty = stackHourNode->GetLayoutProperty<LayoutProperty>();
131         layoutProperty->UpdateAlignment(Alignment::CENTER);
132         layoutProperty->UpdateLayoutWeight(1);
133         stackHourNode->MountToParent(timePickerNode);
134     }
135     if (!hasMinuteNode) {
136         auto stackMinuteNode = CreateStackNode();
137         auto columnBlendNode = CreateColumnNode();
138         auto buttonYearNode = CreateButtonNode();
139         buttonYearNode->MountToParent(stackMinuteNode);
140         minuteColumnNode->MountToParent(columnBlendNode);
141         columnBlendNode->MountToParent(stackMinuteNode);
142         auto layoutProperty = stackMinuteNode->GetLayoutProperty<LayoutProperty>();
143         layoutProperty->UpdateAlignment(Alignment::CENTER);
144         layoutProperty->UpdateLayoutWeight(1);
145         stackMinuteNode->MountToParent(timePickerNode);
146     }
147     timePickerRowPattern->SetHasSecond(settingData.showSecond);
148     auto it = timePickerProperty.find("selected");
149     if (it != timePickerProperty.end()) {
150         auto selectedTime = it->second;
151         SetSelectedTime(timePickerRowPattern, selectedTime);
152         SetDialogTitleDate(timePickerRowPattern, settingData.dialogTitleDate);
153     }
154     SetHour24(timePickerRowPattern, settingData.isUseMilitaryTime);
155     SetTextProperties(pickerTheme, settingData.properties);
156     auto changeEvent = dialogEvent["changeId"];
157     SetDialogChange(timePickerNode, std::move(changeEvent));
158     RefPtr<FrameNode> contentRow = nullptr;
159 
160     if (isNeedAging) {
161         contentRow = CreateButtonNodeForAging(
162             timePickerNode, timePickerNode, buttonInfos, dialogEvent, std::move(dialogCancelEvent));
163     } else {
164         contentRow = CreateButtonNode(
165             timePickerNode, timePickerNode, buttonInfos, dialogEvent, std::move(dialogCancelEvent));
166         contentRow->AddChild(CreateDividerNode(timePickerNode), 1);
167     }
168     CHECK_NULL_RETURN(contentRow, nullptr);
169     auto buttonTitleNode = CreateTitleButtonNode(timePickerNode);
170     CHECK_NULL_RETURN(buttonTitleNode, nullptr);
171     ViewStackProcessor::GetInstance()->Finish();
172 
173     auto timePickerLayoutProperty = timePickerNode->GetLayoutProperty();
174     CHECK_NULL_RETURN(timePickerLayoutProperty, nullptr);
175 
176     MarginProperty margin;
177     margin.left = CalcLength(PICKER_DIALOG_MARGIN_FORM_EDGE);
178     margin.right = CalcLength(PICKER_DIALOG_MARGIN_FORM_EDGE);
179     timePickerLayoutProperty->UpdateMargin(margin);
180 
181     buttonTitleNode->MountToParent(contentColumn);
182     timePickerNode->MountToParent(contentColumn);
183 
184     contentRow->SetNeedCallChildrenUpdate(false);
185     auto timePickerPattern = timePickerNode->GetPattern<TimePickerRowPattern>();
186     timePickerPattern->SetContentRowNode(contentRow);
187     timePickerPattern->SetbuttonTitleNode(buttonTitleNode);
188     auto buttonTitlePattern = buttonTitleNode->GetPattern<ButtonPattern>();
189     CHECK_NULL_RETURN(buttonTitlePattern, nullptr);
190     buttonTitlePattern->SetSkipColorConfigurationUpdate();
191 
192     if (isNeedAging) {
193         for (uint32_t i = 1; i < timePickerNode->GetChildren().size(); i++) {
194             auto childStackNode = AceType::DynamicCast<FrameNode>(timePickerNode->GetChildAtIndex(i));
195             CHECK_NULL_RETURN(childStackNode, nullptr);
196             for (uint32_t j = 0; j < childStackNode->GetChildren().size(); j++) {
197                 auto childNode = AceType::DynamicCast<FrameNode>(childStackNode->GetChildAtIndex(j));
198                 CHECK_NULL_RETURN(childNode, nullptr);
199                 auto childLayoutProperty = childNode->GetLayoutProperty<LayoutProperty>();
200                 CHECK_NULL_RETURN(childLayoutProperty, nullptr);
201                 childLayoutProperty->UpdateVisibility(VisibleType::GONE);
202                 childNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF_AND_PARENT);
203             }
204             auto layoutProperty = childStackNode->GetLayoutProperty<LayoutProperty>();
205             layoutProperty->UpdateAlignment(Alignment::CENTER);
206             layoutProperty->UpdateLayoutWeight(0);
207         }
208     }
209     auto dialogNode = DialogView::CreateDialogNode(dialogProperties, contentColumn);
210     CHECK_NULL_RETURN(dialogNode, nullptr);
211     auto dialogPattern = dialogNode->GetPattern<DialogPattern>();
212     CHECK_NULL_RETURN(dialogPattern, nullptr);
213     dialogPattern->SetIsPickerDialog(true);
214     auto closeDialogEvent = CloseDialogEvent(timePickerPattern, dialogNode);
215     auto event = [func = std::move(closeDialogEvent)](const GestureEvent& /* info */) {
216         func();
217     };
218 
219     auto onClick = AceType::MakeRefPtr<NG::ClickEvent>(event);
220     auto cancelButtonNode = AceType::DynamicCast<FrameNode>(contentRow->GetChildAtIndex(0));
221     CHECK_NULL_RETURN(cancelButtonNode, nullptr);
222     auto cancelButtonGesturHub = cancelButtonNode->GetOrCreateGestureEventHub();
223     cancelButtonGesturHub->AddClickEvent(onClick);
224     auto confirmButtonNode = AceType::DynamicCast<FrameNode>(contentRow->GetLastChild());
225     CHECK_NULL_RETURN(confirmButtonNode, nullptr);
226     auto confirmButtonGesturHub = confirmButtonNode->GetOrCreateGestureEventHub();
227     confirmButtonGesturHub->AddClickEvent(onClick);
228     contentRow->MountToParent(contentColumn);
229     dialogNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
230     return dialogNode;
231 }
232 
CloseDialogEvent(const RefPtr<TimePickerRowPattern> & timePickerPattern,const RefPtr<FrameNode> & dialogNode)233 std::function<void()> TimePickerDialogView::CloseDialogEvent(const RefPtr<TimePickerRowPattern>& timePickerPattern,
234     const RefPtr<FrameNode>& dialogNode)
235 {
236     auto event = [weak = WeakPtr<FrameNode>(dialogNode),
237         weakPattern = WeakPtr<TimePickerRowPattern>(timePickerPattern)]() {
238         auto dialogNode = weak.Upgrade();
239         CHECK_NULL_VOID(dialogNode);
240         auto dialogPattern = dialogNode->GetPattern<DialogPattern>();
241         CHECK_NULL_VOID(dialogPattern);
242         dialogPattern->SetIsPickerDialog(false);
243         auto timePickerPattern = weakPattern.Upgrade();
244         CHECK_NULL_VOID(timePickerPattern);
245         if (timePickerPattern->GetIsShowInDialog()) {
246             auto pipeline = dialogNode->GetContext();
247             CHECK_NULL_VOID(pipeline);
248             auto overlayManager = pipeline->GetOverlayManager();
249             CHECK_NULL_VOID(overlayManager);
250             overlayManager->CloseDialog(dialogNode);
251             timePickerPattern->SetIsShowInDialog(false);
252         }
253     };
254     timePickerPattern->updateFontConfigurationEvent(event);
255     return event;
256 }
257 
CreateNextPrevButtonNode(std::function<void ()> & timePickerSwitchEvent,const RefPtr<FrameNode> & timeNode,const std::vector<ButtonInfo> & buttonInfos)258 RefPtr<FrameNode> TimePickerDialogView::CreateNextPrevButtonNode(std::function<void()>& timePickerSwitchEvent,
259     const RefPtr<FrameNode>& timeNode, const std::vector<ButtonInfo>& buttonInfos)
260 {
261     auto pipeline = PipelineContext::GetCurrentContext();
262     CHECK_NULL_RETURN(pipeline, nullptr);
263     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
264     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
265     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
266     auto nextPrevButtonNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
267         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
268     CHECK_NULL_RETURN(nextPrevButtonNode, nullptr);
269     auto textNextPrevNode = FrameNode::CreateFrameNode(
270         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
271     CHECK_NULL_RETURN(textNextPrevNode, nullptr);
272     auto textNextPrevLayoutProperty = textNextPrevNode->GetLayoutProperty<TextLayoutProperty>();
273     CHECK_NULL_RETURN(textNextPrevLayoutProperty, nullptr);
274     textNextPrevLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.next"));
275     textNextPrevLayoutProperty->UpdateTextColor(pickerTheme->GetOptionStyle(true, false).GetTextColor());
276     textNextPrevLayoutProperty->UpdateFontSize(
277         ConvertFontScaleValue(pickerTheme->GetOptionStyle(false, false).GetFontSize()));
278     textNextPrevLayoutProperty->UpdateFontWeight(pickerTheme->GetOptionStyle(true, false).GetFontWeight());
279     textNextPrevNode->MountToParent(nextPrevButtonNode);
280     auto eventNextPrevHub = nextPrevButtonNode->GetOrCreateGestureEventHub();
281     CHECK_NULL_RETURN(eventNextPrevHub, nullptr);
282     auto event = UpdateTimePickerSwitchEvent(timeNode, textNextPrevNode, dialogTheme, nextPrevButtonNode,
283         timePickerSwitchEvent);
284     eventNextPrevHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(std::move(event)));
285     auto buttonNextPrevEventHub = nextPrevButtonNode->GetEventHub<ButtonEventHub>();
286     CHECK_NULL_RETURN(buttonNextPrevEventHub, nullptr);
287     buttonNextPrevEventHub->SetStateEffect(true);
288     auto buttonNextPrevLayoutProperty = nextPrevButtonNode->GetLayoutProperty<ButtonLayoutProperty>();
289     buttonNextPrevLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.next"));
290     buttonNextPrevLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
291     buttonNextPrevLayoutProperty->UpdateType(ButtonType::CAPSULE);
292     buttonNextPrevLayoutProperty->UpdateFlexShrink(1.0);
293     UpdateConfirmButtonMargin(buttonNextPrevLayoutProperty, dialogTheme);
294     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
295             buttonNextPrevLayoutProperty->UpdateUserDefinedIdealSize(
296                 CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
297     } else {
298         buttonNextPrevLayoutProperty->UpdateUserDefinedIdealSize(
299             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
300     }
301     auto buttonNextPrevRenderContext = nextPrevButtonNode->GetRenderContext();
302     buttonNextPrevRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
303     UpdateButtonStyles(buttonInfos, CANCEL_BUTTON_INDEX, buttonNextPrevLayoutProperty, buttonNextPrevRenderContext);
304     UpdateButtonDefaultFocus(buttonInfos, nextPrevButtonNode, false);
305     nextPrevButtonNode->MarkModifyDone();
306     return nextPrevButtonNode;
307 }
308 
UpdateTimePickerSwitchEvent(const RefPtr<FrameNode> & timeNode,const RefPtr<FrameNode> & textNode,const RefPtr<DialogTheme> & dialogTheme,const RefPtr<FrameNode> & buttonNode,const std::function<void ()> & timePickerSwitchEvent)309 std::function<void(const GestureEvent&)> TimePickerDialogView::UpdateTimePickerSwitchEvent(
310     const RefPtr<FrameNode>& timeNode, const RefPtr<FrameNode>& textNode, const RefPtr<DialogTheme>& dialogTheme,
311     const RefPtr<FrameNode>& buttonNode, const std::function<void()>& timePickerSwitchEvent)
312 {
313     auto nextPrevEvent = [weak = WeakPtr<FrameNode>(timeNode), textWeak = WeakPtr<FrameNode>(textNode),
314                         nextPrevButtonNodeWeak = WeakPtr<FrameNode>(buttonNode),
315                         dialogThemeWeak = WeakPtr<DialogTheme>(dialogTheme),
316                         func = std::move(timePickerSwitchEvent)](const GestureEvent&) {
317         auto timeNode = weak.Upgrade();
318         CHECK_NULL_VOID(timeNode);
319         auto textNode = textWeak.Upgrade();
320         CHECK_NULL_VOID(textNode);
321         auto textLayoutProperty = textNode->GetLayoutProperty<TextLayoutProperty>();
322         CHECK_NULL_VOID(textLayoutProperty);
323         auto pickerPattern = timeNode->GetPattern<TimePickerRowPattern>();
324         CHECK_NULL_VOID(pickerPattern);
325         auto timePickerEventHub = pickerPattern->GetEventHub<TimePickerEventHub>();
326         CHECK_NULL_VOID(timePickerEventHub);
327         auto nextPrevButtonNode = nextPrevButtonNodeWeak.Upgrade();
328         CHECK_NULL_VOID(nextPrevButtonNode);
329         auto dialogTheme = dialogThemeWeak.Upgrade();
330         CHECK_NULL_VOID(dialogTheme);
331         auto buttonNextPrevLayoutProperty
332                                 = nextPrevButtonNode->GetLayoutProperty<ButtonLayoutProperty>();
333         CHECK_NULL_VOID(buttonNextPrevLayoutProperty);
334         timePickerEventHub->FireDialogAcceptEvent(pickerPattern->GetSelectedObject(true));
335         func();
336         if (textLayoutProperty->GetContent() == Localization::GetInstance()->GetEntryLetters("common.next")) {
337             UpdateCancelButtonMargin(buttonNextPrevLayoutProperty, dialogTheme);
338             textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.prev"));
339         } else {
340             UpdateConfirmButtonMargin(buttonNextPrevLayoutProperty, dialogTheme);
341             textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.next"));
342         }
343         timeNode->MarkModifyDone();
344         textNode->MarkDirtyNode(PROPERTY_UPDATE_LAYOUT);
345     };
346     return nextPrevEvent;
347 }
348 
CreateStackNode()349 RefPtr<FrameNode> TimePickerDialogView::CreateStackNode()
350 {
351     auto stackId = ElementRegister::GetInstance()->MakeUniqueId();
352     return FrameNode::GetOrCreateFrameNode(
353         V2::STACK_ETS_TAG, stackId, []() { return AceType::MakeRefPtr<StackPattern>(); });
354 }
355 
CreateColumnNode()356 RefPtr<FrameNode> TimePickerDialogView::CreateColumnNode()
357 {
358     auto columnId = ElementRegister::GetInstance()->MakeUniqueId();
359     return FrameNode::GetOrCreateFrameNode(
360         V2::COLUMN_ETS_TAG, columnId, []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
361 }
362 
CreateButtonNode()363 RefPtr<FrameNode> TimePickerDialogView::CreateButtonNode()
364 {
365     auto buttonId = ElementRegister::GetInstance()->MakeUniqueId();
366     return FrameNode::GetOrCreateFrameNode(
367         V2::BUTTON_ETS_TAG, buttonId, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
368 }
369 
CreateDividerNode(const RefPtr<FrameNode> & dateNode,bool isCreateDivider)370 RefPtr<FrameNode> TimePickerDialogView::CreateDividerNode(const RefPtr<FrameNode>& dateNode, bool isCreateDivider)
371 {
372     auto pipeline = PipelineContext::GetCurrentContext();
373     CHECK_NULL_RETURN(pipeline, nullptr);
374     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
375     auto pickerPattern = dateNode->GetPattern<TimePickerRowPattern>();
376     CHECK_NULL_RETURN(pickerPattern, nullptr);
377     int32_t dividerNodeId = 0;
378     if (isCreateDivider) {
379         dividerNodeId = ElementRegister::GetInstance()->MakeUniqueId();
380     } else {
381         dividerNodeId = pickerPattern->GetDividerId();
382     }
383     auto dividerNode = FrameNode::GetOrCreateFrameNode(
384         V2::DIVIDER_ETS_TAG, dividerNodeId, []() { return AceType::MakeRefPtr<DividerPattern>(); });
385     CHECK_NULL_RETURN(dividerNode, nullptr);
386 
387     auto dividerPaintProps = dividerNode->GetPaintProperty<DividerRenderProperty>();
388     CHECK_NULL_RETURN(dividerPaintProps, nullptr);
389     dividerPaintProps->UpdateDividerColor(dialogTheme->GetDividerColor());
390 
391     auto dividerLayoutProps = dividerNode->GetLayoutProperty<DividerLayoutProperty>();
392     CHECK_NULL_RETURN(dividerLayoutProps, nullptr);
393     dividerLayoutProps->UpdateVertical(true);
394 
395     dividerLayoutProps->UpdateUserDefinedIdealSize(
396         CalcSize(CalcLength(dialogTheme->GetDividerWidth()), CalcLength(dialogTheme->GetDividerHeight())));
397     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
398         MarginProperty margin;
399         margin.top = CalcLength(dialogTheme->GetDividerHeight());
400         margin.bottom = CalcLength(dialogTheme->GetDividerPadding().Bottom());
401         dividerLayoutProps->UpdateMargin(margin);
402         dividerLayoutProps->UpdateUserDefinedIdealSize(
403             CalcSize(CalcLength(dialogTheme->GetDividerWidth()), CalcLength(dialogTheme->GetDividerHeight())));
404     } else {
405         auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
406         auto dividerWrapper = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG,
407             ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<LinearLayoutPattern>(false));
408         CHECK_NULL_RETURN(dividerWrapper, nullptr);
409         auto layoutProps = dividerWrapper->GetLayoutProperty<LinearLayoutProperty>();
410         CHECK_NULL_RETURN(layoutProps, nullptr);
411         layoutProps->UpdateMainAxisAlign(FlexAlign::SPACE_AROUND);
412         layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
413         layoutProps->UpdateUserDefinedIdealSize(
414             CalcSize(CalcLength(dialogTheme->GetActionsPadding().Bottom()), CalcLength(buttonTheme->GetHeight())));
415         dividerNode->MountToParent(dividerWrapper);
416         return dividerWrapper;
417     }
418 
419     return dividerNode;
420 }
421 
CreateTitleButtonNode(const RefPtr<FrameNode> & dateNode)422 RefPtr<FrameNode> TimePickerDialogView::CreateTitleButtonNode(const RefPtr<FrameNode>& dateNode)
423 {
424     auto pipeline = PipelineContext::GetCurrentContext();
425     CHECK_NULL_RETURN(pipeline, nullptr);
426     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
427     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
428     auto pickerPattern = dateNode->GetPattern<TimePickerRowPattern>();
429     CHECK_NULL_RETURN(pickerPattern, nullptr);
430     auto buttonTitleNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
431         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
432     auto textTitleNodeId = pickerPattern->GetTitleId();
433     auto textTitleNode =
434         FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, textTitleNodeId, AceType::MakeRefPtr<TextPattern>());
435     CHECK_NULL_RETURN(textTitleNode, nullptr);
436     auto textLayoutProperty = textTitleNode->GetLayoutProperty<TextLayoutProperty>();
437     CHECK_NULL_RETURN(textLayoutProperty, nullptr);
438     textLayoutProperty->UpdateContent("");
439     textLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
440     auto titleNodeRenderContext = textTitleNode->GetRenderContext();
441     titleNodeRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
442     textLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
443 
444     textLayoutProperty->UpdateTextColor(pickerTheme->GetTitleStyle().GetTextColor());
445     textLayoutProperty->UpdateFontSize(
446         ConvertTitleFontScaleValue(pickerTheme->GetTitleStyle().GetFontSize()));
447     textLayoutProperty->UpdateFontWeight(pickerTheme->GetTitleStyle().GetFontWeight());
448     textLayoutProperty->UpdateTextOverflow(pickerTheme->GetTitleStyle().GetTextOverflow());
449     textLayoutProperty->UpdateMaxLines(pickerTheme->GetTitleStyle().GetMaxLines());
450     auto buttonTitleRenderContext = buttonTitleNode->GetRenderContext();
451     CHECK_NULL_RETURN(buttonTitleRenderContext, nullptr);
452     buttonTitleRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
453     MarginProperty margin;
454     margin.left = CalcLength(dialogTheme->GetDividerPadding().Left());
455     margin.right = CalcLength(dialogTheme->GetDividerPadding().Right());
456     margin.top = CalcLength(dialogTheme->GetDividerHeight() / MARGIN_HALF);
457     margin.bottom = CalcLength(dialogTheme->GetDividerHeight() / MARGIN_HALF);
458     buttonTitleNode->GetLayoutProperty()->UpdateMargin(margin);
459     if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
460         buttonTitleNode->GetLayoutProperty()->UpdateUserDefinedIdealSize(
461             CalcSize(std::nullopt, CalcLength(TITLE_BUTTON_HEIGHT)));
462     }
463     textTitleNode->MountToParent(buttonTitleNode);
464     return buttonTitleNode;
465 }
466 
CreateButtonNode(const RefPtr<FrameNode> & frameNode,const RefPtr<FrameNode> & timePickerNode,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)467 RefPtr<FrameNode> TimePickerDialogView::CreateButtonNode(const RefPtr<FrameNode>& frameNode,
468     const RefPtr<FrameNode>& timePickerNode, const std::vector<ButtonInfo>& buttonInfos,
469     std::map<std::string, NG::DialogEvent> dialogEvent, std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
470 {
471     auto acceptEvent = dialogEvent["acceptId"];
472     auto cancelEvent = dialogCancelEvent["cancelId"];
473     auto contentRow = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
474         AceType::MakeRefPtr<LinearLayoutPattern>(false));
475 
476     CHECK_NULL_RETURN(contentRow, nullptr);
477     auto layoutProps = contentRow->GetLayoutProperty<LinearLayoutProperty>();
478     CHECK_NULL_RETURN(layoutProps, nullptr);
479     layoutProps->UpdateMainAxisAlign(FlexAlign::SPACE_AROUND);
480     layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
481     auto buttonCancelNode = CreateCancelNode(cancelEvent, timePickerNode, buttonInfos);
482     auto buttonConfirmNode = CreateConfirmNode(frameNode, timePickerNode, buttonInfos, acceptEvent);
483     buttonCancelNode->MountToParent(contentRow);
484     buttonConfirmNode->MountToParent(contentRow);
485     return contentRow;
486 }
487 
CreateButtonNodeForAging(const RefPtr<FrameNode> & frameNode,const RefPtr<FrameNode> & timePickerNode,const std::vector<ButtonInfo> & buttonInfos,std::map<std::string,NG::DialogEvent> dialogEvent,std::map<std::string,NG::DialogGestureEvent> dialogCancelEvent)488 RefPtr<FrameNode> TimePickerDialogView::CreateButtonNodeForAging(const RefPtr<FrameNode>& frameNode,
489     const RefPtr<FrameNode>& timePickerNode, const std::vector<ButtonInfo>& buttonInfos,
490     std::map<std::string, NG::DialogEvent> dialogEvent, std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent)
491 {
492     auto acceptEvent = dialogEvent["acceptId"];
493     auto cancelEvent = dialogCancelEvent["cancelId"];
494     auto contentRow = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
495         AceType::MakeRefPtr<LinearLayoutPattern>(false));
496 
497     CHECK_NULL_RETURN(contentRow, nullptr);
498     auto layoutProps = contentRow->GetLayoutProperty<LinearLayoutProperty>();
499     CHECK_NULL_RETURN(layoutProps, nullptr);
500     layoutProps->UpdateMainAxisAlign(FlexAlign::SPACE_AROUND);
501     layoutProps->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
502 
503     auto buttonCancelNode = CreateCancelNode(cancelEvent, timePickerNode, buttonInfos);
504     CHECK_NULL_RETURN(buttonCancelNode, nullptr);
505 
506     auto buttonConfirmNode = CreateConfirmNode(frameNode, timePickerNode, buttonInfos, acceptEvent);
507     CHECK_NULL_RETURN(buttonConfirmNode, nullptr);
508 
509     auto cancelNextDividerNode = CreateDividerNode(timePickerNode, true);
510     CHECK_NULL_RETURN(cancelNextDividerNode, nullptr);
511     auto nextConfirmDividerNode = CreateDividerNode(timePickerNode, true);
512     CHECK_NULL_RETURN(nextConfirmDividerNode, nullptr);
513 
514     auto timePickerSwitchEvent = CreateAndSetTimePickerSwitchEvent(timePickerNode, buttonCancelNode, buttonConfirmNode,
515         cancelNextDividerNode, nextConfirmDividerNode);
516     auto buttonNextPreNode = CreateNextPrevButtonNode(timePickerSwitchEvent, timePickerNode, buttonInfos);
517     CHECK_NULL_RETURN(buttonNextPreNode, nullptr);
518     buttonCancelNode->MountToParent(contentRow);
519     buttonNextPreNode->MountToParent(contentRow);
520     buttonConfirmNode->MountToParent(contentRow);
521     contentRow->AddChild(cancelNextDividerNode, 1);
522     contentRow->AddChild(nextConfirmDividerNode, DIVIDER_ROWS_THREE);
523 
524     switchFlag_ = false;
525     auto layoutProperty = buttonConfirmNode->GetLayoutProperty<LayoutProperty>();
526     layoutProperty->UpdateVisibility(VisibleType::GONE);
527     auto nextConfirmDividerProperty = nextConfirmDividerNode->GetLayoutProperty<LayoutProperty>();
528     nextConfirmDividerProperty->UpdateVisibility(VisibleType::GONE);
529     return contentRow;
530 }
531 
CreateAndSetTimePickerSwitchEvent(const RefPtr<FrameNode> & timePickerNode,const RefPtr<FrameNode> & buttonCancelNode,const RefPtr<FrameNode> & buttonConfirmNode,const RefPtr<FrameNode> & cancelNextDividerNode,const RefPtr<FrameNode> & nextConfirmDividerNode)532 std::function<void()> TimePickerDialogView::CreateAndSetTimePickerSwitchEvent(const RefPtr<FrameNode>& timePickerNode,
533     const RefPtr<FrameNode>& buttonCancelNode, const RefPtr<FrameNode>& buttonConfirmNode,
534     const RefPtr<FrameNode>& cancelNextDividerNode, const RefPtr<FrameNode>& nextConfirmDividerNode)
535 {
536     auto timePickerSwitchEvent = [weakTimePickerNode = AceType::WeakClaim(AceType::RawPtr(timePickerNode)),
537                                      weakbuttonCancelNode = AceType::WeakClaim(AceType::RawPtr(buttonCancelNode)),
538                                      weakcancelNextDividerNode =
539                                          AceType::WeakClaim(AceType::RawPtr(cancelNextDividerNode)),
540                                      weaknextConfirmDividerNode =
541                                          AceType::WeakClaim(AceType::RawPtr(nextConfirmDividerNode)),
542                                      weakbuttonConfirmNode = AceType::WeakClaim(AceType::RawPtr(buttonConfirmNode))]() {
543         auto timePickerNode = weakTimePickerNode.Upgrade();
544         CHECK_NULL_VOID(timePickerNode);
545         auto buttonCancelNode = weakbuttonCancelNode.Upgrade();
546         CHECK_NULL_VOID(buttonCancelNode);
547         auto buttonConfirmNode = weakbuttonConfirmNode.Upgrade();
548         CHECK_NULL_VOID(buttonConfirmNode);
549         auto cancelNextDividerNode = weakcancelNextDividerNode.Upgrade();
550         CHECK_NULL_VOID(cancelNextDividerNode);
551         auto nextConfirmDividerNode = weaknextConfirmDividerNode.Upgrade();
552         CHECK_NULL_VOID(nextConfirmDividerNode);
553         SwitchTimePickerPage(timePickerNode, buttonCancelNode, buttonConfirmNode,
554             cancelNextDividerNode, nextConfirmDividerNode);
555     };
556 
557     return timePickerSwitchEvent;
558 }
SwitchTimePickerPage(const RefPtr<FrameNode> & timePickerNode,const RefPtr<FrameNode> & buttonCancelNode,const RefPtr<FrameNode> & buttonConfirmNode,const RefPtr<FrameNode> & cancelNextDividerNode,const RefPtr<FrameNode> & nextConfirmDividerNode)559 void TimePickerDialogView::SwitchTimePickerPage(const RefPtr<FrameNode> &timePickerNode,
560                                                 const RefPtr<FrameNode> &buttonCancelNode,
561                                                 const RefPtr<FrameNode> &buttonConfirmNode,
562                                                 const RefPtr<FrameNode>& cancelNextDividerNode,
563                                                 const RefPtr<FrameNode>& nextConfirmDividerNode)
564 {
565     for (uint32_t i = 0; i < timePickerNode->GetChildren().size(); i++) {
566         auto childStackNode = AceType::DynamicCast<FrameNode>(timePickerNode->GetChildAtIndex(i));
567         CHECK_NULL_VOID(childStackNode);
568         auto layoutProperty = childStackNode->GetLayoutProperty<LayoutProperty>();
569         layoutProperty->UpdateAlignment(Alignment::CENTER);
570         for (uint32_t j = 0; j < childStackNode->GetChildren().size(); j++) {
571             auto childNode = AceType::DynamicCast<FrameNode>(childStackNode->GetChildAtIndex(j));
572             CHECK_NULL_VOID(childNode);
573             auto childLayoutProperty = childNode->GetLayoutProperty<LayoutProperty>();
574             CHECK_NULL_VOID(childLayoutProperty);
575             if (i == 0) {
576                 childLayoutProperty->UpdateVisibility(switchFlag_ ? VisibleType::VISIBLE : VisibleType::GONE);
577                 layoutProperty->UpdateLayoutWeight(switchFlag_ ? 1 : 0);
578             } else {
579                 childLayoutProperty->UpdateVisibility(switchFlag_ ? VisibleType::GONE : VisibleType::VISIBLE);
580                 layoutProperty->UpdateLayoutWeight(switchFlag_ ? 0 : 1);
581             }
582             childNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF_AND_PARENT);
583         }
584     }
585 
586     auto cancelButtonLayoutProperty = buttonCancelNode->GetLayoutProperty<LayoutProperty>();
587     CHECK_NULL_VOID(cancelButtonLayoutProperty);
588     cancelButtonLayoutProperty->UpdateVisibility(switchFlag_ ? VisibleType::VISIBLE : VisibleType::GONE);
589     buttonCancelNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
590 
591     auto cancelNextLayoutProperty = cancelNextDividerNode->GetLayoutProperty<LayoutProperty>();
592     CHECK_NULL_VOID(cancelNextLayoutProperty);
593     cancelNextLayoutProperty->UpdateVisibility(switchFlag_ ? VisibleType::VISIBLE : VisibleType::GONE);
594     cancelNextDividerNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
595 
596     auto confirmButtonLayoutProperty = buttonConfirmNode->GetLayoutProperty<LayoutProperty>();
597     CHECK_NULL_VOID(confirmButtonLayoutProperty);
598     confirmButtonLayoutProperty->UpdateVisibility(switchFlag_ ? VisibleType::GONE : VisibleType::VISIBLE);
599     buttonConfirmNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
600 
601     auto nextConfirmLayoutProperty = nextConfirmDividerNode->GetLayoutProperty<LayoutProperty>();
602     CHECK_NULL_VOID(nextConfirmLayoutProperty);
603     nextConfirmLayoutProperty->UpdateVisibility(switchFlag_ ? VisibleType::GONE : VisibleType::VISIBLE);
604     nextConfirmDividerNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
605 
606     switchFlag_ = !switchFlag_;
607 }
CreateConfirmNode(const RefPtr<FrameNode> & dateNode,const RefPtr<FrameNode> & timePickerNode,const std::vector<ButtonInfo> & buttonInfos,DialogEvent & acceptEvent)608 RefPtr<FrameNode> TimePickerDialogView::CreateConfirmNode(const RefPtr<FrameNode>& dateNode,
609     const RefPtr<FrameNode>& timePickerNode, const std::vector<ButtonInfo>& buttonInfos, DialogEvent& acceptEvent)
610 {
611     auto pipeline = PipelineContext::GetCurrentContext();
612     CHECK_NULL_RETURN(pipeline, nullptr);
613     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
614     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
615 
616     auto buttonConfirmNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
617         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
618     auto textConfirmNode = FrameNode::CreateFrameNode(
619         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
620     CHECK_NULL_RETURN(buttonConfirmNode, nullptr);
621     CHECK_NULL_RETURN(textConfirmNode, nullptr);
622     auto textLayoutProperty = textConfirmNode->GetLayoutProperty<TextLayoutProperty>();
623     CHECK_NULL_RETURN(textLayoutProperty, nullptr);
624     UpdateConfirmButtonTextLayoutProperty(textLayoutProperty, pickerTheme);
625     auto columnPattern = timePickerNode->GetPattern<TimePickerRowPattern>();
626     columnPattern->SetConfirmNode(buttonConfirmNode);
627     auto buttonConfirmEventHub = buttonConfirmNode->GetEventHub<ButtonEventHub>();
628     CHECK_NULL_RETURN(buttonConfirmEventHub, nullptr);
629     buttonConfirmEventHub->SetStateEffect(true);
630 
631     auto buttonConfirmLayoutProperty = buttonConfirmNode->GetLayoutProperty<ButtonLayoutProperty>();
632     CHECK_NULL_RETURN(buttonConfirmLayoutProperty, nullptr);
633     UpdateButtonLayoutProperty(buttonConfirmLayoutProperty, pickerTheme);
634     auto buttonConfirmRenderContext = buttonConfirmNode->GetRenderContext();
635     buttonConfirmRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
636     UpdateButtonStyles(buttonInfos, ACCEPT_BUTTON_INDEX, buttonConfirmLayoutProperty, buttonConfirmRenderContext);
637     UpdateButtonDefaultFocus(buttonInfos, buttonConfirmNode, true);
638 
639     textConfirmNode->MountToParent(buttonConfirmNode);
640     auto eventConfirmHub = buttonConfirmNode->GetOrCreateGestureEventHub();
641     CHECK_NULL_RETURN(eventConfirmHub, nullptr);
642     CHECK_NULL_RETURN(dateNode, nullptr);
643     SetDialogAcceptEvent(dateNode, std::move(acceptEvent));
644     auto clickCallback = [weak = WeakPtr<FrameNode>(dateNode)](const GestureEvent& /* info */) {
645         auto dateNode = weak.Upgrade();
646         CHECK_NULL_VOID(dateNode);
647         auto pickerPattern = dateNode->GetPattern<TimePickerRowPattern>();
648         CHECK_NULL_VOID(pickerPattern);
649         auto timePickerEventHub = pickerPattern->GetEventHub<TimePickerEventHub>();
650         CHECK_NULL_VOID(timePickerEventHub);
651         timePickerEventHub->FireDialogAcceptEvent(pickerPattern->GetSelectedObject(true));
652     };
653     eventConfirmHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(clickCallback));
654     buttonConfirmNode->MarkModifyDone();
655     return buttonConfirmNode;
656 }
657 
UpdateButtonLayoutProperty(const RefPtr<ButtonLayoutProperty> & buttonConfirmLayoutProperty,const RefPtr<PickerTheme> & pickerTheme)658 void TimePickerDialogView::UpdateButtonLayoutProperty(
659     const RefPtr<ButtonLayoutProperty>& buttonConfirmLayoutProperty, const RefPtr<PickerTheme>& pickerTheme)
660 {
661     CHECK_NULL_VOID(buttonConfirmLayoutProperty);
662     buttonConfirmLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.ok"));
663     buttonConfirmLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
664     buttonConfirmLayoutProperty->UpdateType(ButtonType::CAPSULE);
665     buttonConfirmLayoutProperty->UpdateFlexShrink(1.0);
666     auto pipeline = PipelineBase::GetCurrentContext();
667     CHECK_NULL_VOID(pipeline);
668     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
669     CHECK_NULL_VOID(dialogTheme);
670     UpdateConfirmButtonMargin(buttonConfirmLayoutProperty, dialogTheme);
671     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
672         buttonConfirmLayoutProperty->UpdateUserDefinedIdealSize(
673             CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
674     } else {
675         auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
676         CHECK_NULL_VOID(buttonTheme);
677         buttonConfirmLayoutProperty->UpdateUserDefinedIdealSize(
678             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
679     }
680 }
681 
UpdateConfirmButtonMargin(const RefPtr<ButtonLayoutProperty> & buttonConfirmLayoutProperty,const RefPtr<DialogTheme> & dialogTheme)682 void TimePickerDialogView::UpdateConfirmButtonMargin(
683     const RefPtr<ButtonLayoutProperty>& buttonConfirmLayoutProperty, const RefPtr<DialogTheme>& dialogTheme)
684 {
685     MarginProperty margin;
686     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
687         margin.right = CalcLength(dialogTheme->GetDividerPadding().Right());
688         margin.top = CalcLength(dialogTheme->GetDividerHeight());
689         margin.bottom = CalcLength(dialogTheme->GetDividerPadding().Bottom());
690         margin.left = CalcLength(0.0_vp);
691     } else {
692         margin.right = CalcLength(dialogTheme->GetActionsPadding().Right());
693         margin.top = CalcLength(dialogTheme->GetActionsPadding().Bottom());
694         margin.bottom = CalcLength(dialogTheme->GetActionsPadding().Bottom());
695         margin.left = CalcLength(0.0_vp);
696     }
697     buttonConfirmLayoutProperty->UpdateMargin(margin);
698 }
699 
UpdateConfirmButtonTextLayoutProperty(const RefPtr<TextLayoutProperty> & textLayoutProperty,const RefPtr<PickerTheme> & pickerTheme)700 void TimePickerDialogView::UpdateConfirmButtonTextLayoutProperty(
701     const RefPtr<TextLayoutProperty>& textLayoutProperty, const RefPtr<PickerTheme>& pickerTheme)
702 {
703     CHECK_NULL_VOID(textLayoutProperty);
704     textLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.ok"));
705     textLayoutProperty->UpdateTextColor(pickerTheme->GetOptionStyle(true, false).GetTextColor());
706     if (!NeedAdaptForAging()) {
707         textLayoutProperty->UpdateMaxFontScale(pickerTheme->GetNormalFontScale());
708     }
709     textLayoutProperty->UpdateFontSize(
710         ConvertFontScaleValue(pickerTheme->GetOptionStyle(false, false).GetFontSize()));
711     textLayoutProperty->UpdateFontWeight(pickerTheme->GetOptionStyle(true, false).GetFontWeight());
712 }
713 
UpdateCancelButtonMargin(const RefPtr<ButtonLayoutProperty> & buttonCancelLayoutProperty,const RefPtr<DialogTheme> & dialogTheme)714 void TimePickerDialogView::UpdateCancelButtonMargin(
715     const RefPtr<ButtonLayoutProperty>& buttonCancelLayoutProperty, const RefPtr<DialogTheme>& dialogTheme)
716 {
717     MarginProperty margin;
718     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
719         margin.left = CalcLength(dialogTheme->GetDividerPadding().Left());
720         margin.top = CalcLength(dialogTheme->GetDividerHeight());
721         margin.bottom = CalcLength(dialogTheme->GetDividerPadding().Bottom());
722         margin.right = CalcLength(0.0_vp);
723     } else {
724         margin.left = CalcLength(dialogTheme->GetActionsPadding().Left());
725         margin.top = CalcLength(dialogTheme->GetActionsPadding().Bottom());
726         margin.bottom = CalcLength(dialogTheme->GetActionsPadding().Bottom());
727         margin.right = CalcLength(0.0_vp);
728     }
729     buttonCancelLayoutProperty->UpdateMargin(margin);
730 }
731 
CreateCancelNode(NG::DialogGestureEvent & cancelEvent,const RefPtr<FrameNode> & timePickerNode,const std::vector<ButtonInfo> & buttonInfos)732 RefPtr<FrameNode> TimePickerDialogView::CreateCancelNode(NG::DialogGestureEvent& cancelEvent,
733     const RefPtr<FrameNode>& timePickerNode, const std::vector<ButtonInfo>& buttonInfos)
734 {
735     auto pipeline = PipelineContext::GetCurrentContext();
736     CHECK_NULL_RETURN(pipeline, nullptr);
737     auto dialogTheme = pipeline->GetTheme<DialogTheme>();
738     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
739     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
740     auto buttonCancelNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
741         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
742     CHECK_NULL_RETURN(buttonCancelNode, nullptr);
743     auto textCancelNode = FrameNode::CreateFrameNode(
744         V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
745     CHECK_NULL_RETURN(textCancelNode, nullptr);
746     auto textCancelLayoutProperty = textCancelNode->GetLayoutProperty<TextLayoutProperty>();
747     CHECK_NULL_RETURN(textCancelLayoutProperty, nullptr);
748     UpdateCancelButtonTextLayoutProperty(textCancelLayoutProperty, pickerTheme);
749     auto columnPattern = timePickerNode->GetPattern<TimePickerRowPattern>();
750     columnPattern->SetCancelNode(buttonCancelNode);
751     textCancelNode->MountToParent(buttonCancelNode);
752     auto eventCancelHub = buttonCancelNode->GetOrCreateGestureEventHub();
753     CHECK_NULL_RETURN(eventCancelHub, nullptr);
754     eventCancelHub->AddClickEvent(AceType::MakeRefPtr<NG::ClickEvent>(std::move(cancelEvent)));
755 
756     auto buttonCancelEventHub = buttonCancelNode->GetEventHub<ButtonEventHub>();
757     CHECK_NULL_RETURN(buttonCancelEventHub, nullptr);
758     buttonCancelEventHub->SetStateEffect(true);
759 
760     auto buttonCancelLayoutProperty = buttonCancelNode->GetLayoutProperty<ButtonLayoutProperty>();
761     buttonCancelLayoutProperty->UpdateLabel(Localization::GetInstance()->GetEntryLetters("common.cancel"));
762     buttonCancelLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT_MAIN_AXIS);
763     buttonCancelLayoutProperty->UpdateType(ButtonType::CAPSULE);
764     buttonCancelLayoutProperty->UpdateFlexShrink(1.0);
765     UpdateCancelButtonMargin(buttonCancelLayoutProperty, dialogTheme);
766     if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
767             buttonCancelLayoutProperty->UpdateUserDefinedIdealSize(
768                 CalcSize(CalcLength(pickerTheme->GetButtonWidth()), CalcLength(pickerTheme->GetButtonHeight())));
769     } else {
770         buttonCancelLayoutProperty->UpdateUserDefinedIdealSize(
771             CalcSize(CalcLength(1.0, DimensionUnit::PERCENT), CalcLength(buttonTheme->GetHeight())));
772     }
773 
774     auto buttonCancelRenderContext = buttonCancelNode->GetRenderContext();
775     buttonCancelRenderContext->UpdateBackgroundColor(Color::TRANSPARENT);
776     UpdateButtonStyles(buttonInfos, CANCEL_BUTTON_INDEX, buttonCancelLayoutProperty, buttonCancelRenderContext);
777     UpdateButtonDefaultFocus(buttonInfos, buttonCancelNode, false);
778     buttonCancelNode->MarkModifyDone();
779     return buttonCancelNode;
780 }
781 
UpdateCancelButtonTextLayoutProperty(const RefPtr<TextLayoutProperty> & textCancelLayoutProperty,const RefPtr<PickerTheme> & pickerTheme)782 void TimePickerDialogView::UpdateCancelButtonTextLayoutProperty(
783     const RefPtr<TextLayoutProperty>& textCancelLayoutProperty, const RefPtr<PickerTheme>& pickerTheme)
784 {
785     CHECK_NULL_VOID(textCancelLayoutProperty);
786     textCancelLayoutProperty->UpdateContent(Localization::GetInstance()->GetEntryLetters("common.cancel"));
787     textCancelLayoutProperty->UpdateTextColor(pickerTheme->GetOptionStyle(true, false).GetTextColor());
788     if (!NeedAdaptForAging()) {
789         textCancelLayoutProperty->UpdateMaxFontScale(pickerTheme->GetNormalFontScale());
790     }
791     textCancelLayoutProperty->UpdateFontSize(pickerTheme->GetOptionStyle(false, false).GetFontSize());
792     textCancelLayoutProperty->UpdateFontWeight(pickerTheme->GetOptionStyle(true, false).GetFontWeight());
793 }
794 
UpdateButtonStyles(const std::vector<ButtonInfo> & buttonInfos,size_t index,const RefPtr<ButtonLayoutProperty> & buttonLayoutProperty,const RefPtr<RenderContext> & buttonRenderContext)795 void TimePickerDialogView::UpdateButtonStyles(const std::vector<ButtonInfo>& buttonInfos, size_t index,
796     const RefPtr<ButtonLayoutProperty>& buttonLayoutProperty, const RefPtr<RenderContext>& buttonRenderContext)
797 {
798     if (index >= buttonInfos.size()) {
799         return;
800     }
801     CHECK_NULL_VOID(buttonLayoutProperty);
802     CHECK_NULL_VOID(buttonRenderContext);
803     auto pipeline = PipelineContext::GetCurrentContextSafelyWithCheck();
804     CHECK_NULL_VOID(pipeline);
805     auto buttonTheme = pipeline->GetTheme<ButtonTheme>();
806     CHECK_NULL_VOID(buttonTheme);
807     if (buttonInfos[index].type.has_value()) {
808         buttonLayoutProperty->UpdateType(buttonInfos[index].type.value());
809     }
810     UpdateButtonStyleAndRole(buttonInfos, index, buttonLayoutProperty, buttonRenderContext, buttonTheme);
811     if (buttonInfos[index].fontSize.has_value()) {
812         buttonLayoutProperty->UpdateFontSize(ConvertFontScaleValue(buttonInfos[index].fontSize.value()));
813     }
814     if (buttonInfos[index].fontColor.has_value()) {
815         buttonLayoutProperty->UpdateFontColor(buttonInfos[index].fontColor.value());
816     }
817     if (buttonInfos[index].fontWeight.has_value()) {
818         buttonLayoutProperty->UpdateFontWeight(buttonInfos[index].fontWeight.value());
819     }
820     if (buttonInfos[index].fontStyle.has_value()) {
821         buttonLayoutProperty->UpdateFontStyle(buttonInfos[index].fontStyle.value());
822     }
823     if (buttonInfos[index].fontFamily.has_value()) {
824         buttonLayoutProperty->UpdateFontFamily(buttonInfos[index].fontFamily.value());
825     }
826     if (buttonInfos[index].borderRadius.has_value()) {
827         buttonLayoutProperty->UpdateBorderRadius(buttonInfos[index].borderRadius.value());
828     }
829     if (buttonInfos[index].backgroundColor.has_value()) {
830         buttonRenderContext->UpdateBackgroundColor(buttonInfos[index].backgroundColor.value());
831     }
832 }
833 
UpdateButtonStyleAndRole(const std::vector<ButtonInfo> & buttonInfos,size_t index,const RefPtr<ButtonLayoutProperty> & buttonLayoutProperty,const RefPtr<RenderContext> & buttonRenderContext,const RefPtr<ButtonTheme> & buttonTheme)834 void TimePickerDialogView::UpdateButtonStyleAndRole(const std::vector<ButtonInfo>& buttonInfos, size_t index,
835     const RefPtr<ButtonLayoutProperty>& buttonLayoutProperty, const RefPtr<RenderContext>& buttonRenderContext,
836     const RefPtr<ButtonTheme>& buttonTheme)
837 {
838     if (index >= buttonInfos.size()) {
839         return;
840     }
841     CHECK_NULL_VOID(buttonLayoutProperty);
842     CHECK_NULL_VOID(buttonRenderContext);
843     CHECK_NULL_VOID(buttonTheme);
844     if (buttonInfos[index].role.has_value()) {
845         buttonLayoutProperty->UpdateButtonRole(buttonInfos[index].role.value());
846         ButtonStyleMode buttonStyleMode;
847         if (buttonInfos[index].buttonStyle.has_value()) {
848             buttonStyleMode = buttonInfos[index].buttonStyle.value();
849         } else {
850             buttonStyleMode = buttonLayoutProperty->GetButtonStyle().value_or(ButtonStyleMode::EMPHASIZE);
851         }
852         auto bgColor = buttonTheme->GetBgColor(buttonStyleMode, buttonInfos[index].role.value());
853         auto textColor = buttonTheme->GetTextColor(buttonStyleMode, buttonInfos[index].role.value());
854         buttonRenderContext->UpdateBackgroundColor(bgColor);
855         buttonLayoutProperty->UpdateFontColor(textColor);
856     }
857     if (buttonInfos[index].buttonStyle.has_value()) {
858         buttonLayoutProperty->UpdateButtonStyle(buttonInfos[index].buttonStyle.value());
859         ButtonRole buttonRole = buttonLayoutProperty->GetButtonRole().value_or(ButtonRole::NORMAL);
860         auto bgColor = buttonTheme->GetBgColor(buttonInfos[index].buttonStyle.value(), buttonRole);
861         auto textColor = buttonTheme->GetTextColor(buttonInfos[index].buttonStyle.value(), buttonRole);
862         buttonRenderContext->UpdateBackgroundColor(bgColor);
863         buttonLayoutProperty->UpdateFontColor(textColor);
864     }
865 }
866 
SetSelectedTime(const RefPtr<TimePickerRowPattern> & timePickerRowPattern,const PickerTime & value)867 void TimePickerDialogView::SetSelectedTime(
868     const RefPtr<TimePickerRowPattern>& timePickerRowPattern, const PickerTime& value)
869 {
870     timePickerRowPattern->SetSelectedTime(value);
871 }
872 
SetDialogTitleDate(const RefPtr<TimePickerRowPattern> & timePickerRowPattern,const PickerDate & value)873 void TimePickerDialogView::SetDialogTitleDate(
874     const RefPtr<TimePickerRowPattern>& timePickerRowPattern, const PickerDate& value)
875 {
876     timePickerRowPattern->SetDialogTitleDate(value);
877 }
878 
SetHour24(const RefPtr<TimePickerRowPattern> & timePickerRowPattern,bool isUseMilitaryTime)879 void TimePickerDialogView::SetHour24(const RefPtr<TimePickerRowPattern>& timePickerRowPattern, bool isUseMilitaryTime)
880 {
881     auto timePickerLayoutProperty = timePickerRowPattern->GetLayoutProperty<TimePickerLayoutProperty>();
882     CHECK_NULL_VOID(timePickerLayoutProperty);
883     timePickerLayoutProperty->UpdateIsUseMilitaryTime(isUseMilitaryTime);
884 }
885 
SetDialogChange(const RefPtr<FrameNode> & frameNode,DialogEvent && onChange)886 void TimePickerDialogView::SetDialogChange(const RefPtr<FrameNode>& frameNode, DialogEvent&& onChange)
887 {
888     CHECK_NULL_VOID(frameNode);
889     auto eventHub = frameNode->GetEventHub<TimePickerEventHub>();
890     CHECK_NULL_VOID(eventHub);
891     eventHub->SetDialogChange(std::move(onChange));
892 }
893 
SetDialogAcceptEvent(const RefPtr<FrameNode> & frameNode,DialogEvent && onChange)894 void TimePickerDialogView::SetDialogAcceptEvent(const RefPtr<FrameNode>& frameNode, DialogEvent&& onChange)
895 {
896     CHECK_NULL_VOID(frameNode);
897     auto eventHub = frameNode->GetEventHub<TimePickerEventHub>();
898     CHECK_NULL_VOID(eventHub);
899     eventHub->SetDialogAcceptEvent(std::move(onChange));
900 }
901 
SetTextProperties(const RefPtr<PickerTheme> & pickerTheme,const PickerTextProperties & properties)902 void TimePickerDialogView::SetTextProperties(
903     const RefPtr<PickerTheme>& pickerTheme, const PickerTextProperties& properties)
904 {
905     CHECK_NULL_VOID(pickerTheme);
906     auto selectedStyle = pickerTheme->GetOptionStyle(true, false);
907     auto normalStyle = pickerTheme->GetOptionStyle(false, false);
908 
909     SetTextDisappearProperties(pickerTheme, properties);
910 
911     if (properties.normalTextStyle_.fontSize.has_value() && properties.normalTextStyle_.fontSize->IsValid()) {
912         ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, FontSize,
913             ConvertFontScaleValue(properties.normalTextStyle_.fontSize.value(), normalTextStyleFont_, true));
914     } else {
915         ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, FontSize,
916             ConvertFontScaleValue(normalStyle.GetFontSize()));
917     }
918     ACE_UPDATE_LAYOUT_PROPERTY(
919         TimePickerLayoutProperty, Color, properties.normalTextStyle_.textColor.value_or(normalStyle.GetTextColor()));
920     ACE_UPDATE_LAYOUT_PROPERTY(
921         TimePickerLayoutProperty, Weight, properties.normalTextStyle_.fontWeight.value_or(normalStyle.GetFontWeight()));
922     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, FontFamily,
923         properties.normalTextStyle_.fontFamily.value_or(normalStyle.GetFontFamilies()));
924     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, FontStyle,
925         properties.normalTextStyle_.fontStyle.value_or(normalStyle.GetFontStyle()));
926 
927     if (properties.selectedTextStyle_.fontSize.has_value() && properties.selectedTextStyle_.fontSize->IsValid()) {
928         ACE_UPDATE_LAYOUT_PROPERTY(
929             TimePickerLayoutProperty, SelectedFontSize,
930             ConvertFontScaleValue(properties.selectedTextStyle_.fontSize.value(), selectedTextStyleFont_, true));
931     } else {
932         ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, SelectedFontSize,
933             ConvertFontScaleValue(selectedStyle.GetFontSize()));
934     }
935     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, SelectedColor,
936         properties.selectedTextStyle_.textColor.value_or(selectedStyle.GetTextColor()));
937     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, SelectedWeight,
938         properties.selectedTextStyle_.fontWeight.value_or(selectedStyle.GetFontWeight()));
939     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, SelectedFontFamily,
940         properties.selectedTextStyle_.fontFamily.value_or(selectedStyle.GetFontFamilies()));
941     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, SelectedFontStyle,
942         properties.selectedTextStyle_.fontStyle.value_or(selectedStyle.GetFontStyle()));
943 }
944 
SetTextDisappearProperties(const RefPtr<PickerTheme> & pickerTheme,const PickerTextProperties & properties)945 void TimePickerDialogView::SetTextDisappearProperties(
946     const RefPtr<PickerTheme>& pickerTheme, const PickerTextProperties& properties)
947 {
948     CHECK_NULL_VOID(pickerTheme);
949     auto disappearStyle = pickerTheme->GetDisappearOptionStyle();
950 
951     if (properties.disappearTextStyle_.fontSize.has_value() && properties.disappearTextStyle_.fontSize->IsValid()) {
952         ACE_UPDATE_LAYOUT_PROPERTY(
953             TimePickerLayoutProperty, DisappearFontSize,
954             ConvertFontScaleValue(properties.disappearTextStyle_.fontSize.value(), disappearTextStyleFont_, true));
955     } else {
956         ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, DisappearFontSize,
957             ConvertFontScaleValue(disappearStyle.GetFontSize()));
958     }
959     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, DisappearColor,
960         properties.disappearTextStyle_.textColor.value_or(disappearStyle.GetTextColor()));
961     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, DisappearWeight,
962         properties.disappearTextStyle_.fontWeight.value_or(disappearStyle.GetFontWeight()));
963     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, DisappearFontFamily,
964         properties.disappearTextStyle_.fontFamily.value_or(disappearStyle.GetFontFamilies()));
965     ACE_UPDATE_LAYOUT_PROPERTY(TimePickerLayoutProperty, DisappearFontStyle,
966         properties.disappearTextStyle_.fontStyle.value_or(disappearStyle.GetFontStyle()));
967 }
968 
UpdateButtonDefaultFocus(const std::vector<ButtonInfo> & buttonInfos,const RefPtr<FrameNode> & buttonNode,bool isConfirm)969 void TimePickerDialogView::UpdateButtonDefaultFocus(
970     const std::vector<ButtonInfo>& buttonInfos, const RefPtr<FrameNode>& buttonNode, bool isConfirm)
971 {
972     bool setDefaultFocus = false;
973     if (buttonInfos.size() > CANCEL_BUTTON_INDEX) {
974         if (buttonInfos[ACCEPT_BUTTON_INDEX].isPrimary && buttonInfos[CANCEL_BUTTON_INDEX].isPrimary) {
975             return;
976         }
977         auto index = isConfirm ? ACCEPT_BUTTON_INDEX : CANCEL_BUTTON_INDEX;
978         if (buttonInfos[index].isPrimary) {
979             setDefaultFocus = true;
980         }
981     } else if (buttonInfos.size() == CANCEL_BUTTON_INDEX) {
982         bool isAcceptButtonPrimary = (buttonInfos[0].isAcceptButton && isConfirm && buttonInfos[0].isPrimary);
983         bool isCancelButtonPrimary = (!buttonInfos[0].isAcceptButton && !isConfirm && buttonInfos[0].isPrimary);
984         if (isAcceptButtonPrimary || isCancelButtonPrimary) {
985             setDefaultFocus = true;
986         }
987     }
988     if (setDefaultFocus && buttonNode) {
989         auto focusHub = buttonNode->GetOrCreateFocusHub();
990         if (focusHub) {
991             focusHub->SetIsDefaultFocus(true);
992         }
993     }
994 }
995 
GetIsUserSetTextProperties(const PickerTextProperties & properties)996 bool TimePickerDialogView::GetIsUserSetTextProperties(const PickerTextProperties& properties)
997 {
998     if (properties.disappearTextStyle_.fontSize.has_value() && properties.disappearTextStyle_.fontSize->IsValid()) {
999         return true;
1000     }
1001 
1002     if (properties.normalTextStyle_.fontSize.has_value() && properties.normalTextStyle_.fontSize->IsValid()) {
1003         return true;
1004     }
1005     if (properties.selectedTextStyle_.fontSize.has_value() && properties.selectedTextStyle_.fontSize->IsValid()) {
1006         return true;
1007     }
1008     return false;
1009 }
NeedAdaptForAging()1010 bool TimePickerDialogView::NeedAdaptForAging()
1011 {
1012     auto pipeline = PipelineContext::GetCurrentContext();
1013     CHECK_NULL_RETURN(pipeline, false);
1014     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1015     CHECK_NULL_RETURN(pickerTheme, false);
1016 
1017     if (GreatOrEqual(pipeline->GetFontScale(), pickerTheme->GetMaxOneFontScale()) &&
1018         Dimension(pipeline->GetRootHeight()).ConvertToVp() > pickerTheme->GetDeviceHeightLimit()) {
1019         return true;
1020     }
1021     return false;
1022 }
1023 
AdjustFontSizeScale(const Dimension & fontSizeValue,double fontScale)1024 const Dimension TimePickerDialogView::AdjustFontSizeScale(const Dimension& fontSizeValue, double fontScale)
1025 {
1026     auto pipeline = PipelineContext::GetCurrentContextSafely();
1027     CHECK_NULL_RETURN(pipeline, fontSizeValue);
1028     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1029     CHECK_NULL_RETURN(pickerTheme, fontSizeValue);
1030 
1031     auto adjustedScale = std::clamp(fontScale, pickerTheme->GetNormalFontScale(),
1032         pickerTheme->GetMaxTwoFontScale());
1033     return fontSizeValue * adjustedScale;
1034 }
1035 
ConvertFontScaleValue(const Dimension & fontSizeValue,const Dimension & fontSizeLimit,bool isUserSetFont)1036 const Dimension TimePickerDialogView::ConvertFontScaleValue(
1037     const Dimension& fontSizeValue, const Dimension& fontSizeLimit, bool isUserSetFont)
1038 {
1039     auto pipeline = PipelineContext::GetCurrentContextPtrSafelyWithCheck();
1040     CHECK_NULL_RETURN(pipeline, fontSizeValue);
1041     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1042     CHECK_NULL_RETURN(pickerTheme, fontSizeValue);
1043     float fontSizeScale = pipeline->GetFontScale();
1044     Dimension fontSizeValueResult = fontSizeValue;
1045 
1046     if (NeedAdaptForAging()) {
1047         if (fontSizeValue.Unit() == DimensionUnit::VP) {
1048             if (isUserSetFont) {
1049                 fontSizeValueResult = ConvertFontSizeLimit(fontSizeValue, fontSizeLimit, isUserSetFont);
1050             }
1051             fontSizeValueResult = AdjustFontSizeScale(fontSizeValueResult, fontSizeScale);
1052         } else {
1053             if (GreatOrEqualCustomPrecision(fontSizeScale, pickerTheme->GetMaxThirdFontScale())) {
1054                 fontSizeScale = pickerTheme->GetMaxTwoFontScale() / pickerTheme->GetMaxThirdFontScale();
1055                 fontSizeValueResult = fontSizeValue * fontSizeScale;
1056             }
1057             if (isUserSetFont) {
1058                 fontSizeValueResult = ConvertFontSizeLimit(fontSizeValueResult, fontSizeLimit, isUserSetFont);
1059             }
1060         }
1061     } else {
1062         if (isUserSetFont) {
1063             fontSizeValueResult = ConvertFontSizeLimit(fontSizeValue, fontSizeLimit, isUserSetFont);
1064         }
1065 
1066         if (GreatOrEqualCustomPrecision(fontSizeScale, pickerTheme->GetMaxOneFontScale()) &&
1067             fontSizeValueResult.Unit() != DimensionUnit::VP) {
1068             if (!NearZero(fontSizeScale)) {
1069                 fontSizeValueResult = fontSizeValueResult / fontSizeScale;
1070             }
1071         }
1072     }
1073     return fontSizeValueResult;
1074 }
1075 
ConvertFontSizeLimit(const Dimension & fontSizeValue,const Dimension & fontSizeLimit,bool isUserSetFont)1076 const Dimension TimePickerDialogView::ConvertFontSizeLimit(
1077     const Dimension& fontSizeValue, const Dimension& fontSizeLimit, bool isUserSetFont)
1078 {
1079     if (isUserSetFont == false) {
1080         return fontSizeValue;
1081     }
1082     Dimension fontSizeValueResult = fontSizeValue;
1083     if (fontSizeValue.Unit() == DimensionUnit::VP) {
1084         if (GreatOrEqualCustomPrecision(fontSizeValue.ConvertToPx(), fontSizeLimit.ConvertToPx() / MARGIN_HALF)) {
1085             fontSizeValueResult = fontSizeLimit / MARGIN_HALF;
1086         } else {
1087             fontSizeValueResult = fontSizeValue;
1088         }
1089     } else {
1090         if (GreatOrEqualCustomPrecision(fontSizeValue.ConvertToPx(), fontSizeLimit.ConvertToPx())) {
1091             fontSizeValueResult = fontSizeLimit;
1092         } else {
1093             fontSizeValueResult = fontSizeValue;
1094         }
1095     }
1096 
1097     return fontSizeValueResult;
1098 }
1099 
ConvertTitleFontScaleValue(const Dimension & fontSizeValue)1100 const Dimension TimePickerDialogView::ConvertTitleFontScaleValue(const Dimension& fontSizeValue)
1101 {
1102     auto pipeline = PipelineContext::GetCurrentContextSafely();
1103     CHECK_NULL_RETURN(pipeline, fontSizeValue);
1104     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1105     CHECK_NULL_RETURN(pickerTheme, fontSizeValue);
1106 
1107     double fontScale = pipeline->GetFontScale();
1108     auto adjustedScale =
1109         std::clamp(fontScale, pickerTheme->GetNormalFontScale(), pickerTheme->GetTitleFontScaleLimit());
1110 
1111     if (NeedAdaptForAging()) {
1112         if (fontSizeValue.Unit() == DimensionUnit::VP) {
1113             return (fontSizeValue * adjustedScale);
1114         } else {
1115             if (GreatOrEqualCustomPrecision(pipeline->GetFontScale(), pickerTheme->GetTitleFontScaleLimit())) {
1116                 auto fontSizeScale = pickerTheme->GetTitleFontScaleLimit() / pipeline->GetFontScale();
1117                 return (fontSizeValue * fontSizeScale);
1118             }
1119         }
1120     } else {
1121         if (GreatOrEqualCustomPrecision(fontScale, pickerTheme->GetMaxOneFontScale()) &&
1122             fontSizeValue.Unit() != DimensionUnit::VP) {
1123             return (fontSizeValue / pipeline->GetFontScale());
1124         }
1125     }
1126     return fontSizeValue;
1127 }
1128 
GetUserSettingLimit()1129 void TimePickerDialogView::GetUserSettingLimit()
1130 {
1131     auto pipeline = PipelineContext::GetCurrentContextSafely();
1132     CHECK_NULL_VOID(pipeline);
1133     auto pickerTheme = pipeline->GetTheme<PickerTheme>();
1134     CHECK_NULL_VOID(pickerTheme);
1135     selectedTextStyleFont_ = pickerTheme->GetUseSetSelectedTextStyle();
1136     normalTextStyleFont_ = pickerTheme->GetUserSetNormalTextStyle();
1137     disappearTextStyleFont_ = pickerTheme->GetUserSetDisappearTextStyle();
1138 }
1139 
1140 } // namespace OHOS::Ace::NG
1141