1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "core/interfaces/native/node/calendar_picker_modifier.h"
17
18 #include "core/components_ng/base/view_abstract.h"
19 #include "frameworks/core/components_ng/pattern/calendar_picker/calendar_picker_model_ng.h"
20
21 namespace OHOS::Ace::NG {
22 namespace {
23 constexpr int NUM_0 = 0;
24 constexpr int NUM_1 = 1;
25 constexpr int NUM_2 = 2;
26 constexpr int NUM_12 = 12;
27 constexpr int DATE_SIZE = 3;
28 const bool DEFAULT_MARK_TODAY = false;
29 std::string g_strValue;
30 } // namespace
SetHintRadius(ArkUINodeHandle node,float radius,int32_t unit)31 void SetHintRadius(ArkUINodeHandle node, float radius, int32_t unit)
32 {
33 auto* frameNode = reinterpret_cast<FrameNode*>(node);
34 CHECK_NULL_VOID(frameNode);
35 Dimension radiusDimension(radius, static_cast<DimensionUnit>(unit));
36 CalendarPickerModelNG::SetHintRadiusWithNode(frameNode, radiusDimension);
37 }
38
GetHintRadius(ArkUINodeHandle node)39 float GetHintRadius(ArkUINodeHandle node)
40 {
41 auto* frameNode = reinterpret_cast<FrameNode*>(node);
42 CHECK_NULL_RETURN(frameNode, 0.0f);
43 return CalendarPickerModelNG::GetHintRadius(frameNode).Value();
44 }
45
SetSelectedDate(ArkUINodeHandle node,uint32_t year,uint32_t month,uint32_t day)46 void SetSelectedDate(ArkUINodeHandle node, uint32_t year, uint32_t month, uint32_t day)
47 {
48 auto* frameNode = reinterpret_cast<FrameNode*>(node);
49 CHECK_NULL_VOID(frameNode);
50 CalendarPickerModelNG::SetSelectDateWithNode(frameNode, year, month, day);
51 }
52
GetSelectedDate(ArkUINodeHandle node)53 ArkUISelectedDateType GetSelectedDate(ArkUINodeHandle node)
54 {
55 ArkUISelectedDateType selectedDate = { 0, 0, 0 };
56 auto* frameNode = reinterpret_cast<FrameNode*>(node);
57 CHECK_NULL_RETURN(frameNode, selectedDate);
58 auto pickDate = CalendarPickerModelNG::GetSelectDateWithNode(frameNode);
59 selectedDate.year = static_cast<uint32_t>(pickDate.GetYear());
60 selectedDate.month = static_cast<uint32_t>(pickDate.GetMonth());
61 selectedDate.day = static_cast<uint32_t>(pickDate.GetDay());
62 return selectedDate;
63 }
64
ResetSelectedDate(ArkUINodeHandle node)65 void ResetSelectedDate(ArkUINodeHandle node)
66 {
67 auto* frameNode = reinterpret_cast<FrameNode*>(node);
68 CHECK_NULL_VOID(frameNode);
69 auto currentDate = PickerDate::Current();
70 CalendarPickerModelNG::SetSelectDateWithNode(
71 frameNode, currentDate.GetYear(), currentDate.GetMonth(), currentDate.GetDay());
72 }
73
SetStartDate(ArkUINodeHandle node,uint32_t year,uint32_t month,uint32_t day)74 void SetStartDate(ArkUINodeHandle node, uint32_t year, uint32_t month, uint32_t day)
75 {
76 auto* frameNode = reinterpret_cast<FrameNode*>(node);
77 CHECK_NULL_VOID(frameNode);
78 CalendarPickerModelNG::SetStartDateWithNode(frameNode, year, month, day);
79 }
80
GetStartDate(ArkUINodeHandle node)81 ArkUI_CharPtr GetStartDate(ArkUINodeHandle node)
82 {
83 auto* frameNode = reinterpret_cast<FrameNode*>(node);
84 CHECK_NULL_RETURN(frameNode, "");
85 auto pickDate = CalendarPickerModelNG::GetStartDateWithNode(frameNode);
86 if (pickDate.ToDays() <= 0) {
87 return "";
88 }
89 g_strValue = std::to_string(static_cast<uint32_t>(pickDate.GetYear())) + "-";
90 g_strValue = g_strValue + std::to_string(static_cast<uint32_t>(pickDate.GetMonth())) + "-";
91 g_strValue = g_strValue + std::to_string(static_cast<uint32_t>(pickDate.GetDay()));
92 return g_strValue.c_str();
93 }
94
ResetStartDate(ArkUINodeHandle node)95 void ResetStartDate(ArkUINodeHandle node)
96 {
97 auto* frameNode = reinterpret_cast<FrameNode*>(node);
98 CHECK_NULL_VOID(frameNode);
99 PickerDate defaultDate;
100 CalendarPickerModelNG::SetStartDateWithNode(
101 frameNode, defaultDate.GetYear(), defaultDate.GetMonth(), defaultDate.GetDay());
102 }
103
SetEndDate(ArkUINodeHandle node,uint32_t year,uint32_t month,uint32_t day)104 void SetEndDate(ArkUINodeHandle node, uint32_t year, uint32_t month, uint32_t day)
105 {
106 auto* frameNode = reinterpret_cast<FrameNode*>(node);
107 CHECK_NULL_VOID(frameNode);
108 CalendarPickerModelNG::SetEndDateWithNode(frameNode, year, month, day);
109 }
110
GetEndDate(ArkUINodeHandle node)111 ArkUI_CharPtr GetEndDate(ArkUINodeHandle node)
112 {
113 auto* frameNode = reinterpret_cast<FrameNode*>(node);
114 CHECK_NULL_RETURN(frameNode, "");
115 auto pickDate = CalendarPickerModelNG::GetEndDateWithNode(frameNode);
116 if (pickDate.ToDays() <= 0) {
117 return "";
118 }
119 g_strValue = std::to_string(static_cast<uint32_t>(pickDate.GetYear())) + "-";
120 g_strValue = g_strValue + std::to_string(static_cast<uint32_t>(pickDate.GetMonth())) + "-";
121 g_strValue = g_strValue + std::to_string(static_cast<uint32_t>(pickDate.GetDay()));
122 return g_strValue.c_str();
123 }
124
ResetEndDate(ArkUINodeHandle node)125 void ResetEndDate(ArkUINodeHandle node)
126 {
127 auto* frameNode = reinterpret_cast<FrameNode*>(node);
128 CHECK_NULL_VOID(frameNode);
129 PickerDate defaultDate;
130 CalendarPickerModelNG::SetEndDateWithNode(
131 frameNode, defaultDate.GetYear(), defaultDate.GetMonth(), defaultDate.GetDay());
132 }
133
SetTextStyleWithWeightEnum(ArkUINodeHandle node,uint32_t color,float fontSize,int32_t fontSizeUnit,int32_t fontWeight)134 void SetTextStyleWithWeightEnum(
135 ArkUINodeHandle node, uint32_t color, float fontSize, int32_t fontSizeUnit, int32_t fontWeight)
136 {
137 auto* frameNode = reinterpret_cast<FrameNode*>(node);
138 CHECK_NULL_VOID(frameNode);
139 NG::PickerTextStyle textStyle;
140 textStyle.textColor = Color(color);
141 Dimension fontSizeDimension(fontSize, DimensionUnit::FP);
142 textStyle.fontSize = fontSizeDimension;
143 textStyle.fontWeight = static_cast<Ace::FontWeight>(fontWeight);
144 CalendarPickerModelNG::SetTextStyle(frameNode, textStyle);
145 }
146
SetTextStyle(ArkUINodeHandle node,uint32_t color,const char * fontSize,const char * fontweight)147 void SetTextStyle(ArkUINodeHandle node, uint32_t color, const char* fontSize, const char* fontweight)
148 {
149 auto* frameNode = reinterpret_cast<FrameNode*>(node);
150 CHECK_NULL_VOID(frameNode);
151 NG::PickerTextStyle textStyle;
152 textStyle.textColor = Color(color);
153 CalcDimension fontSizeDimension =
154 StringUtils::StringToCalcDimension(std::string(fontSize), false, DimensionUnit::FP);
155 if (fontSizeDimension.Unit() == DimensionUnit::PERCENT) {
156 textStyle.fontSize = Dimension(-1);
157 } else {
158 textStyle.fontSize = fontSizeDimension;
159 }
160 textStyle.fontWeight = StringUtils::StringToFontWeight(fontweight, FontWeight::NORMAL);
161 CalendarPickerModelNG::SetTextStyle(frameNode, textStyle);
162 }
163
GetTextStyle(ArkUINodeHandle node)164 ArkUICalendarTextStyleType GetTextStyle(ArkUINodeHandle node)
165 {
166 ArkUICalendarTextStyleType textStyle = { Color::BLACK.GetValue(), 0.0f, 0 };
167 auto* frameNode = reinterpret_cast<FrameNode*>(node);
168 CHECK_NULL_RETURN(frameNode, textStyle);
169 auto currentTextStyle = CalendarPickerModelNG::GetTextStyle(frameNode);
170 textStyle.fontColor = currentTextStyle.textColor.has_value() ? currentTextStyle.textColor.value().GetValue()
171 : Color::BLACK.GetValue();
172 textStyle.fontSize = currentTextStyle.fontSize.has_value() ? currentTextStyle.fontSize.value().Value() : 0.0f;
173 textStyle.fontWeight = currentTextStyle.fontWeight.has_value()
174 ? static_cast<int32_t>(currentTextStyle.fontWeight.value())
175 : static_cast<int32_t>(FontWeight::NORMAL);
176 return textStyle;
177 }
178
ResetTextStyle(ArkUINodeHandle node)179 void ResetTextStyle(ArkUINodeHandle node)
180 {
181 auto* frameNode = reinterpret_cast<FrameNode*>(node);
182 CHECK_NULL_VOID(frameNode);
183 auto pipeline = PipelineBase::GetCurrentContext();
184 CHECK_NULL_VOID(pipeline);
185 RefPtr<CalendarTheme> calendarTheme = pipeline->GetTheme<CalendarTheme>();
186 CHECK_NULL_VOID(calendarTheme);
187 NG::PickerTextStyle textStyle;
188 textStyle.fontSize = calendarTheme->GetEntryFontSize();
189 textStyle.textColor = calendarTheme->GetEntryFontColor();
190 textStyle.fontWeight = FontWeight::NORMAL;
191 CalendarPickerModelNG::SetTextStyle(frameNode, textStyle);
192 }
193
SetEdgeAlign(ArkUINodeHandle node,const ArkUI_Float32 * values,const int * units,int32_t size,int32_t alignType)194 void SetEdgeAlign(ArkUINodeHandle node, const ArkUI_Float32* values, const int* units, int32_t size, int32_t alignType)
195 {
196 auto* frameNode = reinterpret_cast<FrameNode*>(node);
197 CHECK_NULL_VOID(frameNode);
198 if (size < NUM_2) {
199 return;
200 }
201
202 Dimension dx = Dimension(values[NUM_0], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_0]));
203 Dimension dy = Dimension(values[NUM_1], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_1]));
204 NG::CalendarEdgeAlign align = static_cast<NG::CalendarEdgeAlign>(alignType);
205 DimensionOffset offset = DimensionOffset(dx, dy);
206 CalendarPickerModelNG::SetEdgeAlign(frameNode, align, offset);
207 }
208
GetEdgeAlign(ArkUINodeHandle node)209 ArkUIEdgeAlignType GetEdgeAlign(ArkUINodeHandle node)
210 {
211 ArkUIEdgeAlignType align = { 0, 0.0f, 0.0f };
212 auto* frameNode = reinterpret_cast<FrameNode*>(node);
213 CHECK_NULL_RETURN(frameNode, align);
214 auto offset = CalendarPickerModelNG::GetEdgeOffset(frameNode);
215 align.alignType = static_cast<int32_t>(CalendarPickerModelNG::GetEdgeAlignType(frameNode));
216 align.offsetX = offset.GetX().ConvertToVp();
217 align.offsetY = offset.GetY().ConvertToVp();
218 return align;
219 }
220
ResetEdgeAlign(ArkUINodeHandle node)221 void ResetEdgeAlign(ArkUINodeHandle node)
222 {
223 auto* frameNode = reinterpret_cast<FrameNode*>(node);
224 CHECK_NULL_VOID(frameNode);
225 NG::CalendarEdgeAlign alignType = NG::CalendarEdgeAlign::EDGE_ALIGN_END;
226 DimensionOffset offset;
227 CalendarPickerModelNG::SetEdgeAlign(frameNode, alignType, offset);
228 }
229
SetCalendarPickerHeight(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)230 void SetCalendarPickerHeight(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
231 {
232 auto* frameNode = reinterpret_cast<FrameNode*>(node);
233 CHECK_NULL_VOID(frameNode);
234 DimensionUnit unitEnum = static_cast<OHOS::Ace::DimensionUnit>(unit);
235 Dimension height = Dimension(value, unitEnum);
236 if (height.IsValid()) {
237 ViewAbstract::SetHeight(frameNode, CalcLength(height));
238 } else {
239 CalendarPickerModelNG::ClearHeight(frameNode);
240 }
241 }
242
ResetCalendarPickerHeight(ArkUINodeHandle node)243 void ResetCalendarPickerHeight(ArkUINodeHandle node)
244 {
245 auto* frameNode = reinterpret_cast<FrameNode*>(node);
246 CHECK_NULL_VOID(frameNode);
247 CalendarPickerModelNG::ClearHeight(frameNode);
248 }
249
SetCalendarPickerBorderColor(ArkUINodeHandle node,ArkUI_Uint32 color)250 void SetCalendarPickerBorderColor(ArkUINodeHandle node, ArkUI_Uint32 color)
251 {
252 auto* frameNode = reinterpret_cast<FrameNode*>(node);
253 CHECK_NULL_VOID(frameNode);
254 ViewAbstract::SetBorderColor(frameNode, Color(color));
255 }
256
ResetCalendarPickerBorderColor(ArkUINodeHandle node)257 void ResetCalendarPickerBorderColor(ArkUINodeHandle node)
258 {
259 auto* frameNode = reinterpret_cast<FrameNode*>(node);
260 CHECK_NULL_VOID(frameNode);
261 CalendarPickerModelNG::ClearBorderColor(frameNode);
262 }
263
SetCalendarPickerBorderRadius(ArkUINodeHandle node,const ArkUI_Float32 value,const ArkUI_Int32 unit)264 void SetCalendarPickerBorderRadius(ArkUINodeHandle node, const ArkUI_Float32 value, const ArkUI_Int32 unit)
265 {
266 auto *frameNode = reinterpret_cast<FrameNode *>(node);
267 CHECK_NULL_VOID(frameNode);
268 Dimension radius =
269 Dimension(static_cast<double>(value), static_cast<OHOS::Ace::DimensionUnit>(unit));
270 ViewAbstract::SetBorderRadius(frameNode, radius);
271 }
272
ResetCalendarPickerBorderRadius(ArkUINodeHandle node)273 void ResetCalendarPickerBorderRadius(ArkUINodeHandle node)
274 {
275 auto* frameNode = reinterpret_cast<FrameNode*>(node);
276 CHECK_NULL_VOID(frameNode);
277 CalendarPickerModelNG::ClearBorderRadius(frameNode);
278 }
279
ResetCalendarPickerBorderWidth(ArkUINodeHandle node)280 void ResetCalendarPickerBorderWidth(ArkUINodeHandle node)
281 {
282 auto* frameNode = reinterpret_cast<FrameNode*>(node);
283 CHECK_NULL_VOID(frameNode);
284 CalendarPickerModelNG::ClearBorderWidth(frameNode);
285 }
286
IsPaddingValid(NG::PaddingProperty & paddings,CalcLength topDim,CalcLength rightDim,CalcLength bottomDim,CalcLength leftDim)287 bool IsPaddingValid(NG::PaddingProperty& paddings, CalcLength topDim,
288 CalcLength rightDim, CalcLength bottomDim, CalcLength leftDim)
289 {
290 bool hasValue = false;
291 if (topDim.IsValid()) {
292 paddings.top = std::optional<CalcLength>(topDim);
293 hasValue = true;
294 }
295 if (bottomDim.IsValid()) {
296 paddings.bottom = std::optional<CalcLength>(bottomDim);
297 hasValue = true;
298 }
299 if (leftDim.IsValid()) {
300 paddings.left = std::optional<CalcLength>(leftDim);
301 hasValue = true;
302 }
303 if (rightDim.IsValid()) {
304 paddings.right = std::optional<CalcLength>(rightDim);
305 hasValue = true;
306 }
307 return hasValue;
308 }
309
SetCalendarPickerPadding(ArkUINodeHandle node,const struct ArkUISizeType * top,const struct ArkUISizeType * right,const struct ArkUISizeType * bottom,const struct ArkUISizeType * left)310 void SetCalendarPickerPadding(ArkUINodeHandle node, const struct ArkUISizeType* top, const struct ArkUISizeType* right,
311 const struct ArkUISizeType* bottom, const struct ArkUISizeType* left)
312 {
313 auto* frameNode = reinterpret_cast<FrameNode*>(node);
314 CHECK_NULL_VOID(frameNode);
315 CalcLength topDim;
316 CalcLength rightDim;
317 CalcLength bottomDim;
318 CalcLength leftDim;
319 if (top->string != nullptr) {
320 topDim = CalcLength(top->string);
321 } else {
322 topDim = CalcLength(top->value, static_cast<DimensionUnit>(top->unit));
323 }
324 if (right->string != nullptr) {
325 rightDim = CalcLength(right->string);
326 } else {
327 rightDim = CalcLength(right->value, static_cast<DimensionUnit>(right->unit));
328 }
329 if (bottom->string != nullptr) {
330 bottomDim = CalcLength(bottom->string);
331 } else {
332 bottomDim = CalcLength(bottom->value, static_cast<DimensionUnit>(bottom->unit));
333 }
334 if (left->string != nullptr) {
335 leftDim = CalcLength(left->string);
336 } else {
337 leftDim = CalcLength(left->value, static_cast<DimensionUnit>(left->unit));
338 }
339 NG::PaddingProperty paddings;
340 paddings.top = std::optional<CalcLength>();
341 paddings.bottom = std::optional<CalcLength>();
342 paddings.left = std::optional<CalcLength>();
343 paddings.right = std::optional<CalcLength>();
344
345 if (IsPaddingValid(paddings, topDim, rightDim, bottomDim, leftDim)) {
346 CalendarPickerModelNG::SetPadding(frameNode, paddings);
347 } else {
348 CalendarPickerModelNG::ClearPadding(frameNode);
349 }
350 }
351
ResetCalendarPickerPadding(ArkUINodeHandle node)352 void ResetCalendarPickerPadding(ArkUINodeHandle node)
353 {
354 auto* frameNode = reinterpret_cast<FrameNode*>(node);
355 CHECK_NULL_VOID(frameNode);
356 CalendarPickerModelNG::ClearPadding(frameNode);
357 }
358
SetCalendarPickerBorder(ArkUINodeHandle node,uint32_t color)359 void SetCalendarPickerBorder(ArkUINodeHandle node, uint32_t color)
360 {
361 auto* frameNode = reinterpret_cast<FrameNode*>(node);
362 CHECK_NULL_VOID(frameNode);
363
364 ViewAbstract::SetBorderColor(frameNode, Color(color));
365 }
366
ResetCalendarPickerBorder(ArkUINodeHandle node)367 void ResetCalendarPickerBorder(ArkUINodeHandle node)
368 {
369 auto* frameNode = reinterpret_cast<FrameNode*>(node);
370 CHECK_NULL_VOID(frameNode);
371
372 auto pipeline = PipelineBase::GetCurrentContext();
373 CHECK_NULL_VOID(pipeline);
374 RefPtr<CalendarTheme> calendarTheme = pipeline->GetTheme<CalendarTheme>();
375 CHECK_NULL_VOID(calendarTheme);
376 ViewAbstract::SetBorderWidth(frameNode, calendarTheme->GetEntryBorderWidth());
377 ViewAbstract::SetBorderColor(frameNode, calendarTheme->GetEntryBorderColor());
378 ViewAbstract::SetBorderRadius(frameNode, calendarTheme->GetEntryBorderRadius());
379 ViewAbstract::SetBorderStyle(frameNode, BorderStyle::SOLID);
380 }
381
SetCalendarPickerMarkToday(ArkUINodeHandle node,ArkUI_Bool isMarkToday)382 void SetCalendarPickerMarkToday(ArkUINodeHandle node, ArkUI_Bool isMarkToday)
383 {
384 auto* frameNode = reinterpret_cast<FrameNode*>(node);
385 CHECK_NULL_VOID(frameNode);
386 CalendarPickerModelNG::SetMarkToday(frameNode, isMarkToday);
387 }
388
ResetCalendarPickerMarkToday(ArkUINodeHandle node)389 void ResetCalendarPickerMarkToday(ArkUINodeHandle node)
390 {
391 auto* frameNode = reinterpret_cast<FrameNode*>(node);
392 CHECK_NULL_VOID(frameNode);
393 CalendarPickerModelNG::SetMarkToday(frameNode, DEFAULT_MARK_TODAY);
394 }
395
GetCalendarPickerMarkToday(ArkUINodeHandle node)396 ArkUI_Bool GetCalendarPickerMarkToday(ArkUINodeHandle node)
397 {
398 auto* frameNode = reinterpret_cast<FrameNode*>(node);
399 CHECK_NULL_RETURN(frameNode, DEFAULT_MARK_TODAY);
400 auto isMarkToday = CalendarPickerModelNG::GetMarkToday(frameNode);
401 return isMarkToday;
402 }
403
IsValidDate(uint32_t year,uint32_t month,uint32_t day)404 bool IsValidDate(uint32_t year, uint32_t month, uint32_t day)
405 {
406 if (year <= 0) {
407 return false;
408 }
409 if (month < NUM_1 || month > NUM_12) {
410 return false;
411 }
412 uint32_t daysInMonth[] = { 31, PickerDate::IsLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
413 if (day < 1 || day > daysInMonth[month - 1]) {
414 return false;
415 }
416 return true;
417 }
418
ParseDateFromString(const std::string & dateStr)419 PickerDate ParseDateFromString(const std::string& dateStr)
420 {
421 std::vector<std::string> dateVec;
422 StringUtils::StringSplitter(dateStr, '-', dateVec);
423 PickerDate date;
424 if (dateVec.size() != DATE_SIZE) {
425 return date;
426 }
427 auto year = StringUtils::StringToInt(dateVec[NUM_0].c_str());
428 auto month = StringUtils::StringToInt(dateVec[NUM_1].c_str());
429 auto day = StringUtils::StringToInt(dateVec[NUM_2].c_str());
430 if (!IsValidDate(year, month, day)) {
431 return date;
432 }
433 date.SetYear(year);
434 date.SetMonth(month);
435 date.SetDay(day);
436 return date;
437 }
438
SetCalendarPickerDisabledDateRange(ArkUINodeHandle node,ArkUI_CharPtr disabledDateRangeStr)439 void SetCalendarPickerDisabledDateRange(ArkUINodeHandle node, ArkUI_CharPtr disabledDateRangeStr)
440 {
441 auto* frameNode = reinterpret_cast<FrameNode*>(node);
442 CHECK_NULL_VOID(frameNode);
443 std::vector<std::string> dateStrVector;
444 StringUtils::StringSplitter(std::string(disabledDateRangeStr), ',', dateStrVector);
445 std::vector<std::pair<PickerDate, PickerDate>> disabledDateRange;
446 for (size_t i = 0; i + 1 < dateStrVector.size(); i += 2) { // 2 pair size
447 std::pair<PickerDate, PickerDate> pickerDateRange;
448 auto start = ParseDateFromString(dateStrVector[i]);
449 auto end = ParseDateFromString(dateStrVector[i + 1]);
450 if (start.GetYear() == 0 || end.GetYear() == 0 || end < start) {
451 continue;
452 }
453 pickerDateRange.first = start;
454 pickerDateRange.second = end;
455 disabledDateRange.emplace_back(pickerDateRange);
456 }
457 PickerDate::SortAndMergeDisabledDateRange(disabledDateRange);
458 CalendarPickerModelNG::SetDisabledDateRange(frameNode, disabledDateRange);
459 }
460
ResetCalendarPickerDisabledDateRange(ArkUINodeHandle node)461 void ResetCalendarPickerDisabledDateRange(ArkUINodeHandle node)
462 {
463 auto* frameNode = reinterpret_cast<FrameNode*>(node);
464 CHECK_NULL_VOID(frameNode);
465 std::vector<std::pair<PickerDate, PickerDate>> disabledDateRange;
466 CalendarPickerModelNG::SetDisabledDateRange(frameNode, disabledDateRange);
467 }
468
GetCalendarPickerDisabledDateRange(ArkUINodeHandle node)469 ArkUI_CharPtr GetCalendarPickerDisabledDateRange(ArkUINodeHandle node)
470 {
471 auto* frameNode = reinterpret_cast<FrameNode*>(node);
472 CHECK_NULL_RETURN(frameNode, "");
473
474 g_strValue = CalendarPickerModelNG::GetDisabledDateRange(frameNode);
475 return g_strValue.c_str();
476 }
477
SetCalendarPickerOnChangeExt(ArkUINodeHandle node,void * callback)478 void SetCalendarPickerOnChangeExt(ArkUINodeHandle node, void* callback)
479 {
480 auto* frameNode = reinterpret_cast<FrameNode*>(node);
481 CHECK_NULL_VOID(frameNode);
482 auto onChange = reinterpret_cast<std::function<void(const std::string&)>*>(callback);
483 CalendarPickerModelNG::SetOnChangeWithNode(frameNode, std::move(*onChange));
484 }
485
ResetCalendarPickerOnChange(ArkUINodeHandle node)486 void ResetCalendarPickerOnChange(ArkUINodeHandle node)
487 {
488 auto* frameNode = reinterpret_cast<FrameNode*>(node);
489 CHECK_NULL_VOID(frameNode);
490 CalendarPickerModelNG::SetOnChangeWithNode(frameNode, nullptr);
491 }
492 namespace NodeModifier {
GetCalendarPickerModifier()493 const ArkUICalendarPickerModifier* GetCalendarPickerModifier()
494 {
495 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
496 static const ArkUICalendarPickerModifier modifier = {
497 .setHintRadius = SetHintRadius,
498 .setSelectDate = SetSelectedDate,
499 .resetSelectDate = ResetSelectedDate,
500 .setTextStyleWithWeightEnum = SetTextStyleWithWeightEnum,
501 .setTextStyle = SetTextStyle,
502 .resetTextStyle = ResetTextStyle,
503 .setStartDate = SetStartDate,
504 .resetStartDate = ResetStartDate,
505 .setEndDate = SetEndDate,
506 .resetEndDate = ResetEndDate,
507 .setCalendarPickerMarkToday = SetCalendarPickerMarkToday,
508 .resetCalendarPickerMarkToday = ResetCalendarPickerMarkToday,
509 .setCalendarPickerDisabledDateRange = SetCalendarPickerDisabledDateRange,
510 .resetCalendarPickerDisabledDateRange = ResetCalendarPickerDisabledDateRange,
511 .setEdgeAlign = SetEdgeAlign,
512 .resetEdgeAlign = ResetEdgeAlign,
513 .setCalendarPickerPadding = SetCalendarPickerPadding,
514 .resetCalendarPickerPadding = ResetCalendarPickerPadding,
515 .setCalendarPickerBorder = SetCalendarPickerBorder,
516 .resetCalendarPickerBorder = ResetCalendarPickerBorder,
517 .getHintRadius = GetHintRadius,
518 .getSelectedDate = GetSelectedDate,
519 .getCalendarPickerTextStyle = GetTextStyle,
520 .getStartDate = GetStartDate,
521 .getEndDate = GetEndDate,
522 .getCalendarPickerMarkToday = GetCalendarPickerMarkToday,
523 .getCalendarPickerDisabledDateRange = GetCalendarPickerDisabledDateRange,
524 .getEdgeAlign = GetEdgeAlign,
525 .setCalendarPickerHeight = SetCalendarPickerHeight,
526 .resetCalendarPickerHeight = ResetCalendarPickerHeight,
527 .setCalendarPickerBorderColor = SetCalendarPickerBorderColor,
528 .resetCalendarPickerBorderColor = ResetCalendarPickerBorderColor,
529 .setCalendarPickerBorderRadius = SetCalendarPickerBorderRadius,
530 .resetCalendarPickerBorderRadius = ResetCalendarPickerBorderRadius,
531 .resetCalendarPickerBorderWidth = ResetCalendarPickerBorderWidth,
532 .setCalendarPickerOnChange = SetCalendarPickerOnChangeExt,
533 .resetCalendarPickerOnChange = ResetCalendarPickerOnChange,
534 };
535 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
536
537 return &modifier;
538 }
539
GetCJUICalendarPickerModifier()540 const CJUICalendarPickerModifier* GetCJUICalendarPickerModifier()
541 {
542 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
543 static const CJUICalendarPickerModifier modifier = {
544 .setHintRadius = SetHintRadius,
545 .setSelectDate = SetSelectedDate,
546 .resetSelectDate = ResetSelectedDate,
547 .setTextStyleWithWeightEnum = SetTextStyleWithWeightEnum,
548 .setTextStyle = SetTextStyle,
549 .resetTextStyle = ResetTextStyle,
550 .setStartDate = SetStartDate,
551 .resetStartDate = ResetStartDate,
552 .setEndDate = SetEndDate,
553 .resetEndDate = ResetEndDate,
554 .setCalendarPickerMarkToday = SetCalendarPickerMarkToday,
555 .resetCalendarPickerMarkToday = ResetCalendarPickerMarkToday,
556 .setCalendarPickerDisabledDateRange = SetCalendarPickerDisabledDateRange,
557 .resetCalendarPickerDisabledDateRange = ResetCalendarPickerDisabledDateRange,
558 .setEdgeAlign = SetEdgeAlign,
559 .resetEdgeAlign = ResetEdgeAlign,
560 .setCalendarPickerPadding = SetCalendarPickerPadding,
561 .resetCalendarPickerPadding = ResetCalendarPickerPadding,
562 .setCalendarPickerBorder = SetCalendarPickerBorder,
563 .resetCalendarPickerBorder = ResetCalendarPickerBorder,
564 .getHintRadius = GetHintRadius,
565 .getSelectedDate = GetSelectedDate,
566 .getCalendarPickerTextStyle = GetTextStyle,
567 .getStartDate = GetStartDate,
568 .getEndDate = GetEndDate,
569 .getCalendarPickerMarkToday = GetCalendarPickerMarkToday,
570 .getCalendarPickerDisabledDateRange = GetCalendarPickerDisabledDateRange,
571 .getEdgeAlign = GetEdgeAlign,
572 .setCalendarPickerHeight = SetCalendarPickerHeight,
573 .resetCalendarPickerHeight = ResetCalendarPickerHeight,
574 .setCalendarPickerBorderColor = SetCalendarPickerBorderColor,
575 .resetCalendarPickerBorderColor = ResetCalendarPickerBorderColor,
576 .setCalendarPickerBorderRadius = SetCalendarPickerBorderRadius,
577 .resetCalendarPickerBorderRadius = ResetCalendarPickerBorderRadius,
578 .resetCalendarPickerBorderWidth = ResetCalendarPickerBorderWidth,
579 };
580 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
581
582 return &modifier;
583 }
584
ParseDateByStr(const std::string & date,ArkUISelectedDateType & selectedDate)585 void ParseDateByStr(const std::string& date, ArkUISelectedDateType& selectedDate)
586 {
587 auto json = JsonUtil::ParseJsonString(date);
588 if (!json || json->IsNull()) {
589 return;
590 }
591 auto year = json->GetValue("year");
592 if (year && year->IsNumber()) {
593 uint32_t yearVal = year->GetInt() > 0 ? static_cast<uint32_t>(year->GetInt()) : 0;
594 selectedDate.year = yearVal; // local date start from 1900
595 }
596 auto month = json->GetValue("month");
597 if (month && month->IsNumber()) {
598 uint32_t monthVal = month->GetInt() > 0 ? static_cast<uint32_t>(month->GetInt()) : 0;
599 selectedDate.month = monthVal;
600 }
601 auto day = json->GetValue("day");
602 if (day && day->IsNumber()) {
603 uint32_t dayVal = day->GetInt() > 0 ? static_cast<uint32_t>(day->GetInt()) : 0;
604 selectedDate.day = dayVal;
605 }
606 }
607
SetCalendarPickerOnChange(ArkUINodeHandle node,void * extraParam)608 void SetCalendarPickerOnChange(ArkUINodeHandle node, void* extraParam)
609 {
610 auto* frameNode = reinterpret_cast<FrameNode*>(node);
611 CHECK_NULL_VOID(frameNode);
612 auto onEvent = [node, extraParam](const std::string& dateStr) {
613 ArkUINodeEvent event;
614 event.kind = COMPONENT_ASYNC_EVENT;
615 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
616 ArkUISelectedDateType selectedDate;
617 selectedDate.year = 0;
618 selectedDate.month = 0;
619 selectedDate.day = 0;
620 ParseDateByStr(dateStr, selectedDate);
621 event.componentAsyncEvent.subKind = ON_CALENDAR_PICKER_CHANGE;
622 event.componentAsyncEvent.data[NUM_0].u32 = selectedDate.year;
623 event.componentAsyncEvent.data[NUM_1].u32 = selectedDate.month;
624 event.componentAsyncEvent.data[NUM_2].u32 = selectedDate.day;
625 SendArkUISyncEvent(&event);
626 };
627 CalendarPickerModelNG::SetOnChangeWithNode(frameNode, std::move(onEvent));
628 }
629 } // namespace NodeModifier
630 } // namespace OHOS::Ace::NG
631