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 
17 #include "base/geometry/dimension.h"
18 #include "base/utils/utils.h"
19 #include "bridge/common/utils/utils.h"
20 #include "core/components/common/layout/constants.h"
21 #include "core/components/common/properties/text_style.h"
22 #include "core/components/picker/picker_theme.h"
23 #include "core/components_ng/base/frame_node.h"
24 #include "core/components_ng/pattern/picker/picker_type_define.h"
25 #include "core/components_ng/pattern/tabs/tabs_model.h"
26 #include "core/components_ng/pattern/text_picker/textpicker_model_ng.h"
27 #include "core/interfaces/arkoala/arkoala_api.h"
28 #include "core/pipeline/base/element_register.h"
29 
30 namespace OHOS::Ace::NG {
31 namespace {
32 constexpr int32_t SIZE_OF_THREE = 3;
33 constexpr int32_t POS_0 = 0;
34 constexpr int32_t POS_1 = 1;
35 constexpr int32_t POS_2 = 2;
36 constexpr int NUM_3 = 3;
37 constexpr int32_t DEFAULT_GROUP_DIVIDER_VALUES_COUNT = 3;
38 const char DEFAULT_DELIMITER = '|';
39 const int32_t ERROR_INT_CODE = -1;
40 constexpr uint32_t MAX_SIZE = 12;
41 std::string g_strValue;
42 const std::vector<OHOS::Ace::FontStyle> FONT_STYLES = { OHOS::Ace::FontStyle::NORMAL, OHOS::Ace::FontStyle::ITALIC };
43 
SetTextPickerBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)44 void SetTextPickerBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
45 {
46     auto* frameNode = reinterpret_cast<FrameNode*>(node);
47     CHECK_NULL_VOID(frameNode);
48     TextPickerModelNG::SetBackgroundColor(frameNode, Color(color));
49 }
50 
ResetTextPickerBackgroundColor(ArkUINodeHandle node)51 void ResetTextPickerBackgroundColor(ArkUINodeHandle node)
52 {
53     auto* frameNode = reinterpret_cast<FrameNode*>(node);
54     CHECK_NULL_VOID(frameNode);
55     auto pipeline = frameNode->GetContext();
56     CHECK_NULL_VOID(pipeline);
57     auto theme = pipeline->GetTheme<DialogTheme>();
58     CHECK_NULL_VOID(theme);
59     TextPickerModelNG::SetBackgroundColor(frameNode, theme->GetBackgroundColor());
60 }
61 
GetTextPickerCanLoop(ArkUINodeHandle node)62 ArkUI_Int32 GetTextPickerCanLoop(ArkUINodeHandle node)
63 {
64     auto* frameNode = reinterpret_cast<FrameNode*>(node);
65     CHECK_NULL_RETURN(frameNode, 1);
66     return TextPickerModelNG::GetCanLoop(frameNode);
67 }
68 
SetTextPickerCanLoop(ArkUINodeHandle node,int canLoop)69 void SetTextPickerCanLoop(ArkUINodeHandle node, int canLoop)
70 {
71     auto* frameNode = reinterpret_cast<FrameNode*>(node);
72     CHECK_NULL_VOID(frameNode);
73     TextPickerModelNG::SetCanLoop(frameNode, canLoop);
74 }
75 
ResetTextPickerCanLoop(ArkUINodeHandle node)76 void ResetTextPickerCanLoop(ArkUINodeHandle node)
77 {
78     auto* frameNode = reinterpret_cast<FrameNode*>(node);
79     CHECK_NULL_VOID(frameNode);
80     TextPickerModelNG::SetCanLoop(frameNode, true);
81 }
82 
GetTextPickerSelectedIndex(ArkUINodeHandle node,ArkUI_Uint32 * values,ArkUI_Int32 size)83 void GetTextPickerSelectedIndex(ArkUINodeHandle node, ArkUI_Uint32* values, ArkUI_Int32 size)
84 {
85     auto* frameNode = reinterpret_cast<FrameNode*>(node);
86     CHECK_NULL_VOID(frameNode);
87     if (TextPickerModelNG::IsSingle(frameNode)) {
88         auto selectedValue = static_cast<ArkUI_Uint32>(TextPickerModelNG::getTextPickerSelectedIndex(frameNode));
89         values[0] = selectedValue;
90     } else {
91         auto selectedValue = TextPickerModelNG::getTextPickerSelecteds(frameNode);
92         if (static_cast<ArkUI_Uint32>(size) != selectedValue.size()) {
93             return;
94         }
95         for (int i = 0; i < size; i++) {
96             values[i] = selectedValue[i];
97         }
98     }
99 }
100 
SetTextPickerSelectedIndex(ArkUINodeHandle node,ArkUI_Uint32 * values,ArkUI_Int32 size)101 void SetTextPickerSelectedIndex(ArkUINodeHandle node, ArkUI_Uint32* values, ArkUI_Int32 size)
102 {
103     auto* frameNode = reinterpret_cast<FrameNode*>(node);
104     CHECK_NULL_VOID(frameNode);
105 
106     if (TextPickerModelNG::IsSingle(frameNode)) {
107         NodeModifier::SetSelectedIndexSingle(frameNode, values, size);
108     } else {
109         NodeModifier::SetSelectedIndexMulti(frameNode, values, size);
110     }
111 }
112 
ResetTextPickerSelectedIndex(ArkUINodeHandle node)113 void ResetTextPickerSelectedIndex(ArkUINodeHandle node)
114 {
115     auto* frameNode = reinterpret_cast<FrameNode*>(node);
116     CHECK_NULL_VOID(frameNode);
117     std::vector<uint32_t> selectedValues;
118     selectedValues.emplace_back(0);
119     if (TextPickerModelNG::IsSingle(frameNode)) {
120         NodeModifier::SetSelectedIndexSingle(frameNode, selectedValues.data(), selectedValues.size());
121     } else {
122         NodeModifier::SetSelectedIndexMulti(frameNode, selectedValues.data(), selectedValues.size());
123     }
124 }
125 
SetTextPickerTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style)126 void SetTextPickerTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo, ArkUI_Int32 style)
127 {
128     auto* frameNode = reinterpret_cast<FrameNode*>(node);
129     CHECK_NULL_VOID(frameNode);
130     auto pipeline = frameNode->GetContext();
131     CHECK_NULL_VOID(pipeline);
132     auto themeManager = pipeline->GetThemeManager();
133     CHECK_NULL_VOID(themeManager);
134     auto theme = themeManager->GetTheme<PickerTheme>();
135     CHECK_NULL_VOID(theme);
136 
137     NG::PickerTextStyle textStyle;
138     std::vector<std::string> res;
139     std::string fontValues = std::string(fontInfo);
140     StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
141     if (res.size() != NUM_3) {
142         return;
143     }
144     textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
145     if (style >= 0 && style < static_cast<int32_t>(FONT_STYLES.size())) {
146         textStyle.fontStyle = FONT_STYLES[style];
147     } else {
148         textStyle.fontStyle = FONT_STYLES[0];
149     }
150     textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
151     textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1]);
152     textStyle.textColor = Color(color);
153     TextPickerModelNG::SetNormalTextStyle(frameNode, theme, textStyle);
154 }
155 
ResetTextPickerTextStyle(ArkUINodeHandle node)156 void ResetTextPickerTextStyle(ArkUINodeHandle node)
157 {
158     auto* frameNode = reinterpret_cast<FrameNode*>(node);
159     CHECK_NULL_VOID(frameNode);
160     NG::PickerTextStyle pickerTextStyle;
161     auto context = frameNode->GetContext();
162     CHECK_NULL_VOID(context);
163     auto themeManager = context->GetThemeManager();
164     CHECK_NULL_VOID(themeManager);
165     auto pickerTheme = themeManager->GetTheme<PickerTheme>();
166     TextPickerModelNG::SetNormalTextStyle(frameNode, pickerTheme, pickerTextStyle);
167 }
168 
SetTextPickerSelectedTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style)169 void SetTextPickerSelectedTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo, ArkUI_Int32 style)
170 {
171     auto* frameNode = reinterpret_cast<FrameNode*>(node);
172     CHECK_NULL_VOID(frameNode);
173     auto pipeline = frameNode->GetContext();
174     CHECK_NULL_VOID(pipeline);
175     auto themeManager = pipeline->GetThemeManager();
176     CHECK_NULL_VOID(themeManager);
177     auto theme = themeManager->GetTheme<PickerTheme>();
178     CHECK_NULL_VOID(theme);
179 
180     NG::PickerTextStyle textStyle;
181     std::vector<std::string> res;
182     std::string fontValues = std::string(fontInfo);
183     StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
184     if (res.size() != NUM_3) {
185         return;
186     }
187     textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
188     if (style >= 0 && style < static_cast<int32_t>(FONT_STYLES.size())) {
189         textStyle.fontStyle = FONT_STYLES[style];
190     } else {
191         textStyle.fontStyle = FONT_STYLES[0];
192     }
193     textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
194     textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1]);
195     textStyle.textColor = Color(color);
196     TextPickerModelNG::SetSelectedTextStyle(frameNode, theme, textStyle);
197 }
198 
ResetTextPickerSelectedTextStyle(ArkUINodeHandle node)199 void ResetTextPickerSelectedTextStyle(ArkUINodeHandle node)
200 {
201     auto* frameNode = reinterpret_cast<FrameNode*>(node);
202     CHECK_NULL_VOID(frameNode);
203     NG::PickerTextStyle pickerTextStyle;
204     auto context = frameNode->GetContext();
205     CHECK_NULL_VOID(context);
206     auto themeManager = context->GetThemeManager();
207     CHECK_NULL_VOID(themeManager);
208     auto pickerTheme = themeManager->GetTheme<PickerTheme>();
209     TextPickerModelNG::SetSelectedTextStyle(frameNode, pickerTheme, pickerTextStyle);
210 }
211 
SetTextPickerDisappearTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style)212 void SetTextPickerDisappearTextStyle(
213     ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo, ArkUI_Int32 style)
214 {
215     auto* frameNode = reinterpret_cast<FrameNode*>(node);
216     CHECK_NULL_VOID(frameNode);
217     auto pipeline = frameNode->GetContext();
218     CHECK_NULL_VOID(pipeline);
219     auto themeManager = pipeline->GetThemeManager();
220     CHECK_NULL_VOID(themeManager);
221     auto theme = themeManager->GetTheme<PickerTheme>();
222     CHECK_NULL_VOID(theme);
223 
224     NG::PickerTextStyle textStyle;
225     std::vector<std::string> res;
226     std::string fontValues = std::string(fontInfo);
227     StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
228     if (res.size() != NUM_3) {
229         return;
230     }
231     textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
232     if (style >= 0 && style < static_cast<int32_t>(FONT_STYLES.size())) {
233         textStyle.fontStyle = FONT_STYLES[style];
234     } else {
235         textStyle.fontStyle = FONT_STYLES[0];
236     }
237     textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
238     textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1]);
239     textStyle.textColor = Color(color);
240     TextPickerModelNG::SetDisappearTextStyle(frameNode, theme, textStyle);
241 }
242 
ResetTextPickerDisappearTextStyle(ArkUINodeHandle node)243 void ResetTextPickerDisappearTextStyle(ArkUINodeHandle node)
244 {
245     auto* frameNode = reinterpret_cast<FrameNode*>(node);
246     CHECK_NULL_VOID(frameNode);
247     NG::PickerTextStyle pickerTextStyle;
248     auto context = frameNode->GetContext();
249     CHECK_NULL_VOID(context);
250     auto themeManager = context->GetThemeManager();
251     CHECK_NULL_VOID(themeManager);
252     auto pickerTheme = themeManager->GetTheme<PickerTheme>();
253     TextPickerModelNG::SetDisappearTextStyle(frameNode, pickerTheme, pickerTextStyle);
254 }
255 
GetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node,ArkUI_Int32 dUnit)256 ArkUI_Float32 GetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node, ArkUI_Int32 dUnit)
257 {
258     auto* frameNode = reinterpret_cast<FrameNode*>(node);
259     CHECK_NULL_RETURN(frameNode, -1.0f);
260     return TextPickerModelNG::GetDefaultPickerItemHeight(frameNode).GetNativeValue(static_cast<DimensionUnit>(dUnit));
261 }
262 
SetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node,float dVal,ArkUI_Int32 dUnit)263 void SetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node, float dVal, ArkUI_Int32 dUnit)
264 {
265     auto* frameNode = reinterpret_cast<FrameNode*>(node);
266     CHECK_NULL_VOID(frameNode);
267     TextPickerModelNG::SetDefaultPickerItemHeight(frameNode, Dimension(dVal, static_cast<DimensionUnit>(dUnit)));
268 }
269 
ResetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node)270 void ResetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node)
271 {
272     auto* frameNode = reinterpret_cast<FrameNode*>(node);
273     CHECK_NULL_VOID(frameNode);
274     auto height = Dimension(0.0);
275     TextPickerModelNG::SetDefaultPickerItemHeight(frameNode, height);
276 }
277 
GetTextPickerRangeStr(ArkUINodeHandle node)278 ArkUI_CharPtr GetTextPickerRangeStr(ArkUINodeHandle node)
279 {
280     auto* frameNode = reinterpret_cast<FrameNode*>(node);
281     CHECK_NULL_RETURN(frameNode, "");
282     g_strValue = TextPickerModelNG::getTextPickerRange(frameNode);
283     return g_strValue.c_str();
284 }
285 
GetTextPickerSingleRange(ArkUINodeHandle node)286 ArkUI_Int32 GetTextPickerSingleRange(ArkUINodeHandle node)
287 {
288     auto* frameNode = reinterpret_cast<FrameNode*>(node);
289     CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
290     return TextPickerModelNG::GetTextPickerRangeType(frameNode);
291 }
292 
SetTextPickerRangeStr(ArkUINodeHandle node,ArkUI_CharPtr rangeStr,ArkUI_Bool isSingleRange,ArkUI_Int32 rangeType)293 void SetTextPickerRangeStr(
294     ArkUINodeHandle node, ArkUI_CharPtr rangeStr, ArkUI_Bool isSingleRange, ArkUI_Int32 rangeType)
295 {
296     auto* frameNode = reinterpret_cast<FrameNode*>(node);
297     CHECK_NULL_VOID(frameNode);
298     TextPickerModelNG::SetTextPickerSingeRange(static_cast<bool>(isSingleRange));
299     std::vector<std::string> getRangeVector;
300     StringUtils::StringSplitter(std::string(rangeStr), ';', getRangeVector);
301     if (isSingleRange) {
302         std::vector<NG::RangeContent> result;
303         for (const auto& text : getRangeVector) {
304             NG::RangeContent content;
305             content.icon_ = "";
306             content.text_ = text;
307             result.emplace_back(content);
308         }
309         TextPickerModelNG::SetRange(frameNode, result);
310     } else {
311         std::vector<NG::TextCascadePickerOptions> multiResult;
312         for (const auto& text : getRangeVector) {
313             NG::TextCascadePickerOptions option;
314             StringUtils::StringSplitter(std::string(text), ',', option.rangeResult);
315             multiResult.emplace_back(option);
316         }
317         TextPickerModelNG::SetColumns(frameNode, multiResult);
318     }
319     TextPickerModelNG::SetTextPickerRangeType(frameNode, rangeType);
320 }
321 
GetTextPickerValue(ArkUINodeHandle node)322 ArkUI_CharPtr GetTextPickerValue(ArkUINodeHandle node)
323 {
324     auto* frameNode = reinterpret_cast<FrameNode*>(node);
325     CHECK_NULL_RETURN(frameNode, "");
326     if (TextPickerModelNG::IsSingle(frameNode)) {
327         g_strValue = TextPickerModelNG::getTextPickerValue(frameNode);
328     } else {
329         g_strValue = TextPickerModelNG::getTextPickerValues(frameNode);
330     }
331     return g_strValue.c_str();
332 }
333 
SetTextPickerValue(ArkUINodeHandle node,ArkUI_CharPtr valueStr)334 void SetTextPickerValue(ArkUINodeHandle node, ArkUI_CharPtr valueStr)
335 {
336     auto* frameNode = reinterpret_cast<FrameNode*>(node);
337     CHECK_NULL_VOID(frameNode);
338     std::vector<std::string> getValueVector;
339     StringUtils::StringSplitter(std::string(valueStr), ';', getValueVector);
340     if (TextPickerModelNG::GetTextPickerSingeRange()) {
341         TextPickerModelNG::SetValue(frameNode, valueStr);
342     } else {
343         TextPickerModelNG::SetValues(frameNode, getValueVector);
344     }
345 }
346 
GetTextPickerSelectedTextStyle(ArkUINodeHandle node)347 ArkUI_CharPtr GetTextPickerSelectedTextStyle(ArkUINodeHandle node)
348 {
349     auto* frameNode = reinterpret_cast<FrameNode*>(node);
350     CHECK_NULL_RETURN(frameNode, "");
351     PickerTextStyle pickerTextStyle = TextPickerModelNG::getSelectedTextStyle(frameNode);
352     std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
353     std::string families;
354     if (fontFamilies.size() == 0) {
355         fontFamilies.emplace_back("HarmonyOS Sans");
356     }
357     //set index start
358     int index = 0;
359     for (auto& family : fontFamilies) {
360         families += family;
361         if (index != static_cast<int>(fontFamilies.size()) - 1) {
362             families += ",";
363         }
364         index++;
365     }
366     g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
367     g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
368     g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
369     g_strValue = g_strValue + families + ";";
370     g_strValue =
371         g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
372     return g_strValue.c_str();
373 }
374 
GetTextPickerTextStyle(ArkUINodeHandle node)375 ArkUI_CharPtr GetTextPickerTextStyle(ArkUINodeHandle node)
376 {
377     auto* frameNode = reinterpret_cast<FrameNode*>(node);
378     CHECK_NULL_RETURN(frameNode, "");
379     PickerTextStyle pickerTextStyle = TextPickerModelNG::getNormalTextStyle(frameNode);
380     std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
381     std::string families;
382     if (fontFamilies.size() == 0) {
383         fontFamilies.emplace_back("HarmonyOS Sans");
384     }
385     //set index start
386     int index = 0;
387     for (auto& family : fontFamilies) {
388         families += family;
389         if (index != static_cast<int>(fontFamilies.size()) - 1) {
390             families += ",";
391         }
392         index++;
393     }
394     g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
395     g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
396     g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
397     g_strValue = g_strValue + families + ";";
398     g_strValue =
399         g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
400     return g_strValue.c_str();
401 }
402 
GetTextPickerDisappearTextStyle(ArkUINodeHandle node)403 ArkUI_CharPtr GetTextPickerDisappearTextStyle(ArkUINodeHandle node)
404 {
405     auto* frameNode = reinterpret_cast<FrameNode*>(node);
406     CHECK_NULL_RETURN(frameNode, "");
407     PickerTextStyle pickerTextStyle = TextPickerModelNG::getDisappearTextStyle(frameNode);
408     std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
409     std::string families;
410     if (fontFamilies.size() == 0) {
411         fontFamilies.emplace_back("HarmonyOS Sans");
412     }
413     //set index start
414     int index = 0;
415     for (auto& family : fontFamilies) {
416         families += family;
417         if (index != static_cast<int>(fontFamilies.size()) - 1) {
418             families += ",";
419         }
420         index++;
421     }
422     g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
423     g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
424     g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
425     g_strValue = g_strValue + families + ";";
426     g_strValue =
427         g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
428     return g_strValue.c_str();
429 }
430 
SetTextPickerDivider(ArkUINodeHandle node,ArkUI_Uint32 color,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length)431 void SetTextPickerDivider(
432     ArkUINodeHandle node, ArkUI_Uint32 color, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length)
433 {
434     auto* frameNode = reinterpret_cast<FrameNode*>(node);
435     CHECK_NULL_VOID(frameNode);
436 
437     if (length != DEFAULT_GROUP_DIVIDER_VALUES_COUNT) {
438         return;
439     }
440 
441     NG::ItemDivider divider;
442     divider.color = Color(color);
443     divider.strokeWidth = Dimension(values[POS_0], static_cast<OHOS::Ace::DimensionUnit>(units[POS_0]));
444     divider.startMargin = Dimension(values[POS_1], static_cast<OHOS::Ace::DimensionUnit>(units[POS_1]));
445     divider.endMargin = Dimension(values[POS_2], static_cast<OHOS::Ace::DimensionUnit>(units[POS_2]));
446 
447     TextPickerModelNG::SetDivider(frameNode, divider);
448 }
449 
ResetTextPickerDivider(ArkUINodeHandle node)450 void ResetTextPickerDivider(ArkUINodeHandle node)
451 {
452     auto* frameNode = reinterpret_cast<FrameNode*>(node);
453     CHECK_NULL_VOID(frameNode);
454     NG::ItemDivider divider;
455     TextPickerModelNG::SetDivider(frameNode, divider);
456 }
457 
SetTextPickerGradientHeight(ArkUINodeHandle node,ArkUI_Float32 dVal,ArkUI_Int32 dUnit)458 void SetTextPickerGradientHeight(ArkUINodeHandle node, ArkUI_Float32 dVal, ArkUI_Int32 dUnit)
459 {
460     auto* frameNode = reinterpret_cast<FrameNode*>(node);
461     CHECK_NULL_VOID(frameNode);
462     TextPickerModelNG::SetGradientHeight(frameNode, Dimension(dVal, static_cast<DimensionUnit>(dUnit)));
463 }
464 
ResetTextPickerGradientHeight(ArkUINodeHandle node)465 void ResetTextPickerGradientHeight(ArkUINodeHandle node)
466 {
467     auto* frameNode = reinterpret_cast<FrameNode*>(node);
468     CHECK_NULL_VOID(frameNode);
469 
470     auto pipeline = frameNode->GetContext();
471     CHECK_NULL_VOID(pipeline);
472     auto themeManager = pipeline->GetThemeManager();
473     CHECK_NULL_VOID(themeManager);
474     auto pickerTheme = themeManager->GetTheme<PickerTheme>();
475     CHECK_NULL_VOID(pickerTheme);
476 
477     CalcDimension height;
478     if (pickerTheme) {
479         height = pickerTheme->GetGradientHeight();
480     } else {
481         height = 0.0_vp;
482     }
483 
484     TextPickerModelNG::SetGradientHeight(frameNode, height);
485 }
486 
GetTextPickerSelectedSize(ArkUINodeHandle node)487 ArkUI_Int32 GetTextPickerSelectedSize(ArkUINodeHandle node)
488 {
489     auto* frameNode = reinterpret_cast<FrameNode*>(node);
490     CHECK_NULL_RETURN(frameNode, 0);
491     if (TextPickerModelNG::IsSingle(frameNode)) {
492         return 1;
493     }
494     return TextPickerModelNG::GetSelectedSize(frameNode);
495 }
496 
497 } // namespace
498 
499 namespace NodeModifier {
GetTextPickerModifier()500 const ArkUITextPickerModifier* GetTextPickerModifier()
501 {
502     static const ArkUITextPickerModifier modifier = { SetTextPickerBackgroundColor, SetTextPickerCanLoop,
503         GetTextPickerSelectedIndex, SetTextPickerSelectedIndex, GetTextPickerTextStyle, SetTextPickerTextStyle,
504         GetTextPickerSelectedTextStyle, SetTextPickerSelectedTextStyle, GetTextPickerDisappearTextStyle,
505         SetTextPickerDisappearTextStyle, SetTextPickerDefaultPickerItemHeight, ResetTextPickerCanLoop,
506         ResetTextPickerSelectedIndex, ResetTextPickerTextStyle, ResetTextPickerSelectedTextStyle,
507         ResetTextPickerDisappearTextStyle, ResetTextPickerDefaultPickerItemHeight, ResetTextPickerBackgroundColor,
508         GetTextPickerRangeStr, GetTextPickerSingleRange, SetTextPickerRangeStr, GetTextPickerValue, SetTextPickerValue,
509         SetTextPickerDivider, ResetTextPickerDivider, SetTextPickerGradientHeight, ResetTextPickerGradientHeight,
510         GetTextPickerSelectedSize, GetTextPickerCanLoop, GetTextPickerDefaultPickerItemHeight };
511 
512     return &modifier;
513 }
514 
GetCJUITextPickerModifier()515 const CJUITextPickerModifier* GetCJUITextPickerModifier()
516 {
517     static const CJUITextPickerModifier modifier = { SetTextPickerBackgroundColor, SetTextPickerCanLoop,
518         GetTextPickerSelectedIndex, SetTextPickerSelectedIndex, GetTextPickerTextStyle, SetTextPickerTextStyle,
519         GetTextPickerSelectedTextStyle, SetTextPickerSelectedTextStyle, GetTextPickerDisappearTextStyle,
520         SetTextPickerDisappearTextStyle, SetTextPickerDefaultPickerItemHeight, ResetTextPickerCanLoop,
521         ResetTextPickerSelectedIndex, ResetTextPickerTextStyle, ResetTextPickerSelectedTextStyle,
522         ResetTextPickerDisappearTextStyle, ResetTextPickerDefaultPickerItemHeight, ResetTextPickerBackgroundColor,
523         GetTextPickerRangeStr, GetTextPickerSingleRange, SetTextPickerRangeStr, GetTextPickerValue, SetTextPickerValue,
524         SetTextPickerDivider, ResetTextPickerDivider, SetTextPickerGradientHeight, ResetTextPickerGradientHeight,
525         GetTextPickerSelectedSize, GetTextPickerCanLoop, GetTextPickerDefaultPickerItemHeight };
526 
527     return &modifier;
528 }
529 
GetPickerTextStyle(uint32_t color,ArkUI_CharPtr fontInfo,int32_t styleVal,NG::PickerTextStyle & textStyle)530 void GetPickerTextStyle(uint32_t color, ArkUI_CharPtr fontInfo, int32_t styleVal, NG::PickerTextStyle& textStyle)
531 {
532     textStyle.textColor = Color(color);
533 
534     std::vector<std::string> res;
535     std::string fontValues = std::string(fontInfo);
536     StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
537 
538     if (res.size() != SIZE_OF_THREE) {
539         return;
540     }
541 
542     if (res[POS_0] != "-1") {
543         textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
544     } else {
545         textStyle.fontSize = Dimension(-1);
546     }
547 
548     if (res[POS_1] != "-1") {
549         textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1], FontWeight::NORMAL);
550     }
551 
552     if (res[POS_2] != "-1") {
553         textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
554     }
555     textStyle.fontStyle = static_cast<Ace::FontStyle>(styleVal);
556 }
557 
SetSelectedIndexSingle(FrameNode * frameNode,uint32_t * selectedValues,const int32_t size)558 void SetSelectedIndexSingle(FrameNode* frameNode, uint32_t* selectedValues, const int32_t size)
559 {
560     std::vector<NG::RangeContent> rangeResult;
561     TextPickerModelNG::GetSingleRange(frameNode, rangeResult);
562     if (selectedValues[0] >= rangeResult.size()) {
563         TextPickerModelNG::SetSelected(frameNode, 0);
564     } else {
565         TextPickerModelNG::SetSelected(frameNode, selectedValues[0]);
566     }
567 }
568 
SetSelectedIndexMultiInternal(FrameNode * frameNode,uint32_t count,std::vector<NG::TextCascadePickerOptions> & options,std::vector<uint32_t> & selectedValues)569 void SetSelectedIndexMultiInternal(FrameNode* frameNode, uint32_t count,
570     std::vector<NG::TextCascadePickerOptions>& options, std::vector<uint32_t>& selectedValues)
571 {
572     if (!TextPickerModelNG::IsCascade(frameNode)) {
573         NodeModifier::SetSelectedInternal(count, options, selectedValues);
574     } else {
575         TextPickerModelNG::SetHasSelectAttr(frameNode, true);
576         NodeModifier::ProcessCascadeSelected(options, 0, selectedValues);
577         uint32_t maxCount = TextPickerModelNG::GetMaxCount(frameNode);
578         if (selectedValues.size() < maxCount) {
579             auto differ = maxCount - selectedValues.size();
580             for (uint32_t i = 0; i < differ; i++) {
581                 selectedValues.emplace_back(0);
582             }
583         }
584     }
585 }
586 
SetSelectedIndexSingleInternal(const std::vector<NG::TextCascadePickerOptions> & options,uint32_t count,uint32_t & selectedValue,std::vector<uint32_t> & selectedValues)587 void SetSelectedIndexSingleInternal(const std::vector<NG::TextCascadePickerOptions>& options, uint32_t count,
588     uint32_t& selectedValue, std::vector<uint32_t>& selectedValues)
589 {
590     if (options.size() > 0) {
591         if (selectedValue >= options[0].rangeResult.size()) {
592             selectedValue = 0;
593         }
594         selectedValues.emplace_back(selectedValue);
595         for (uint32_t i = 1; i < count; i++) {
596             selectedValues.emplace_back(0);
597         }
598     } else {
599         for (uint32_t i = 0; i < count; i++) {
600             selectedValues.emplace_back(0);
601         }
602     }
603 }
604 
SetSelectedInternal(uint32_t count,std::vector<NG::TextCascadePickerOptions> & options,std::vector<uint32_t> & selectedValues)605 void SetSelectedInternal(
606     uint32_t count, std::vector<NG::TextCascadePickerOptions>& options, std::vector<uint32_t>& selectedValues)
607 {
608     for (uint32_t i = 0; i < count; i++) {
609         uint32_t val = selectedValues.size() > 0 ? selectedValues.size() - 1 : 0;
610         if (i > val) {
611             selectedValues.emplace_back(0);
612         } else {
613             if (selectedValues[i] >= options[i].rangeResult.size()) {
614                 selectedValues[i] = 0;
615             }
616         }
617     }
618 }
619 
SetSelectedIndexMulti(FrameNode * frameNode,uint32_t * inputs,const int32_t size)620 void SetSelectedIndexMulti(FrameNode* frameNode, uint32_t* inputs, const int32_t size)
621 {
622     std::vector<NG::TextCascadePickerOptions> options;
623     TextPickerModelNG::GetMultiOptions(frameNode, options);
624 
625     auto count = TextPickerModelNG::IsCascade(frameNode) ? TextPickerModelNG::GetMaxCount(frameNode) : options.size();
626     std::vector<uint32_t> selectedValues;
627 
628     if (size >= 0) {
629         selectedValues.assign(inputs, inputs + size);
630         SetSelectedIndexMultiInternal(frameNode, count, options, selectedValues);
631     } else {
632         TextPickerModelNG::SetHasSelectAttr(frameNode, true);
633         SetSelectedIndexSingleInternal(options, count, inputs[0], selectedValues);
634     }
635     TextPickerModelNG::SetSelecteds(frameNode, selectedValues);
636 }
637 
ProcessCascadeSelected(const std::vector<NG::TextCascadePickerOptions> & options,uint32_t index,std::vector<uint32_t> & selectedValues)638 void ProcessCascadeSelected(
639     const std::vector<NG::TextCascadePickerOptions>& options, uint32_t index, std::vector<uint32_t>& selectedValues)
640 {
641     const size_t size = options.size();
642     if (size == 0) {
643         return;
644     }
645     std::vector<std::string> rangeResultValue;
646     for (size_t i = 0; i < size; i++) {
647         rangeResultValue.emplace_back(options[i].rangeResult[0]);
648     }
649     uint32_t val = selectedValues.size() > 0 ? selectedValues.size() - 1 : 0;
650     if (index > val) {
651         selectedValues.emplace_back(0);
652     }
653     if (selectedValues[index] >= rangeResultValue.size()) {
654         selectedValues[index] = 0;
655     }
656     if ((selectedValues[index] <= size - 1) && (options[selectedValues[index]].children.size() > 0)) {
657         ProcessCascadeSelected(options[selectedValues[index]].children, index + 1, selectedValues);
658     }
659 }
660 
SetTextPickerOnChange(ArkUINodeHandle node,void * extraParam)661 void SetTextPickerOnChange(ArkUINodeHandle node, void* extraParam)
662 {
663     auto* frameNode = reinterpret_cast<FrameNode*>(node);
664     CHECK_NULL_VOID(frameNode);
665     auto onChangeEvent = [node, extraParam](
666                              const std::vector<std::string>& value, const std::vector<double>& indexVector) {
667         ArkUINodeEvent event;
668         event.kind = COMPONENT_ASYNC_EVENT;
669         event.extraParam = reinterpret_cast<intptr_t>(extraParam);
670         event.componentAsyncEvent.subKind = ON_TEXT_PICKER_CHANGE;
671         for (size_t i = 0; i < indexVector.size() && i < MAX_SIZE; i++) {
672             event.componentAsyncEvent.data[i].i32 = static_cast<int32_t>(indexVector[i]);
673         }
674         SendArkUIAsyncEvent(&event);
675     };
676     TextPickerModelNG::SetOnCascadeChange(frameNode, std::move(onChangeEvent));
677 }
678 
SetTextPickerOnScrollStop(ArkUINodeHandle node,void * extraParam)679 void SetTextPickerOnScrollStop(ArkUINodeHandle node, void* extraParam)
680 {
681     auto* frameNode = reinterpret_cast<FrameNode*>(node);
682     CHECK_NULL_VOID(frameNode);
683     auto onScrollStopEvent = [node, extraParam](
684                              const std::vector<std::string>& value, const std::vector<double>& indexVector) {
685         ArkUINodeEvent event;
686         event.kind = COMPONENT_ASYNC_EVENT;
687         event.extraParam = reinterpret_cast<intptr_t>(extraParam);
688         event.componentAsyncEvent.subKind = ON_TEXT_PICKER_SCROLL_STOP;
689         for (size_t i = 0; i < indexVector.size() && i < MAX_SIZE; i++) {
690             event.componentAsyncEvent.data[i].i32 = static_cast<int32_t>(indexVector[i]);
691         }
692         SendArkUIAsyncEvent(&event);
693     };
694     TextPickerModelNG::SetOnScrollStop(frameNode, std::move(onScrollStopEvent));
695 }
696 } // namespace NodeModifier
697 } // namespace OHOS::Ace::NG
698