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