1 /*
2 * Copyright (c) 2023-2024 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/interfaces/native/node/node_textpicker_modifier.h"
16 #include "native_type.h"
17
18 #include "bridge/common/utils/utils.h"
19 #include "core/components_ng/pattern/tabs/tabs_model.h"
20 #include "core/pipeline_ng/pipeline_context.h"
21 #include "core/components_ng/pattern/text_picker/textpicker_model_ng.h"
22 #include "core/common/resource/resource_parse_utils.h"
23
24 namespace OHOS::Ace::NG {
25 namespace {
26 constexpr int32_t SIZE_OF_THREE = 3;
27 constexpr int32_t POS_0 = 0;
28 constexpr int32_t POS_1 = 1;
29 constexpr int32_t POS_2 = 2;
30 constexpr int FONT_INFO_SIZE = 3;
31 constexpr int32_t DEFAULT_GROUP_DIVIDER_VALUES_COUNT = 3;
32 const char DEFAULT_DELIMITER = '|';
33 const int32_t ERROR_INT_CODE = -1;
34 constexpr uint32_t MAX_SIZE = 12;
35 constexpr float MAX_PERCENT = 100.0f;
36 constexpr bool DEFAULT_ENABLE_HAPTIC_FEEDBACK = true;
37 thread_local std::string g_strValue;
38 const std::vector<OHOS::Ace::FontStyle> FONT_STYLES = { OHOS::Ace::FontStyle::NORMAL, OHOS::Ace::FontStyle::ITALIC };
39 const std::vector<TextOverflow> TEXT_OVERFLOWS = { TextOverflow::NONE, TextOverflow::CLIP, TextOverflow::ELLIPSIS,
40 TextOverflow::MARQUEE };
41
42 enum GetValueArrayIndex {
43 GETCOLOR,
44 GETTOPLEFT,
45 GETTOPRIGHT,
46 GETBOTTOMLEFT,
47 GETBOTTOMRIGHT,
48 };
49 enum ValueArrayIndex {
50 TOPLEFT,
51 TOPRIGHT,
52 BOTTOMLEFT,
53 BOTTOMRIGHT,
54 };
55
GetPickerThemeByFrameNode(FrameNode * frameNode,RefPtr<PickerTheme> & theme)56 ArkUI_Bool GetPickerThemeByFrameNode(FrameNode* frameNode, RefPtr<PickerTheme>& theme)
57 {
58 CHECK_NULL_RETURN(frameNode, false);
59 auto pipeline = frameNode->GetContext();
60 CHECK_NULL_RETURN(pipeline, false);
61 auto themeManager = pipeline->GetThemeManager();
62 CHECK_NULL_RETURN(themeManager, false);
63 theme = themeManager->GetTheme<PickerTheme>();
64 CHECK_NULL_RETURN(theme, false);
65 return true;
66 }
67
InitTextPickerTextStyle(const char * fontInfo,uint32_t color,int32_t fontStyle,NG::PickerTextStyle & textStyle)68 void InitTextPickerTextStyle(const char* fontInfo, uint32_t color, int32_t fontStyle, NG::PickerTextStyle& textStyle)
69 {
70 std::vector<std::string> res;
71 std::string fontValues = std::string(fontInfo);
72 StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
73 if (res.size() != FONT_INFO_SIZE) {
74 return;
75 }
76 textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
77 if (fontStyle >= 0 && fontStyle < static_cast<int32_t>(FONT_STYLES.size())) {
78 textStyle.fontStyle = FONT_STYLES[fontStyle];
79 } else {
80 textStyle.fontStyle = FONT_STYLES[0];
81 }
82 textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
83 textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1]);
84 textStyle.textColor = Color(color);
85 }
86
SetTextPickerTextStyleResObj(NG::PickerTextStyle & textStyle,const struct ArkUIPickerTextStyleStruct * textStyleStruct)87 void SetTextPickerTextStyleResObj(NG::PickerTextStyle& textStyle,
88 const struct ArkUIPickerTextStyleStruct* textStyleStruct)
89 {
90 auto* fontSizePtr = reinterpret_cast<ResourceObject*>(textStyleStruct->fontSizeRawPtr);
91 if (fontSizePtr) {
92 textStyle.fontSizeResObj = AceType::Claim(fontSizePtr);
93 }
94
95 auto* fontFamilyPtr = reinterpret_cast<ResourceObject*>(textStyleStruct->fontFamilyRawPtr);
96 if (fontFamilyPtr) {
97 textStyle.fontFamilyResObj = AceType::Claim(fontFamilyPtr);
98 }
99
100 auto* textColorPtr = reinterpret_cast<ResourceObject*>(textStyleStruct->textColorRawPtr);
101 if (textColorPtr) {
102 textStyle.textColorResObj = AceType::Claim(textColorPtr);
103 }
104
105 auto* minFontSizePtr = reinterpret_cast<ResourceObject*>(textStyleStruct->minFontSizeRawPtr);
106 if (minFontSizePtr) {
107 textStyle.minFontSizeResObj = AceType::Claim(minFontSizePtr);
108 }
109
110 auto* maxFontSizePtr = reinterpret_cast<ResourceObject*>(textStyleStruct->maxFontSizeRawPtr);
111 if (maxFontSizePtr) {
112 textStyle.maxFontSizeResObj = AceType::Claim(maxFontSizePtr);
113 }
114 }
115
SetTextPickerBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)116 void SetTextPickerBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
117 {
118 auto* frameNode = reinterpret_cast<FrameNode*>(node);
119 CHECK_NULL_VOID(frameNode);
120 TextPickerModelNG::SetBackgroundColor(frameNode, Color(color));
121 }
122
ResetTextPickerBackgroundColor(ArkUINodeHandle node)123 void ResetTextPickerBackgroundColor(ArkUINodeHandle node)
124 {
125 auto* frameNode = reinterpret_cast<FrameNode*>(node);
126 CHECK_NULL_VOID(frameNode);
127 auto pipeline = frameNode->GetContext();
128 CHECK_NULL_VOID(pipeline);
129 auto theme = pipeline->GetTheme<DialogTheme>();
130 CHECK_NULL_VOID(theme);
131 TextPickerModelNG::SetBackgroundColor(frameNode, theme->GetBackgroundColor());
132 }
133
GetTextPickerCanLoop(ArkUINodeHandle node)134 ArkUI_Int32 GetTextPickerCanLoop(ArkUINodeHandle node)
135 {
136 auto* frameNode = reinterpret_cast<FrameNode*>(node);
137 CHECK_NULL_RETURN(frameNode, 1);
138 return TextPickerModelNG::GetCanLoop(frameNode);
139 }
140
SetTextPickerCanLoop(ArkUINodeHandle node,int canLoop)141 void SetTextPickerCanLoop(ArkUINodeHandle node, int canLoop)
142 {
143 auto* frameNode = reinterpret_cast<FrameNode*>(node);
144 CHECK_NULL_VOID(frameNode);
145 TextPickerModelNG::SetCanLoop(frameNode, canLoop);
146 }
147
ResetTextPickerCanLoop(ArkUINodeHandle node)148 void ResetTextPickerCanLoop(ArkUINodeHandle node)
149 {
150 auto* frameNode = reinterpret_cast<FrameNode*>(node);
151 CHECK_NULL_VOID(frameNode);
152 auto context = frameNode->GetContext();
153 CHECK_NULL_VOID(context);
154 auto themeManager = context->GetThemeManager();
155 CHECK_NULL_VOID(themeManager);
156 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
157 TextPickerModelNG::SetCanLoop(frameNode, true);
158 }
159
SetTextPickerDigitalCrownSensitivity(ArkUINodeHandle node,int32_t CrownSensitivity)160 void SetTextPickerDigitalCrownSensitivity(ArkUINodeHandle node, int32_t CrownSensitivity)
161 {
162 auto* frameNode = reinterpret_cast<FrameNode*>(node);
163 CHECK_NULL_VOID(frameNode);
164 TextPickerModelNG::SetDigitalCrownSensitivity(frameNode, CrownSensitivity);
165 }
166
ResetTextPickerDigitalCrownSensitivity(ArkUINodeHandle node)167 void ResetTextPickerDigitalCrownSensitivity(ArkUINodeHandle node)
168 {
169 auto* frameNode = reinterpret_cast<FrameNode*>(node);
170 CHECK_NULL_VOID(frameNode);
171 TextPickerModelNG::SetDigitalCrownSensitivity(frameNode, DEFAULT_CROWNSENSITIVITY);
172 }
173
GetTextPickerSelectedIndex(ArkUINodeHandle node,ArkUI_Uint32 * values,ArkUI_Int32 size)174 void GetTextPickerSelectedIndex(ArkUINodeHandle node, ArkUI_Uint32* values, ArkUI_Int32 size)
175 {
176 auto* frameNode = reinterpret_cast<FrameNode*>(node);
177 CHECK_NULL_VOID(frameNode);
178 if (TextPickerModelNG::IsSingle(frameNode)) {
179 auto selectedValue = static_cast<ArkUI_Uint32>(TextPickerModelNG::getTextPickerSelectedIndex(frameNode));
180 values[0] = selectedValue;
181 } else {
182 auto selectedValue = TextPickerModelNG::getTextPickerSelecteds(frameNode);
183 if (static_cast<ArkUI_Uint32>(size) != selectedValue.size()) {
184 return;
185 }
186 for (int i = 0; i < size; i++) {
187 values[i] = selectedValue[i];
188 }
189 }
190 }
191
SetTextPickerSelectedIndex(ArkUINodeHandle node,ArkUI_Uint32 * values,ArkUI_Int32 size)192 void SetTextPickerSelectedIndex(ArkUINodeHandle node, ArkUI_Uint32* values, ArkUI_Int32 size)
193 {
194 auto* frameNode = reinterpret_cast<FrameNode*>(node);
195 CHECK_NULL_VOID(frameNode);
196
197 if (TextPickerModelNG::IsSingle(frameNode)) {
198 NodeModifier::SetSelectedIndexSingle(frameNode, values, size);
199 } else {
200 NodeModifier::SetSelectedIndexMulti(frameNode, values, size);
201 }
202 }
203
ResetTextPickerSelectedIndex(ArkUINodeHandle node)204 void ResetTextPickerSelectedIndex(ArkUINodeHandle node)
205 {
206 auto* frameNode = reinterpret_cast<FrameNode*>(node);
207 CHECK_NULL_VOID(frameNode);
208 std::vector<uint32_t> selectedValues;
209 selectedValues.emplace_back(0);
210 if (TextPickerModelNG::IsSingle(frameNode)) {
211 NodeModifier::SetSelectedIndexSingle(frameNode, selectedValues.data(), selectedValues.size());
212 } else {
213 NodeModifier::SetSelectedIndexMulti(frameNode, selectedValues.data(), selectedValues.size());
214 }
215 }
216
SetTextPickerTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style,ArkUI_CharPtr minFontSize,ArkUI_CharPtr maxFontSize,ArkUI_Int32 overflow)217 void SetTextPickerTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo,
218 ArkUI_Int32 style, ArkUI_CharPtr minFontSize, ArkUI_CharPtr maxFontSize, ArkUI_Int32 overflow)
219 {
220 auto* frameNode = reinterpret_cast<FrameNode*>(node);
221 CHECK_NULL_VOID(frameNode);
222 RefPtr<PickerTheme> theme;
223 if (!GetPickerThemeByFrameNode(frameNode, theme)) {
224 return;
225 }
226 NG::PickerTextStyle textStyle;
227 InitTextPickerTextStyle(fontInfo, color, style, textStyle);
228 if (minFontSize) {
229 textStyle.minFontSize = StringUtils::StringToCalcDimension(minFontSize, false, DimensionUnit::FP);
230 }
231 if (maxFontSize) {
232 textStyle.maxFontSize = StringUtils::StringToCalcDimension(maxFontSize, false, DimensionUnit::FP);
233 }
234 if (overflow >= 0 && overflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
235 textStyle.textOverflow = TEXT_OVERFLOWS[overflow];
236 } else {
237 textStyle.textOverflow = TEXT_OVERFLOWS[0];
238 }
239 TextPickerModelNG::SetNormalTextStyle(frameNode, theme, textStyle);
240 }
241
SetTextPickerTextStyleWithResObj(ArkUINodeHandle node,const struct ArkUIPickerTextStyleStruct * textStyleStruct)242 void SetTextPickerTextStyleWithResObj(ArkUINodeHandle node, const struct ArkUIPickerTextStyleStruct* textStyleStruct)
243 {
244 auto* frameNode = reinterpret_cast<FrameNode*>(node);
245 CHECK_NULL_VOID(frameNode);
246 RefPtr<PickerTheme> theme;
247 if (!GetPickerThemeByFrameNode(frameNode, theme)) {
248 return;
249 }
250 NG::PickerTextStyle textStyle;
251 textStyle.textColorSetByUser = textStyleStruct->textColorSetByUser;
252 InitTextPickerTextStyle(textStyleStruct->fontInfo, textStyleStruct->textColor, textStyleStruct->fontStyle,
253 textStyle);
254 if (textStyleStruct->minFontSize) {
255 textStyle.minFontSize =
256 StringUtils::StringToCalcDimension(textStyleStruct->minFontSize, false, DimensionUnit::FP);
257 }
258 if (textStyleStruct->maxFontSize) {
259 textStyle.maxFontSize =
260 StringUtils::StringToCalcDimension(textStyleStruct->maxFontSize, false, DimensionUnit::FP);
261 }
262 if (textStyleStruct->textOverflow >= 0 &&
263 textStyleStruct->textOverflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
264 textStyle.textOverflow = TEXT_OVERFLOWS[textStyleStruct->textOverflow];
265 } else {
266 textStyle.textOverflow = TEXT_OVERFLOWS[0];
267 }
268 SetTextPickerTextStyleResObj(textStyle, textStyleStruct);
269 TextPickerModelNG::SetNormalTextStyle(frameNode, theme, textStyle);
270 }
271
ResetTextPickerTextStyle(ArkUINodeHandle node)272 void ResetTextPickerTextStyle(ArkUINodeHandle node)
273 {
274 auto* frameNode = reinterpret_cast<FrameNode*>(node);
275 CHECK_NULL_VOID(frameNode);
276 NG::PickerTextStyle pickerTextStyle;
277 auto context = frameNode->GetContext();
278 CHECK_NULL_VOID(context);
279 auto themeManager = context->GetThemeManager();
280 CHECK_NULL_VOID(themeManager);
281 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
282 TextPickerModelNG::SetNormalTextStyle(frameNode, pickerTheme, pickerTextStyle);
283 }
284
SetTextPickerSelectedTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style,ArkUI_CharPtr minFontSize,ArkUI_CharPtr maxFontSize,ArkUI_Int32 overflow)285 void SetTextPickerSelectedTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo,
286 ArkUI_Int32 style, ArkUI_CharPtr minFontSize, ArkUI_CharPtr maxFontSize, ArkUI_Int32 overflow)
287 {
288 auto* frameNode = reinterpret_cast<FrameNode*>(node);
289 CHECK_NULL_VOID(frameNode);
290 RefPtr<PickerTheme> theme;
291 if (!GetPickerThemeByFrameNode(frameNode, theme)) {
292 return;
293 }
294 NG::PickerTextStyle textStyle;
295 InitTextPickerTextStyle(fontInfo, color, style, textStyle);
296 if (minFontSize) {
297 textStyle.minFontSize = StringUtils::StringToCalcDimension(minFontSize, false, DimensionUnit::FP);
298 }
299 if (maxFontSize) {
300 textStyle.maxFontSize = StringUtils::StringToCalcDimension(maxFontSize, false, DimensionUnit::FP);
301 }
302 if (overflow >= 0 && overflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
303 textStyle.textOverflow = TEXT_OVERFLOWS[overflow];
304 } else {
305 textStyle.textOverflow = TEXT_OVERFLOWS[0];
306 }
307 TextPickerModelNG::SetSelectedTextStyle(frameNode, theme, textStyle);
308 }
309
SetTextPickerSelectedTextStyleWithResObj(ArkUINodeHandle node,const struct ArkUIPickerTextStyleStruct * textStyleStruct)310 void SetTextPickerSelectedTextStyleWithResObj(ArkUINodeHandle node,
311 const struct ArkUIPickerTextStyleStruct* textStyleStruct)
312 {
313 auto* frameNode = reinterpret_cast<FrameNode*>(node);
314 CHECK_NULL_VOID(frameNode);
315 RefPtr<PickerTheme> theme;
316 if (!GetPickerThemeByFrameNode(frameNode, theme)) {
317 return;
318 }
319 NG::PickerTextStyle textStyle;
320 textStyle.textColorSetByUser = textStyleStruct->textColorSetByUser;
321 InitTextPickerTextStyle(textStyleStruct->fontInfo, textStyleStruct->textColor, textStyleStruct->fontStyle,
322 textStyle);
323 if (textStyleStruct->minFontSize) {
324 textStyle.minFontSize =
325 StringUtils::StringToCalcDimension(textStyleStruct->minFontSize, false, DimensionUnit::FP);
326 }
327 if (textStyleStruct->maxFontSize) {
328 textStyle.maxFontSize =
329 StringUtils::StringToCalcDimension(textStyleStruct->maxFontSize, false, DimensionUnit::FP);
330 }
331 if (textStyleStruct->textOverflow >= 0 &&
332 textStyleStruct->textOverflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
333 textStyle.textOverflow = TEXT_OVERFLOWS[textStyleStruct->textOverflow];
334 } else {
335 textStyle.textOverflow = TEXT_OVERFLOWS[0];
336 }
337 SetTextPickerTextStyleResObj(textStyle, textStyleStruct);
338 TextPickerModelNG::SetSelectedTextStyle(frameNode, theme, textStyle);
339 }
340
ResetTextPickerSelectedTextStyle(ArkUINodeHandle node)341 void ResetTextPickerSelectedTextStyle(ArkUINodeHandle node)
342 {
343 auto* frameNode = reinterpret_cast<FrameNode*>(node);
344 CHECK_NULL_VOID(frameNode);
345 NG::PickerTextStyle pickerTextStyle;
346 auto context = frameNode->GetContext();
347 CHECK_NULL_VOID(context);
348 auto themeManager = context->GetThemeManager();
349 CHECK_NULL_VOID(themeManager);
350 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
351 TextPickerModelNG::SetSelectedTextStyle(frameNode, pickerTheme, pickerTextStyle);
352 }
353
SetTextPickerDisappearTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style,ArkUI_CharPtr minFontSize,ArkUI_CharPtr maxFontSize,ArkUI_Int32 overflow)354 void SetTextPickerDisappearTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo,
355 ArkUI_Int32 style, ArkUI_CharPtr minFontSize, ArkUI_CharPtr maxFontSize, ArkUI_Int32 overflow)
356 {
357 auto* frameNode = reinterpret_cast<FrameNode*>(node);
358 CHECK_NULL_VOID(frameNode);
359 RefPtr<PickerTheme> theme;
360 if (!GetPickerThemeByFrameNode(frameNode, theme)) {
361 return;
362 }
363 NG::PickerTextStyle textStyle;
364 InitTextPickerTextStyle(fontInfo, color, style, textStyle);
365 if (minFontSize) {
366 textStyle.minFontSize = StringUtils::StringToCalcDimension(minFontSize, false, DimensionUnit::FP);
367 }
368 if (maxFontSize) {
369 textStyle.maxFontSize = StringUtils::StringToCalcDimension(maxFontSize, false, DimensionUnit::FP);
370 }
371 if (overflow >= 0 && overflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
372 textStyle.textOverflow = TEXT_OVERFLOWS[overflow];
373 } else {
374 textStyle.textOverflow = TEXT_OVERFLOWS[0];
375 }
376 TextPickerModelNG::SetDisappearTextStyle(frameNode, theme, textStyle);
377 }
378
SetTextPickerDisappearTextStyleWithResObj(ArkUINodeHandle node,const struct ArkUIPickerTextStyleStruct * textStyleStruct)379 void SetTextPickerDisappearTextStyleWithResObj(ArkUINodeHandle node,
380 const struct ArkUIPickerTextStyleStruct* textStyleStruct)
381 {
382 auto* frameNode = reinterpret_cast<FrameNode*>(node);
383 CHECK_NULL_VOID(frameNode);
384 RefPtr<PickerTheme> theme;
385 if (!GetPickerThemeByFrameNode(frameNode, theme)) {
386 return;
387 }
388 NG::PickerTextStyle textStyle;
389 textStyle.textColorSetByUser = textStyleStruct->textColorSetByUser;
390 InitTextPickerTextStyle(textStyleStruct->fontInfo, textStyleStruct->textColor, textStyleStruct->fontStyle,
391 textStyle);
392 if (textStyleStruct->minFontSize) {
393 textStyle.minFontSize =
394 StringUtils::StringToCalcDimension(textStyleStruct->minFontSize, false, DimensionUnit::FP);
395 }
396 if (textStyleStruct->maxFontSize) {
397 textStyle.maxFontSize =
398 StringUtils::StringToCalcDimension(textStyleStruct->maxFontSize, false, DimensionUnit::FP);
399 }
400 if (textStyleStruct->textOverflow >= 0 &&
401 textStyleStruct->textOverflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
402 textStyle.textOverflow = TEXT_OVERFLOWS[textStyleStruct->textOverflow];
403 } else {
404 textStyle.textOverflow = TEXT_OVERFLOWS[0];
405 }
406 SetTextPickerTextStyleResObj(textStyle, textStyleStruct);
407 TextPickerModelNG::SetDisappearTextStyle(frameNode, theme, textStyle);
408 }
409
ResetTextPickerDisappearTextStyle(ArkUINodeHandle node)410 void ResetTextPickerDisappearTextStyle(ArkUINodeHandle node)
411 {
412 auto* frameNode = reinterpret_cast<FrameNode*>(node);
413 CHECK_NULL_VOID(frameNode);
414 NG::PickerTextStyle pickerTextStyle;
415 auto context = frameNode->GetContext();
416 CHECK_NULL_VOID(context);
417 auto themeManager = context->GetThemeManager();
418 CHECK_NULL_VOID(themeManager);
419 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
420 TextPickerModelNG::SetDisappearTextStyle(frameNode, pickerTheme, pickerTextStyle);
421 }
422
GetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node,ArkUI_Int32 dUnit)423 ArkUI_Float32 GetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node, ArkUI_Int32 dUnit)
424 {
425 auto* frameNode = reinterpret_cast<FrameNode*>(node);
426 CHECK_NULL_RETURN(frameNode, -1.0f);
427 return TextPickerModelNG::GetDefaultPickerItemHeight(frameNode).GetNativeValue(static_cast<DimensionUnit>(dUnit));
428 }
429
SetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node,float dVal,ArkUI_Int32 dUnit)430 void SetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node, float dVal, ArkUI_Int32 dUnit)
431 {
432 auto* frameNode = reinterpret_cast<FrameNode*>(node);
433 CHECK_NULL_VOID(frameNode);
434 TextPickerModelNG::SetDefaultPickerItemHeight(frameNode, Dimension(dVal, static_cast<DimensionUnit>(dUnit)));
435 }
436
ResetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node)437 void ResetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node)
438 {
439 auto* frameNode = reinterpret_cast<FrameNode*>(node);
440 CHECK_NULL_VOID(frameNode);
441 auto height = Dimension(0.0);
442 TextPickerModelNG::SetDefaultPickerItemHeight(frameNode, height);
443 }
444
GetTextPickerRangeStr(ArkUINodeHandle node)445 ArkUI_CharPtr GetTextPickerRangeStr(ArkUINodeHandle node)
446 {
447 auto* frameNode = reinterpret_cast<FrameNode*>(node);
448 CHECK_NULL_RETURN(frameNode, "");
449 g_strValue = TextPickerModelNG::getTextPickerRange(frameNode);
450 return g_strValue.c_str();
451 }
452
GetTextPickerSingleRange(ArkUINodeHandle node)453 ArkUI_Int32 GetTextPickerSingleRange(ArkUINodeHandle node)
454 {
455 auto* frameNode = reinterpret_cast<FrameNode*>(node);
456 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
457 return TextPickerModelNG::GetTextPickerRangeType(frameNode);
458 }
459
SetTextCascadePickChildrenRangeContent(std::vector<NG::TextCascadePickerOptions> & multiResult,ArkUITextCascadePickerRangeContentArray arry)460 void SetTextCascadePickChildrenRangeContent(
461 std::vector<NG::TextCascadePickerOptions>& multiResult, ArkUITextCascadePickerRangeContentArray arry)
462 {
463 for (int index = 0; index < arry->rangeContentArraySize; index++) {
464 NG::TextCascadePickerOptions option;
465 if (arry[index].text == nullptr) {
466 continue;
467 }
468 option.rangeResult.push_back(arry[index].text);
469
470 if (arry[index].children != nullptr) {
471 SetTextCascadePickChildrenRangeContent(option.children, arry[index].children);
472 }
473 multiResult.push_back(option);
474 }
475 }
476
SetTextCascadePickRangeContent(ArkUINodeHandle node,ArkUITextCascadePickerRangeContentArray arry,ArkUI_Int32 rangeType)477 void SetTextCascadePickRangeContent(
478 ArkUINodeHandle node, ArkUITextCascadePickerRangeContentArray arry, ArkUI_Int32 rangeType)
479 {
480 auto* frameNode = reinterpret_cast<FrameNode*>(node);
481 CHECK_NULL_VOID(frameNode);
482 std::vector<NG::TextCascadePickerOptions> multiResult;
483
484 SetTextCascadePickChildrenRangeContent(multiResult, arry);
485 TextPickerModelNG::SetHasSelectAttr(frameNode, true);
486 TextPickerModelNG::SetIsCascade(frameNode, true);
487 TextPickerModelNG::SetColumns(frameNode, multiResult);
488
489 std::vector<std::string> values;
490 for (int index = 0; index < arry->rangeContentArraySize; index++) {
491 if (arry[index].text == nullptr) {
492 continue;
493 }
494 values.emplace_back(arry[index].text);
495 }
496 TextPickerModelNG::SetValues(frameNode, values);
497 TextPickerModelNG::SetTextPickerRangeType(frameNode, rangeType);
498 }
499
SetTextPickerIconRangeStr(ArkUINodeHandle node,ArkUITextPickerRangeContentArray arry,ArkUI_Bool isSingleRange,ArkUI_Int32 rangeType)500 void SetTextPickerIconRangeStr(
501 ArkUINodeHandle node, ArkUITextPickerRangeContentArray arry, ArkUI_Bool isSingleRange, ArkUI_Int32 rangeType)
502 {
503 auto* frameNode = reinterpret_cast<FrameNode*>(node);
504 CHECK_NULL_VOID(frameNode);
505 TextPickerModelNG::SetTextPickerSingeRange(static_cast<bool>(isSingleRange));
506 std::vector<NG::RangeContent> result;
507 for (int i = 0; i < arry->rangeContentArraySize; i++) {
508 NG::RangeContent content;
509 if (arry->rangeContent[i].text != nullptr) {
510 content.text_ = arry->rangeContent[i].text;
511 }
512 if (arry->rangeContent[i].icon != nullptr) {
513 content.icon_ = arry->rangeContent[i].icon;
514 }
515 result.emplace_back(content);
516 }
517 TextPickerModelNG::SetColumnKind(frameNode, MIXTURE);
518 TextPickerModelNG::SetRange(frameNode, result);
519 TextPickerModelNG::SetTextPickerRangeType(frameNode, rangeType);
520 }
521
SetTextPickerRangeStr(ArkUINodeHandle node,ArkUI_CharPtr rangeStr,ArkUI_Bool isSingleRange,ArkUI_Int32 rangeType)522 void SetTextPickerRangeStr(
523 ArkUINodeHandle node, ArkUI_CharPtr rangeStr, ArkUI_Bool isSingleRange, ArkUI_Int32 rangeType)
524 {
525 auto* frameNode = reinterpret_cast<FrameNode*>(node);
526 CHECK_NULL_VOID(frameNode);
527 TextPickerModelNG::SetTextPickerSingeRange(static_cast<bool>(isSingleRange));
528 std::vector<std::string> getRangeVector;
529 StringUtils::StringSplitter(std::string(rangeStr), ';', getRangeVector);
530 if (isSingleRange) {
531 std::vector<NG::RangeContent> result;
532 for (const auto& text : getRangeVector) {
533 NG::RangeContent content;
534 content.icon_ = "";
535 content.text_ = text;
536 result.emplace_back(content);
537 }
538 TextPickerModelNG::SetColumnKind(frameNode, TEXT);
539 TextPickerModelNG::SetRange(frameNode, result);
540 } else {
541 std::vector<NG::TextCascadePickerOptions> multiResult;
542 for (const auto& text : getRangeVector) {
543 NG::TextCascadePickerOptions option;
544 StringUtils::StringSplitter(std::string(text), ',', option.rangeResult);
545 multiResult.emplace_back(option);
546 }
547 TextPickerModelNG::SetColumns(frameNode, multiResult);
548 }
549 TextPickerModelNG::SetTextPickerRangeType(frameNode, rangeType);
550 }
551
GetTextPickerValue(ArkUINodeHandle node)552 ArkUI_CharPtr GetTextPickerValue(ArkUINodeHandle node)
553 {
554 auto* frameNode = reinterpret_cast<FrameNode*>(node);
555 CHECK_NULL_RETURN(frameNode, "");
556 if (TextPickerModelNG::IsSingle(frameNode)) {
557 g_strValue = TextPickerModelNG::getTextPickerValue(frameNode);
558 } else {
559 g_strValue = TextPickerModelNG::getTextPickerValues(frameNode);
560 }
561 return g_strValue.c_str();
562 }
563
SetTextPickerValue(ArkUINodeHandle node,ArkUI_CharPtr valueStr)564 void SetTextPickerValue(ArkUINodeHandle node, ArkUI_CharPtr valueStr)
565 {
566 auto* frameNode = reinterpret_cast<FrameNode*>(node);
567 CHECK_NULL_VOID(frameNode);
568 std::vector<std::string> getValueVector;
569 StringUtils::StringSplitter(std::string(valueStr), ';', getValueVector);
570 if (TextPickerModelNG::GetTextPickerSingeRange()) {
571 TextPickerModelNG::SetValue(frameNode, valueStr);
572 } else {
573 TextPickerModelNG::SetValues(frameNode, getValueVector);
574 }
575 }
576
SetTextPickerColumnWidths(ArkUINodeHandle node,ArkUI_Float32 * values,ArkUI_Int32 size)577 void SetTextPickerColumnWidths(ArkUINodeHandle node, ArkUI_Float32* values, ArkUI_Int32 size)
578 {
579 std::vector<Dimension> widths;
580 auto* frameNode = reinterpret_cast<FrameNode*>(node);
581 CHECK_NULL_VOID(frameNode);
582 for (ArkUI_Int32 i = 0; i < size; i++) {
583 widths.emplace_back(Dimension(values[i] * MAX_PERCENT, DimensionUnit::PERCENT));
584 }
585 TextPickerModelNG::SetColumnWidths(frameNode, widths);
586 }
587
ResetTextPickerColumnWidths(ArkUINodeHandle node)588 void ResetTextPickerColumnWidths(ArkUINodeHandle node)
589 {
590 std::vector<Dimension> widths;
591 auto* frameNode = reinterpret_cast<FrameNode*>(node);
592 CHECK_NULL_VOID(frameNode);
593 auto childCount = frameNode->GetChildren().size();
594 for (size_t i = 0; i < childCount; i++) {
595 widths.emplace_back(Dimension(MAX_PERCENT / static_cast<float>(childCount), DimensionUnit::PERCENT));
596 }
597 TextPickerModelNG::SetColumnWidths(frameNode, widths);
598 }
599
GetTextPickerColumnWidthsSize(ArkUINodeHandle node)600 ArkUI_Int32 GetTextPickerColumnWidthsSize(ArkUINodeHandle node)
601 {
602 auto* frameNode = reinterpret_cast<FrameNode*>(node);
603 CHECK_NULL_RETURN(frameNode, 0);
604 return TextPickerModelNG::GetColumnWidthsSize(frameNode);
605 }
606
GetTextPickerColumnWidths(ArkUINodeHandle node,ArkUI_Float32 * values)607 void GetTextPickerColumnWidths(ArkUINodeHandle node, ArkUI_Float32* values)
608 {
609 auto* frameNode = reinterpret_cast<FrameNode*>(node);
610 CHECK_NULL_VOID(frameNode);
611 auto size = GetTextPickerColumnWidthsSize(node);
612 std::vector<Dimension> widths = TextPickerModelNG::GetColumnWidths(frameNode);
613 for (int32_t i = 0; i < size; i++) {
614 values[i] = widths[i].Value() / MAX_PERCENT;
615 }
616 }
617
GetTextPickerSelectedTextStyle(ArkUINodeHandle node)618 ArkUI_CharPtr GetTextPickerSelectedTextStyle(ArkUINodeHandle node)
619 {
620 auto* frameNode = reinterpret_cast<FrameNode*>(node);
621 CHECK_NULL_RETURN(frameNode, "");
622 PickerTextStyle pickerTextStyle = TextPickerModelNG::getSelectedTextStyle(frameNode);
623 std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
624 std::string families;
625 if (fontFamilies.size() == 0) {
626 fontFamilies.emplace_back("HarmonyOS Sans");
627 }
628 //set index start
629 int index = 0;
630 for (auto& family : fontFamilies) {
631 families += family;
632 if (index != static_cast<int>(fontFamilies.size()) - 1) {
633 families += ",";
634 }
635 index++;
636 }
637 g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
638 g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
639 g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
640 g_strValue = g_strValue + families + ";";
641 g_strValue =
642 g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
643 return g_strValue.c_str();
644 }
645
GetTextPickerTextStyle(ArkUINodeHandle node)646 ArkUI_CharPtr GetTextPickerTextStyle(ArkUINodeHandle node)
647 {
648 auto* frameNode = reinterpret_cast<FrameNode*>(node);
649 CHECK_NULL_RETURN(frameNode, "");
650 PickerTextStyle pickerTextStyle = TextPickerModelNG::getNormalTextStyle(frameNode);
651 std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
652 std::string families;
653 if (fontFamilies.size() == 0) {
654 fontFamilies.emplace_back("HarmonyOS Sans");
655 }
656 //set index start
657 int index = 0;
658 for (auto& family : fontFamilies) {
659 families += family;
660 if (index != static_cast<int>(fontFamilies.size()) - 1) {
661 families += ",";
662 }
663 index++;
664 }
665 g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
666 g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
667 g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
668 g_strValue = g_strValue + families + ";";
669 g_strValue =
670 g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
671 return g_strValue.c_str();
672 }
673
GetTextPickerDisappearTextStyle(ArkUINodeHandle node)674 ArkUI_CharPtr GetTextPickerDisappearTextStyle(ArkUINodeHandle node)
675 {
676 auto* frameNode = reinterpret_cast<FrameNode*>(node);
677 CHECK_NULL_RETURN(frameNode, "");
678 PickerTextStyle pickerTextStyle = TextPickerModelNG::getDisappearTextStyle(frameNode);
679 std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
680 std::string families;
681 if (fontFamilies.size() == 0) {
682 fontFamilies.emplace_back("HarmonyOS Sans");
683 }
684 //set index start
685 int index = 0;
686 for (auto& family : fontFamilies) {
687 families += family;
688 if (index != static_cast<int>(fontFamilies.size()) - 1) {
689 families += ",";
690 }
691 index++;
692 }
693 g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
694 g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
695 g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
696 g_strValue = g_strValue + families + ";";
697 g_strValue =
698 g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
699 return g_strValue.c_str();
700 }
701
SetTextPickerDivider(ArkUINodeHandle node,ArkUI_Uint32 color,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length)702 void SetTextPickerDivider(
703 ArkUINodeHandle node, ArkUI_Uint32 color, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length)
704 {
705 auto* frameNode = reinterpret_cast<FrameNode*>(node);
706 CHECK_NULL_VOID(frameNode);
707
708 if (length != DEFAULT_GROUP_DIVIDER_VALUES_COUNT) {
709 return;
710 }
711
712 NG::ItemDivider divider;
713 divider.color = Color(color);
714 divider.strokeWidth = Dimension(values[POS_0], static_cast<OHOS::Ace::DimensionUnit>(units[POS_0]));
715 divider.startMargin = Dimension(values[POS_1], static_cast<OHOS::Ace::DimensionUnit>(units[POS_1]));
716 divider.endMargin = Dimension(values[POS_2], static_cast<OHOS::Ace::DimensionUnit>(units[POS_2]));
717
718 TextPickerModelNG::SetDivider(frameNode, divider);
719 }
720
SetTextPickerDividerWithResObj(ArkUINodeHandle node,ArkUI_Uint32 color,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length,const struct ArkUIPickerDividerResObjStruct * dividerResObjStr,ArkUI_Bool isDefaultColor)721 void SetTextPickerDividerWithResObj(ArkUINodeHandle node, ArkUI_Uint32 color, const ArkUI_Float32* values,
722 const ArkUI_Int32* units, ArkUI_Int32 length, const struct ArkUIPickerDividerResObjStruct* dividerResObjStr,
723 ArkUI_Bool isDefaultColor)
724 {
725 auto* frameNode = reinterpret_cast<FrameNode*>(node);
726 CHECK_NULL_VOID(frameNode);
727
728 if (length != DEFAULT_GROUP_DIVIDER_VALUES_COUNT) {
729 return;
730 }
731
732 NG::ItemDivider divider;
733 divider.color = Color(color);
734 divider.isDefaultColor = isDefaultColor;
735 divider.strokeWidth = Dimension(values[POS_0], static_cast<OHOS::Ace::DimensionUnit>(units[POS_0]));
736 divider.startMargin = Dimension(values[POS_1], static_cast<OHOS::Ace::DimensionUnit>(units[POS_1]));
737 divider.endMargin = Dimension(values[POS_2], static_cast<OHOS::Ace::DimensionUnit>(units[POS_2]));
738
739 auto* strokeWidthPtr = reinterpret_cast<ResourceObject*>(dividerResObjStr->strokeWidthRawPtr);
740 auto strokeWidthResObj = AceType::Claim(strokeWidthPtr);
741 divider.strokeWidthResObj = strokeWidthResObj;
742
743 auto* colorPtr = reinterpret_cast<ResourceObject*>(dividerResObjStr->colorRawPtr);
744 auto colorResObj = AceType::Claim(colorPtr);
745 divider.colorResObj = colorResObj;
746
747 auto* startMarginPtr = reinterpret_cast<ResourceObject*>(dividerResObjStr->startMarginRawPtr);
748 auto startMarginResObj = AceType::Claim(startMarginPtr);
749 divider.startMarginResObj = startMarginResObj;
750
751 auto* endMarginPtr = reinterpret_cast<ResourceObject*>(dividerResObjStr->endMarginRawPtr);
752 auto endMarginResObj = AceType::Claim(endMarginPtr);
753 divider.endMarginResObj = endMarginResObj;
754 TextPickerModelNG::SetDivider(frameNode, divider);
755 }
756
ResetTextPickerDivider(ArkUINodeHandle node)757 void ResetTextPickerDivider(ArkUINodeHandle node)
758 {
759 auto* frameNode = reinterpret_cast<FrameNode*>(node);
760 CHECK_NULL_VOID(frameNode);
761 auto context = frameNode->GetContext();
762 CHECK_NULL_VOID(context);
763 auto themeManager = context->GetThemeManager();
764 CHECK_NULL_VOID(themeManager);
765 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
766 NG::ItemDivider divider;
767 Dimension defaultStrokeWidth = 0.0_vp;
768 Color defaultColor = Color::TRANSPARENT;
769 if (pickerTheme) {
770 defaultStrokeWidth = pickerTheme->GetDividerThickness();
771 defaultColor = pickerTheme->GetDividerColor();
772 divider.strokeWidth = defaultStrokeWidth;
773 divider.color = defaultColor;
774 }
775 TextPickerModelNG::TextPickerRemoveResObj(frameNode, "textPicker.divider");
776 TextPickerModelNG::SetDivider(frameNode, divider);
777 }
778
ResetTextPickerDividerNull(ArkUINodeHandle node)779 void ResetTextPickerDividerNull(ArkUINodeHandle node)
780 {
781 auto* frameNode = reinterpret_cast<FrameNode*>(node);
782 CHECK_NULL_VOID(frameNode);
783 NG::ItemDivider divider;
784 TextPickerModelNG::TextPickerRemoveResObj(frameNode, "textPicker.divider");
785 TextPickerModelNG::SetDivider(frameNode, divider);
786 }
787
SetTextPickerGradientHeight(ArkUINodeHandle node,ArkUI_Float32 dVal,ArkUI_Int32 dUnit)788 void SetTextPickerGradientHeight(ArkUINodeHandle node, ArkUI_Float32 dVal, ArkUI_Int32 dUnit)
789 {
790 auto* frameNode = reinterpret_cast<FrameNode*>(node);
791 CHECK_NULL_VOID(frameNode);
792 TextPickerModelNG::SetGradientHeight(frameNode, Dimension(dVal, static_cast<DimensionUnit>(dUnit)));
793 }
794
SetTextPickerGradientHeightWithResObj(ArkUINodeHandle node,ArkUI_Float32 dVal,ArkUI_Int32 dUnit,void * heightRawPtr)795 void SetTextPickerGradientHeightWithResObj(ArkUINodeHandle node, ArkUI_Float32 dVal, ArkUI_Int32 dUnit,
796 void* heightRawPtr)
797 {
798 auto* frameNode = reinterpret_cast<FrameNode*>(node);
799 CHECK_NULL_VOID(frameNode);
800 auto* heightPtr = reinterpret_cast<ResourceObject*>(heightRawPtr);
801 auto heightResObj = AceType::Claim(heightPtr);
802 TextPickerModelNG::ParseGradientHeight(frameNode, heightResObj);
803 TextPickerModelNG::SetGradientHeight(frameNode, Dimension(dVal, static_cast<DimensionUnit>(dUnit)));
804 }
805
ResetTextPickerGradientHeight(ArkUINodeHandle node)806 void ResetTextPickerGradientHeight(ArkUINodeHandle node)
807 {
808 auto* frameNode = reinterpret_cast<FrameNode*>(node);
809 CHECK_NULL_VOID(frameNode);
810
811 auto pipeline = frameNode->GetContext();
812 CHECK_NULL_VOID(pipeline);
813 auto themeManager = pipeline->GetThemeManager();
814 CHECK_NULL_VOID(themeManager);
815 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
816 CHECK_NULL_VOID(pickerTheme);
817
818 CalcDimension height;
819 if (pickerTheme) {
820 height = pickerTheme->GetGradientHeight();
821 } else {
822 height = 0.0_vp;
823 }
824
825 TextPickerModelNG::TextPickerRemoveResObj(frameNode, "textPicker.gradientHeight");
826 TextPickerModelNG::SetGradientHeight(frameNode, height);
827 }
828
SetTextPickerDisableTextStyleAnimation(ArkUINodeHandle node,int disableTextStyleAnimation)829 void SetTextPickerDisableTextStyleAnimation(ArkUINodeHandle node, int disableTextStyleAnimation)
830 {
831 auto* frameNode = reinterpret_cast<FrameNode*>(node);
832 CHECK_NULL_VOID(frameNode);
833 TextPickerModelNG::SetDisableTextStyleAnimation(frameNode, disableTextStyleAnimation);
834 }
835
ResetTextPickerDisableTextStyleAnimation(ArkUINodeHandle node)836 void ResetTextPickerDisableTextStyleAnimation(ArkUINodeHandle node)
837 {
838 auto* frameNode = reinterpret_cast<FrameNode*>(node);
839 CHECK_NULL_VOID(frameNode);
840 TextPickerModelNG::SetDisableTextStyleAnimation(frameNode, false);
841 }
842
SetTextPickerDefaultTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style,ArkUI_CharPtr minFontSize,ArkUI_CharPtr maxFontSize,ArkUI_Int32 overflow)843 void SetTextPickerDefaultTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo, ArkUI_Int32 style,
844 ArkUI_CharPtr minFontSize, ArkUI_CharPtr maxFontSize, ArkUI_Int32 overflow)
845 {
846 auto* frameNode = reinterpret_cast<FrameNode*>(node);
847 CHECK_NULL_VOID(frameNode);
848 auto pipeline = frameNode->GetContext();
849 CHECK_NULL_VOID(pipeline);
850 auto themeManager = pipeline->GetThemeManager();
851 CHECK_NULL_VOID(themeManager);
852 auto theme = themeManager->GetTheme<TextTheme>();
853 CHECK_NULL_VOID(theme);
854
855 NG::PickerTextStyle textStyle;
856 InitTextPickerTextStyle(fontInfo, color, style, textStyle);
857 textStyle.minFontSize = StringUtils::StringToCalcDimension(minFontSize, false, DimensionUnit::FP);
858 textStyle.maxFontSize = StringUtils::StringToCalcDimension(maxFontSize, false, DimensionUnit::FP);
859 if (overflow >= 0 && overflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
860 textStyle.textOverflow = TEXT_OVERFLOWS[overflow];
861 } else {
862 textStyle.textOverflow = TEXT_OVERFLOWS[0];
863 }
864
865 TextPickerModelNG::SetDefaultTextStyle(frameNode, theme, textStyle);
866 }
867
SetTextPickerDefaultTextStyleWithResObj(ArkUINodeHandle node,const struct ArkUIPickerTextStyleStruct * textStyleStruct)868 void SetTextPickerDefaultTextStyleWithResObj(ArkUINodeHandle node,
869 const struct ArkUIPickerTextStyleStruct* textStyleStruct)
870 {
871 auto* frameNode = reinterpret_cast<FrameNode*>(node);
872 CHECK_NULL_VOID(frameNode);
873 auto pipeline = frameNode->GetContext();
874 CHECK_NULL_VOID(pipeline);
875 auto themeManager = pipeline->GetThemeManager();
876 CHECK_NULL_VOID(themeManager);
877 auto theme = themeManager->GetTheme<TextTheme>();
878 CHECK_NULL_VOID(theme);
879
880 NG::PickerTextStyle textStyle;
881 textStyle.textColorSetByUser = textStyleStruct->textColorSetByUser;
882 InitTextPickerTextStyle(textStyleStruct->fontInfo, textStyleStruct->textColor, textStyleStruct->fontStyle,
883 textStyle);
884 textStyle.minFontSize = StringUtils::StringToCalcDimension(textStyleStruct->minFontSize, false, DimensionUnit::FP);
885 textStyle.maxFontSize = StringUtils::StringToCalcDimension(textStyleStruct->maxFontSize, false, DimensionUnit::FP);
886 if (textStyleStruct->textOverflow >= 0 &&
887 textStyleStruct->textOverflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
888 textStyle.textOverflow = TEXT_OVERFLOWS[textStyleStruct->textOverflow];
889 } else {
890 textStyle.textOverflow = TEXT_OVERFLOWS[0];
891 }
892 SetTextPickerTextStyleResObj(textStyle, textStyleStruct);
893 TextPickerModelNG::SetDefaultTextStyle(frameNode, theme, textStyle);
894 }
895
ResetTextPickerDefaultTextStyle(ArkUINodeHandle node)896 void ResetTextPickerDefaultTextStyle(ArkUINodeHandle node)
897 {
898 auto* frameNode = reinterpret_cast<FrameNode*>(node);
899 CHECK_NULL_VOID(frameNode);
900 auto pipeline = frameNode->GetContext();
901 CHECK_NULL_VOID(pipeline);
902 auto themeManager = pipeline->GetThemeManager();
903 CHECK_NULL_VOID(themeManager);
904 auto theme = themeManager->GetTheme<TextTheme>();
905 CHECK_NULL_VOID(theme);
906 NG::PickerTextStyle pickerTextStyle;
907 TextPickerModelNG::SetDefaultTextStyle(frameNode, theme, pickerTextStyle);
908 }
909
GetTextPickerSelectedSize(ArkUINodeHandle node)910 ArkUI_Int32 GetTextPickerSelectedSize(ArkUINodeHandle node)
911 {
912 auto* frameNode = reinterpret_cast<FrameNode*>(node);
913 CHECK_NULL_RETURN(frameNode, 0);
914 if (TextPickerModelNG::IsSingle(frameNode)) {
915 return 1;
916 }
917 return TextPickerModelNG::GetSelectedSize(frameNode);
918 }
SetTextPickerOnChangeExt(ArkUINodeHandle node,void * callback)919 void SetTextPickerOnChangeExt(ArkUINodeHandle node, void* callback)
920 {
921 auto* frameNode = reinterpret_cast<FrameNode*>(node);
922 CHECK_NULL_VOID(frameNode);
923 auto onChange =
924 reinterpret_cast<std::function<void(const std::vector<std::string>&, const std::vector<double>&)>*>(callback);
925 TextPickerModelNG::SetOnCascadeChange(frameNode, std::move(*onChange));
926 }
ResetTextPickerOnChange(ArkUINodeHandle node)927 void ResetTextPickerOnChange(ArkUINodeHandle node)
928 {
929 auto* frameNode = reinterpret_cast<FrameNode*>(node);
930 CHECK_NULL_VOID(frameNode);
931 TextPickerModelNG::SetOnCascadeChange(frameNode, nullptr);
932 }
SetTextPickerOnScrollStopExt(ArkUINodeHandle node,void * callback)933 void SetTextPickerOnScrollStopExt(ArkUINodeHandle node, void* callback)
934 {
935 auto* frameNode = reinterpret_cast<FrameNode*>(node);
936 CHECK_NULL_VOID(frameNode);
937 auto onChange =
938 reinterpret_cast<std::function<void(const std::vector<std::string>&, const std::vector<double>&)>*>(callback);
939 TextPickerModelNG::SetOnScrollStop(frameNode, std::move(*onChange));
940 }
ResetTextPickerOnScrollStop(ArkUINodeHandle node)941 void ResetTextPickerOnScrollStop(ArkUINodeHandle node)
942 {
943 auto* frameNode = reinterpret_cast<FrameNode*>(node);
944 CHECK_NULL_VOID(frameNode);
945 TextPickerModelNG::SetOnScrollStop(frameNode, nullptr);
946 }
947
SetTextPickerSelectedBackgroundStyle(ArkUINodeHandle node,ArkUI_Bool * getValue,ArkUI_Uint32 color,ArkUI_Float32 * value,ArkUI_Int32 * unit,ArkUI_Int32 size)948 void SetTextPickerSelectedBackgroundStyle(ArkUINodeHandle node, ArkUI_Bool* getValue, ArkUI_Uint32 color,
949 ArkUI_Float32* value, ArkUI_Int32* unit, ArkUI_Int32 size)
950 {
951 auto* frameNode = reinterpret_cast<FrameNode*>(node);
952 CHECK_NULL_VOID(frameNode);
953 auto pipeline = frameNode->GetContext();
954 CHECK_NULL_VOID(pipeline);
955 auto theme = pipeline->GetTheme<PickerTheme>();
956 CHECK_NULL_VOID(theme);
957 PickerBackgroundStyle pickerBgStyle;
958 pickerBgStyle.color = theme->GetSelectedBackgroundColor();
959 pickerBgStyle.borderRadius = theme->GetSelectedBorderRadius();
960 if (getValue[GETCOLOR]) {
961 pickerBgStyle.color = Color(color);
962 }
963 if (getValue[GETTOPLEFT]) {
964 pickerBgStyle.borderRadius->radiusTopLeft = Dimension(
965 value[TOPLEFT], static_cast<DimensionUnit>(unit[TOPLEFT]));
966 }
967 if (getValue[GETTOPRIGHT]) {
968 pickerBgStyle.borderRadius->radiusTopRight = Dimension(
969 value[TOPRIGHT], static_cast<DimensionUnit>(unit[TOPRIGHT]));
970 }
971 if (getValue[GETBOTTOMLEFT]) {
972 pickerBgStyle.borderRadius->radiusBottomLeft = Dimension(
973 value[BOTTOMLEFT], static_cast<DimensionUnit>(unit[BOTTOMLEFT]));
974 }
975 if (getValue[GETBOTTOMRIGHT]) {
976 pickerBgStyle.borderRadius->radiusBottomRight = Dimension(
977 value[BOTTOMRIGHT], static_cast<DimensionUnit>(unit[BOTTOMRIGHT]));
978 }
979 TextPickerModelNG::SetSelectedBackgroundStyle(frameNode, pickerBgStyle);
980 }
981
982 #define TEXT_PICKER_ADD_RADIUS_RESOURCE(radiusProp, propName, dimensionMember) \
983 auto propName##Update = [](const RefPtr<ResourceObject>& obj, BorderRadiusProperty& prop) { \
984 CalcDimension dim; \
985 ResourceParseUtils::ParseResDimensionVp(obj, dim); \
986 prop.dimensionMember = dim; \
987 }; \
988 const std::string resourceKey = std::string("borderRadius.") + #dimensionMember; \
989 (radiusProp)->AddResource(resourceKey, propName##ResObj, std::move(propName##Update))
990
AddRadiusResource(const struct ArkUIPickerBackgroundStyleStruct * backgroundStyleStruct,PickerBackgroundStyle & pickerBgStyle)991 void AddRadiusResource(const struct ArkUIPickerBackgroundStyleStruct* backgroundStyleStruct,
992 PickerBackgroundStyle& pickerBgStyle)
993 {
994 auto* topLeftResPtr = reinterpret_cast<ResourceObject*>(backgroundStyleStruct->topLeftRawPtr);
995 auto topLeftResObj = AceType::Claim(topLeftResPtr);
996 auto* topRightResPtr = reinterpret_cast<ResourceObject*>(backgroundStyleStruct->topRightRawPtr);
997 auto topRightResObj = AceType::Claim(topRightResPtr);
998 auto* bottomLeftResPtr = reinterpret_cast<ResourceObject*>(backgroundStyleStruct->bottomLeftRawPtr);
999 auto bottomLeftResObj = AceType::Claim(bottomLeftResPtr);
1000 auto* bottomRightResPtr = reinterpret_cast<ResourceObject*>(backgroundStyleStruct->bottomRightRawPtr);
1001 auto bottomRightResObj = AceType::Claim(bottomRightResPtr);
1002 if (topLeftResObj) {
1003 TEXT_PICKER_ADD_RADIUS_RESOURCE(pickerBgStyle.borderRadius, topLeft, radiusTopLeft);
1004 }
1005 if (topRightResObj) {
1006 TEXT_PICKER_ADD_RADIUS_RESOURCE(pickerBgStyle.borderRadius, topRight, radiusTopRight);
1007 }
1008 if (bottomLeftResObj) {
1009 TEXT_PICKER_ADD_RADIUS_RESOURCE(pickerBgStyle.borderRadius, bottomLeft, radiusBottomLeft);
1010 }
1011 if (bottomRightResObj) {
1012 TEXT_PICKER_ADD_RADIUS_RESOURCE(pickerBgStyle.borderRadius, bottomRight, radiusBottomRight);
1013 }
1014 }
1015
SetTextPickerSelectedBackgroundStyleWithResObj(ArkUINodeHandle node,ArkUI_Bool * isHasValue,const struct ArkUIPickerBackgroundStyleStruct * backgroundStyleStruct)1016 void SetTextPickerSelectedBackgroundStyleWithResObj(ArkUINodeHandle node, ArkUI_Bool* isHasValue,
1017 const struct ArkUIPickerBackgroundStyleStruct* backgroundStyleStruct)
1018 {
1019 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1020 CHECK_NULL_VOID(frameNode);
1021 auto pipeline = frameNode->GetContext();
1022 CHECK_NULL_VOID(pipeline);
1023 auto theme = pipeline->GetTheme<PickerTheme>();
1024 CHECK_NULL_VOID(theme);
1025 PickerBackgroundStyle pickerBgStyle;
1026 pickerBgStyle.color = theme->GetSelectedBackgroundColor();
1027 pickerBgStyle.borderRadius = theme->GetSelectedBorderRadius();
1028 if (isHasValue[GETCOLOR]) {
1029 pickerBgStyle.color = Color(backgroundStyleStruct->colorValue);
1030 pickerBgStyle.textColorSetByUser = backgroundStyleStruct->isColorSetByUser;
1031 auto* colorPtr = reinterpret_cast<ResourceObject*>(backgroundStyleStruct->colorRawPtr);
1032 pickerBgStyle.colorResObj = AceType::Claim(colorPtr);
1033 }
1034 if (isHasValue[GETTOPLEFT]) {
1035 pickerBgStyle.borderRadius->radiusTopLeft = Dimension(backgroundStyleStruct->values[TOPLEFT],
1036 static_cast<DimensionUnit>(backgroundStyleStruct->units[TOPLEFT]));
1037 }
1038 if (isHasValue[GETTOPRIGHT]) {
1039 pickerBgStyle.borderRadius->radiusTopRight = Dimension(backgroundStyleStruct->values[TOPRIGHT],
1040 static_cast<DimensionUnit>(backgroundStyleStruct->units[TOPRIGHT]));
1041 }
1042 if (isHasValue[GETBOTTOMLEFT]) {
1043 pickerBgStyle.borderRadius->radiusBottomLeft = Dimension(backgroundStyleStruct->values[BOTTOMLEFT],
1044 static_cast<DimensionUnit>(backgroundStyleStruct->units[BOTTOMLEFT]));
1045 }
1046 if (isHasValue[GETBOTTOMRIGHT]) {
1047 pickerBgStyle.borderRadius->radiusBottomRight = Dimension(backgroundStyleStruct->values[BOTTOMRIGHT],
1048 static_cast<DimensionUnit>(backgroundStyleStruct->units[BOTTOMRIGHT]));
1049 }
1050
1051 AddRadiusResource(backgroundStyleStruct, pickerBgStyle);
1052 TextPickerModelNG::SetSelectedBackgroundStyle(frameNode, pickerBgStyle);
1053 }
1054
GetTextPickerSelectedBackgroundStyle(ArkUINodeHandle node,ArkUINumberValue * result,ArkUI_Int32 size)1055 void GetTextPickerSelectedBackgroundStyle(ArkUINodeHandle node, ArkUINumberValue* result, ArkUI_Int32 size)
1056 {
1057 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1058 CHECK_NULL_VOID(frameNode);
1059 auto pickerBgStyle = TextPickerModelNG::GetSelectedBackgroundStyle(frameNode);
1060 result[GETCOLOR].u32 = pickerBgStyle.color->GetValue();
1061 result[GETTOPLEFT].f32 = pickerBgStyle.borderRadius->radiusTopLeft->Value();
1062 result[GETTOPRIGHT].f32 = pickerBgStyle.borderRadius->radiusTopRight->Value();
1063 result[GETBOTTOMLEFT].f32 = pickerBgStyle.borderRadius->radiusBottomLeft->Value();
1064 result[GETBOTTOMRIGHT].f32 = pickerBgStyle.borderRadius->radiusBottomRight->Value();
1065 }
1066
ResetTextPickerSelectedBackgroundStyle(ArkUINodeHandle node)1067 void ResetTextPickerSelectedBackgroundStyle(ArkUINodeHandle node)
1068 {
1069 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1070 CHECK_NULL_VOID(frameNode);
1071 auto pipeline = frameNode->GetContext();
1072 CHECK_NULL_VOID(pipeline);
1073 auto theme = pipeline->GetTheme<PickerTheme>();
1074 CHECK_NULL_VOID(theme);
1075 PickerBackgroundStyle pickerBgStyle;
1076 pickerBgStyle.color = theme->GetSelectedBackgroundColor();
1077 pickerBgStyle.borderRadius = theme->GetSelectedBorderRadius();
1078 TextPickerModelNG::SetSelectedBackgroundStyle(frameNode, pickerBgStyle);
1079 }
1080 } // namespace
1081
1082 namespace NodeModifier {
GetTextPickerModifier()1083 const ArkUITextPickerModifier* GetTextPickerModifier()
1084 {
1085 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1086 static const ArkUITextPickerModifier modifier = {
1087 .setTextPickerBackgroundColor = SetTextPickerBackgroundColor,
1088 .setTextPickerCanLoop = SetTextPickerCanLoop,
1089 .getTextPickerSelectedIndex = GetTextPickerSelectedIndex,
1090 .setTextPickerSelectedIndex = SetTextPickerSelectedIndex,
1091 .getTextPickerTextStyle = GetTextPickerTextStyle,
1092 .setTextPickerTextStyle = SetTextPickerTextStyle,
1093 .setTextPickerTextStyleWithResObj = SetTextPickerTextStyleWithResObj,
1094 .getTextPickerSelectedTextStyle = GetTextPickerSelectedTextStyle,
1095 .setTextPickerSelectedTextStyle = SetTextPickerSelectedTextStyle,
1096 .setTextPickerSelectedTextStyleWithResObj = SetTextPickerSelectedTextStyleWithResObj,
1097 .getTextPickerDisappearTextStyle = GetTextPickerDisappearTextStyle,
1098 .setTextPickerDisappearTextStyle = SetTextPickerDisappearTextStyle,
1099 .setTextPickerDisappearTextStyleWithResObj = SetTextPickerDisappearTextStyleWithResObj,
1100 .setTextPickerDefaultPickerItemHeight = SetTextPickerDefaultPickerItemHeight,
1101 .resetTextPickerCanLoop = ResetTextPickerCanLoop,
1102 .resetTextPickerSelectedIndex = ResetTextPickerSelectedIndex,
1103 .resetTextPickerTextStyle = ResetTextPickerTextStyle,
1104 .resetTextPickerSelectedTextStyle = ResetTextPickerSelectedTextStyle,
1105 .resetTextPickerDisappearTextStyle = ResetTextPickerDisappearTextStyle,
1106 .resetTextPickerDefaultPickerItemHeight = ResetTextPickerDefaultPickerItemHeight,
1107 .resetTextPickerBackgroundColor = ResetTextPickerBackgroundColor,
1108 .getTextPickerRangeStr = GetTextPickerRangeStr,
1109 .getTextPickerSingleRange = GetTextPickerSingleRange,
1110 .setTextPickerRangeStr = SetTextPickerRangeStr,
1111 .getTextPickerValue = GetTextPickerValue,
1112 .setTextPickerValue = SetTextPickerValue,
1113 .setTextPickerColumnWidths = SetTextPickerColumnWidths,
1114 .resetTextPickerColumnWidths = ResetTextPickerColumnWidths,
1115 .getTextPickerColumnWidths = GetTextPickerColumnWidths,
1116 .getTextPickerColumnWidthsSize = GetTextPickerColumnWidthsSize,
1117 .setTextPickerDivider = SetTextPickerDivider,
1118 .setTextPickerDividerWithResObj = SetTextPickerDividerWithResObj,
1119 .resetTextPickerDivider = ResetTextPickerDivider,
1120 .setTextPickerGradientHeight = SetTextPickerGradientHeight,
1121 .setTextPickerGradientHeightWithResObj = SetTextPickerGradientHeightWithResObj,
1122 .resetTextPickerGradientHeight = ResetTextPickerGradientHeight,
1123 .getTextPickerSelectedSize = GetTextPickerSelectedSize,
1124 .getTextPickerCanLoop = GetTextPickerCanLoop,
1125 .getTextPickerDefaultPickerItemHeight = GetTextPickerDefaultPickerItemHeight,
1126 .resetTextPickerDividerNull = ResetTextPickerDividerNull,
1127 .setTextPickerDisableTextStyleAnimation = SetTextPickerDisableTextStyleAnimation,
1128 .resetTextPickerDisableTextStyleAnimation = ResetTextPickerDisableTextStyleAnimation,
1129 .setTextPickerDefaultTextStyle = SetTextPickerDefaultTextStyle,
1130 .setTextPickerDefaultTextStyleWithResObj = SetTextPickerDefaultTextStyleWithResObj,
1131 .resetTextPickerDefaultTextStyle = ResetTextPickerDefaultTextStyle,
1132 .getTextPickerEnableHapticFeedback = GetTextPickerEnableHapticFeedback,
1133 .setTextPickerEnableHapticFeedback = SetTextPickerEnableHapticFeedback,
1134 .resetTextPickerEnableHapticFeedback = ResetTextPickerEnableHapticFeedback,
1135 .setTextPickerDigitalCrownSensitivity = SetTextPickerDigitalCrownSensitivity,
1136 .resetTextPickerDigitalCrownSensitivity = ResetTextPickerDigitalCrownSensitivity,
1137 .setTextPickerOnChange = SetTextPickerOnChangeExt,
1138 .resetTextPickerOnChange = ResetTextPickerOnChange,
1139 .setTextPickerOnScrollStop = SetTextPickerOnScrollStopExt,
1140 .resetTextPickerOnScrollStop = ResetTextPickerOnScrollStop,
1141 .setTextPickerIconRangeStr = SetTextPickerIconRangeStr,
1142 .setTextCascadePickRangeContent = SetTextCascadePickRangeContent,
1143 .setTextPickerSelectedBackgroundStyle = SetTextPickerSelectedBackgroundStyle,
1144 .setTextPickerSelectedBackgroundStyleWithResObj = SetTextPickerSelectedBackgroundStyleWithResObj,
1145 .getTextPickerSelectedBackgroundStyle = GetTextPickerSelectedBackgroundStyle,
1146 .resetTextPickerSelectedBackgroundStyle = ResetTextPickerSelectedBackgroundStyle,
1147 };
1148 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1149
1150 return &modifier;
1151 }
1152
GetCJUITextPickerModifier()1153 const CJUITextPickerModifier* GetCJUITextPickerModifier()
1154 {
1155 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1156 static const CJUITextPickerModifier modifier = {
1157 .setTextPickerBackgroundColor = SetTextPickerBackgroundColor,
1158 .setTextPickerCanLoop = SetTextPickerCanLoop,
1159 .getTextPickerSelectedIndex = GetTextPickerSelectedIndex,
1160 .setTextPickerSelectedIndex = SetTextPickerSelectedIndex,
1161 .getTextPickerTextStyle = GetTextPickerTextStyle,
1162 .setTextPickerTextStyle = SetTextPickerTextStyle,
1163 .getTextPickerSelectedTextStyle = GetTextPickerSelectedTextStyle,
1164 .setTextPickerSelectedTextStyle = SetTextPickerSelectedTextStyle,
1165 .getTextPickerDisappearTextStyle = GetTextPickerDisappearTextStyle,
1166 .setTextPickerDisappearTextStyle = SetTextPickerDisappearTextStyle,
1167 .setTextPickerDefaultPickerItemHeight = SetTextPickerDefaultPickerItemHeight,
1168 .resetTextPickerCanLoop = ResetTextPickerCanLoop,
1169 .resetTextPickerSelectedIndex = ResetTextPickerSelectedIndex,
1170 .resetTextPickerTextStyle = ResetTextPickerTextStyle,
1171 .resetTextPickerSelectedTextStyle = ResetTextPickerSelectedTextStyle,
1172 .resetTextPickerDisappearTextStyle = ResetTextPickerDisappearTextStyle,
1173 .resetTextPickerDefaultPickerItemHeight = ResetTextPickerDefaultPickerItemHeight,
1174 .resetTextPickerBackgroundColor = ResetTextPickerBackgroundColor,
1175 .getTextPickerRangeStr = GetTextPickerRangeStr,
1176 .getTextPickerSingleRange = GetTextPickerSingleRange,
1177 .setTextPickerRangeStr = SetTextPickerRangeStr,
1178 .getTextPickerValue = GetTextPickerValue,
1179 .setTextPickerValue = SetTextPickerValue,
1180 .setTextPickerDivider = SetTextPickerDivider,
1181 .resetTextPickerDivider = ResetTextPickerDivider,
1182 .setTextPickerGradientHeight = SetTextPickerGradientHeight,
1183 .resetTextPickerGradientHeight = ResetTextPickerGradientHeight,
1184 .getTextPickerSelectedSize = GetTextPickerSelectedSize,
1185 .getTextPickerCanLoop = GetTextPickerCanLoop,
1186 .getTextPickerDefaultPickerItemHeight = GetTextPickerDefaultPickerItemHeight,
1187 };
1188 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1189
1190 return &modifier;
1191 }
1192
GetPickerTextStyle(uint32_t color,ArkUI_CharPtr fontInfo,int32_t styleVal,NG::PickerTextStyle & textStyle)1193 void GetPickerTextStyle(uint32_t color, ArkUI_CharPtr fontInfo, int32_t styleVal, NG::PickerTextStyle& textStyle)
1194 {
1195 textStyle.textColor = Color(color);
1196
1197 std::vector<std::string> res;
1198 std::string fontValues = std::string(fontInfo);
1199 StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
1200
1201 if (res.size() != SIZE_OF_THREE) {
1202 return;
1203 }
1204
1205 if (res[POS_0] != "-1") {
1206 textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
1207 } else {
1208 textStyle.fontSize = Dimension(-1);
1209 }
1210
1211 if (res[POS_1] != "-1") {
1212 textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1], FontWeight::NORMAL);
1213 }
1214
1215 if (res[POS_2] != "-1") {
1216 textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
1217 }
1218 textStyle.fontStyle = static_cast<Ace::FontStyle>(styleVal);
1219 }
1220
SetSelectedIndexSingle(FrameNode * frameNode,uint32_t * selectedValues,const int32_t size)1221 void SetSelectedIndexSingle(FrameNode* frameNode, uint32_t* selectedValues, const int32_t size)
1222 {
1223 std::vector<NG::RangeContent> rangeResult;
1224 TextPickerModelNG::GetSingleRange(frameNode, rangeResult);
1225 if (selectedValues[0] >= rangeResult.size()) {
1226 TextPickerModelNG::SetSelected(frameNode, 0);
1227 } else {
1228 TextPickerModelNG::SetSelected(frameNode, selectedValues[0]);
1229 }
1230 }
1231
SetSelectedIndexMultiInternal(FrameNode * frameNode,uint32_t count,std::vector<NG::TextCascadePickerOptions> & options,std::vector<uint32_t> & selectedValues)1232 void SetSelectedIndexMultiInternal(FrameNode* frameNode, uint32_t count,
1233 std::vector<NG::TextCascadePickerOptions>& options, std::vector<uint32_t>& selectedValues)
1234 {
1235 if (!TextPickerModelNG::IsCascade(frameNode)) {
1236 NodeModifier::SetSelectedInternal(count, options, selectedValues);
1237 } else {
1238 TextPickerModelNG::SetHasSelectAttr(frameNode, true);
1239 NodeModifier::ProcessCascadeSelected(options, 0, selectedValues);
1240 uint32_t maxCount = TextPickerModelNG::GetMaxCount(frameNode);
1241 if (selectedValues.size() < maxCount) {
1242 auto differ = maxCount - selectedValues.size();
1243 for (uint32_t i = 0; i < differ; i++) {
1244 selectedValues.emplace_back(0);
1245 }
1246 }
1247 }
1248 }
1249
SetSelectedIndexSingleInternal(const std::vector<NG::TextCascadePickerOptions> & options,uint32_t count,uint32_t & selectedValue,std::vector<uint32_t> & selectedValues)1250 void SetSelectedIndexSingleInternal(const std::vector<NG::TextCascadePickerOptions>& options, uint32_t count,
1251 uint32_t& selectedValue, std::vector<uint32_t>& selectedValues)
1252 {
1253 if (options.size() > 0) {
1254 if (selectedValue >= options[0].rangeResult.size()) {
1255 selectedValue = 0;
1256 }
1257 selectedValues.emplace_back(selectedValue);
1258 for (uint32_t i = 1; i < count; i++) {
1259 selectedValues.emplace_back(0);
1260 }
1261 } else {
1262 for (uint32_t i = 0; i < count; i++) {
1263 selectedValues.emplace_back(0);
1264 }
1265 }
1266 }
1267
SetSelectedInternal(uint32_t count,std::vector<NG::TextCascadePickerOptions> & options,std::vector<uint32_t> & selectedValues)1268 void SetSelectedInternal(
1269 uint32_t count, std::vector<NG::TextCascadePickerOptions>& options, std::vector<uint32_t>& selectedValues)
1270 {
1271 for (uint32_t i = 0; i < count; i++) {
1272 uint32_t val = selectedValues.size() > 0 ? selectedValues.size() - 1 : 0;
1273 if (i > val) {
1274 selectedValues.emplace_back(0);
1275 } else {
1276 if (selectedValues[i] >= options[i].rangeResult.size()) {
1277 selectedValues[i] = 0;
1278 }
1279 }
1280 }
1281 }
1282
SetSelectedIndexMulti(FrameNode * frameNode,uint32_t * inputs,const int32_t size)1283 void SetSelectedIndexMulti(FrameNode* frameNode, uint32_t* inputs, const int32_t size)
1284 {
1285 std::vector<NG::TextCascadePickerOptions> options;
1286 TextPickerModelNG::GetMultiOptions(frameNode, options);
1287
1288 auto count = TextPickerModelNG::IsCascade(frameNode) ? TextPickerModelNG::GetMaxCount(frameNode) : options.size();
1289 std::vector<uint32_t> selectedValues;
1290
1291 if (size >= 0) {
1292 selectedValues.assign(inputs, inputs + size);
1293 SetSelectedIndexMultiInternal(frameNode, count, options, selectedValues);
1294 } else {
1295 TextPickerModelNG::SetHasSelectAttr(frameNode, true);
1296 SetSelectedIndexSingleInternal(options, count, inputs[0], selectedValues);
1297 }
1298 TextPickerModelNG::SetSelecteds(frameNode, selectedValues);
1299 }
1300
ProcessCascadeSelected(const std::vector<NG::TextCascadePickerOptions> & options,uint32_t index,std::vector<uint32_t> & selectedValues)1301 void ProcessCascadeSelected(
1302 const std::vector<NG::TextCascadePickerOptions>& options, uint32_t index, std::vector<uint32_t>& selectedValues)
1303 {
1304 const size_t size = options.size();
1305 if (size == 0) {
1306 return;
1307 }
1308 std::vector<std::string> rangeResultValue;
1309 for (size_t i = 0; i < size; i++) {
1310 rangeResultValue.emplace_back(options[i].rangeResult[0]);
1311 }
1312 uint32_t val = selectedValues.size() > 0 ? selectedValues.size() - 1 : 0;
1313 if (index > val) {
1314 selectedValues.emplace_back(0);
1315 }
1316 if (selectedValues[index] >= rangeResultValue.size()) {
1317 selectedValues[index] = 0;
1318 }
1319 if ((selectedValues[index] <= size - 1) && (options[selectedValues[index]].children.size() > 0)) {
1320 ProcessCascadeSelected(options[selectedValues[index]].children, index + 1, selectedValues);
1321 }
1322 }
1323
SetTextPickerOnChange(ArkUINodeHandle node,void * extraParam)1324 void SetTextPickerOnChange(ArkUINodeHandle node, void* extraParam)
1325 {
1326 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1327 CHECK_NULL_VOID(frameNode);
1328 auto onChangeEvent = [node, extraParam](
1329 const std::vector<std::string>& value, const std::vector<double>& indexVector) {
1330 ArkUINodeEvent event;
1331 event.kind = COMPONENT_ASYNC_EVENT;
1332 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1333 event.componentAsyncEvent.subKind = ON_TEXT_PICKER_CHANGE;
1334 for (size_t i = 0; i < indexVector.size() && i < MAX_SIZE; i++) {
1335 event.componentAsyncEvent.data[i].i32 = static_cast<int32_t>(indexVector[i]);
1336 }
1337 SendArkUISyncEvent(&event);
1338 };
1339 TextPickerModelNG::SetOnCascadeChange(frameNode, std::move(onChangeEvent));
1340 }
1341
SetTextPickerOnScrollStop(ArkUINodeHandle node,void * extraParam)1342 void SetTextPickerOnScrollStop(ArkUINodeHandle node, void* extraParam)
1343 {
1344 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1345 CHECK_NULL_VOID(frameNode);
1346 auto onScrollStopEvent = [node, extraParam](
1347 const std::vector<std::string>& value, const std::vector<double>& indexVector) {
1348 ArkUINodeEvent event;
1349 event.kind = COMPONENT_ASYNC_EVENT;
1350 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1351 event.componentAsyncEvent.subKind = ON_TEXT_PICKER_SCROLL_STOP;
1352 for (size_t i = 0; i < indexVector.size() && i < MAX_SIZE; i++) {
1353 event.componentAsyncEvent.data[i].i32 = static_cast<int32_t>(indexVector[i]);
1354 }
1355 SendArkUISyncEvent(&event);
1356 };
1357 TextPickerModelNG::SetOnScrollStop(frameNode, std::move(onScrollStopEvent));
1358 }
1359
SetTextPickerEnableHapticFeedback(ArkUINodeHandle node,ArkUI_Bool isEnableHapticFeedback)1360 void SetTextPickerEnableHapticFeedback(ArkUINodeHandle node, ArkUI_Bool isEnableHapticFeedback)
1361 {
1362 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1363 CHECK_NULL_VOID(frameNode);
1364 TextPickerModelNG::SetEnableHapticFeedback(frameNode, isEnableHapticFeedback);
1365 }
1366
ResetTextPickerEnableHapticFeedback(ArkUINodeHandle node)1367 void ResetTextPickerEnableHapticFeedback(ArkUINodeHandle node)
1368 {
1369 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1370 CHECK_NULL_VOID(frameNode);
1371 TextPickerModelNG::SetEnableHapticFeedback(frameNode, DEFAULT_ENABLE_HAPTIC_FEEDBACK);
1372 }
1373
GetTextPickerEnableHapticFeedback(ArkUINodeHandle node)1374 ArkUI_Bool GetTextPickerEnableHapticFeedback(ArkUINodeHandle node)
1375 {
1376 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1377 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1378 return static_cast<ArkUI_Bool>(TextPickerModelNG::GetEnableHapticFeedback(frameNode));
1379 }
1380 } // namespace NodeModifier
1381 } // namespace OHOS::Ace::NG
1382