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
23 namespace OHOS::Ace::NG {
24 namespace {
25 constexpr int32_t SIZE_OF_THREE = 3;
26 constexpr int32_t POS_0 = 0;
27 constexpr int32_t POS_1 = 1;
28 constexpr int32_t POS_2 = 2;
29 constexpr int NUM_3 = 3;
30 constexpr int32_t DEFAULT_GROUP_DIVIDER_VALUES_COUNT = 3;
31 const char DEFAULT_DELIMITER = '|';
32 const int32_t ERROR_INT_CODE = -1;
33 constexpr uint32_t MAX_SIZE = 12;
34 constexpr float MAX_PERCENT = 100.0f;
35 constexpr bool DEFAULT_ENABLE_HAPTIC_FEEDBACK = true;
36 thread_local std::string g_strValue;
37 const std::vector<OHOS::Ace::FontStyle> FONT_STYLES = { OHOS::Ace::FontStyle::NORMAL, OHOS::Ace::FontStyle::ITALIC };
38 const std::vector<TextOverflow> TEXT_OVERFLOWS = { TextOverflow::NONE, TextOverflow::CLIP, TextOverflow::ELLIPSIS,
39 TextOverflow::MARQUEE };
40
SetTextPickerBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)41 void SetTextPickerBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
42 {
43 auto* frameNode = reinterpret_cast<FrameNode*>(node);
44 CHECK_NULL_VOID(frameNode);
45 TextPickerModelNG::SetBackgroundColor(frameNode, Color(color));
46 }
47
ResetTextPickerBackgroundColor(ArkUINodeHandle node)48 void ResetTextPickerBackgroundColor(ArkUINodeHandle node)
49 {
50 auto* frameNode = reinterpret_cast<FrameNode*>(node);
51 CHECK_NULL_VOID(frameNode);
52 auto pipeline = frameNode->GetContext();
53 CHECK_NULL_VOID(pipeline);
54 auto theme = pipeline->GetTheme<DialogTheme>();
55 CHECK_NULL_VOID(theme);
56 TextPickerModelNG::SetBackgroundColor(frameNode, theme->GetBackgroundColor());
57 }
58
GetTextPickerCanLoop(ArkUINodeHandle node)59 ArkUI_Int32 GetTextPickerCanLoop(ArkUINodeHandle node)
60 {
61 auto* frameNode = reinterpret_cast<FrameNode*>(node);
62 CHECK_NULL_RETURN(frameNode, 1);
63 return TextPickerModelNG::GetCanLoop(frameNode);
64 }
65
SetTextPickerCanLoop(ArkUINodeHandle node,int canLoop)66 void SetTextPickerCanLoop(ArkUINodeHandle node, int canLoop)
67 {
68 auto* frameNode = reinterpret_cast<FrameNode*>(node);
69 CHECK_NULL_VOID(frameNode);
70 TextPickerModelNG::SetCanLoop(frameNode, canLoop);
71 }
72
ResetTextPickerCanLoop(ArkUINodeHandle node)73 void ResetTextPickerCanLoop(ArkUINodeHandle node)
74 {
75 auto* frameNode = reinterpret_cast<FrameNode*>(node);
76 CHECK_NULL_VOID(frameNode);
77 auto context = frameNode->GetContext();
78 CHECK_NULL_VOID(context);
79 auto themeManager = context->GetThemeManager();
80 CHECK_NULL_VOID(themeManager);
81 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
82 TextPickerModelNG::SetCanLoop(frameNode, true);
83 }
84
SetTextPickerDigitalCrownSensitivity(ArkUINodeHandle node,int32_t CrownSensitivity)85 void SetTextPickerDigitalCrownSensitivity(ArkUINodeHandle node, int32_t CrownSensitivity)
86 {
87 auto* frameNode = reinterpret_cast<FrameNode*>(node);
88 CHECK_NULL_VOID(frameNode);
89 TextPickerModelNG::SetDigitalCrownSensitivity(frameNode, CrownSensitivity);
90 }
91
ResetTextPickerDigitalCrownSensitivity(ArkUINodeHandle node)92 void ResetTextPickerDigitalCrownSensitivity(ArkUINodeHandle node)
93 {
94 auto* frameNode = reinterpret_cast<FrameNode*>(node);
95 CHECK_NULL_VOID(frameNode);
96 TextPickerModelNG::SetDigitalCrownSensitivity(frameNode, DEFAULT_CROWNSENSITIVITY);
97 }
98
GetTextPickerSelectedIndex(ArkUINodeHandle node,ArkUI_Uint32 * values,ArkUI_Int32 size)99 void GetTextPickerSelectedIndex(ArkUINodeHandle node, ArkUI_Uint32* values, ArkUI_Int32 size)
100 {
101 auto* frameNode = reinterpret_cast<FrameNode*>(node);
102 CHECK_NULL_VOID(frameNode);
103 if (TextPickerModelNG::IsSingle(frameNode)) {
104 auto selectedValue = static_cast<ArkUI_Uint32>(TextPickerModelNG::getTextPickerSelectedIndex(frameNode));
105 values[0] = selectedValue;
106 } else {
107 auto selectedValue = TextPickerModelNG::getTextPickerSelecteds(frameNode);
108 if (static_cast<ArkUI_Uint32>(size) != selectedValue.size()) {
109 return;
110 }
111 for (int i = 0; i < size; i++) {
112 values[i] = selectedValue[i];
113 }
114 }
115 }
116
SetTextPickerSelectedIndex(ArkUINodeHandle node,ArkUI_Uint32 * values,ArkUI_Int32 size)117 void SetTextPickerSelectedIndex(ArkUINodeHandle node, ArkUI_Uint32* values, ArkUI_Int32 size)
118 {
119 auto* frameNode = reinterpret_cast<FrameNode*>(node);
120 CHECK_NULL_VOID(frameNode);
121
122 if (TextPickerModelNG::IsSingle(frameNode)) {
123 NodeModifier::SetSelectedIndexSingle(frameNode, values, size);
124 } else {
125 NodeModifier::SetSelectedIndexMulti(frameNode, values, size);
126 }
127 }
128
ResetTextPickerSelectedIndex(ArkUINodeHandle node)129 void ResetTextPickerSelectedIndex(ArkUINodeHandle node)
130 {
131 auto* frameNode = reinterpret_cast<FrameNode*>(node);
132 CHECK_NULL_VOID(frameNode);
133 std::vector<uint32_t> selectedValues;
134 selectedValues.emplace_back(0);
135 if (TextPickerModelNG::IsSingle(frameNode)) {
136 NodeModifier::SetSelectedIndexSingle(frameNode, selectedValues.data(), selectedValues.size());
137 } else {
138 NodeModifier::SetSelectedIndexMulti(frameNode, selectedValues.data(), selectedValues.size());
139 }
140 }
141
SetTextPickerTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style)142 void SetTextPickerTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo, ArkUI_Int32 style)
143 {
144 auto* frameNode = reinterpret_cast<FrameNode*>(node);
145 CHECK_NULL_VOID(frameNode);
146 auto pipeline = frameNode->GetContext();
147 CHECK_NULL_VOID(pipeline);
148 auto themeManager = pipeline->GetThemeManager();
149 CHECK_NULL_VOID(themeManager);
150 auto theme = themeManager->GetTheme<PickerTheme>();
151 CHECK_NULL_VOID(theme);
152
153 NG::PickerTextStyle textStyle;
154 std::vector<std::string> res;
155 std::string fontValues = std::string(fontInfo);
156 StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
157 if (res.size() != NUM_3) {
158 return;
159 }
160 textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
161 if (style >= 0 && style < static_cast<int32_t>(FONT_STYLES.size())) {
162 textStyle.fontStyle = FONT_STYLES[style];
163 } else {
164 textStyle.fontStyle = FONT_STYLES[0];
165 }
166 textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
167 textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1]);
168 textStyle.textColor = Color(color);
169 TextPickerModelNG::SetNormalTextStyle(frameNode, theme, textStyle);
170 }
171
ResetTextPickerTextStyle(ArkUINodeHandle node)172 void ResetTextPickerTextStyle(ArkUINodeHandle node)
173 {
174 auto* frameNode = reinterpret_cast<FrameNode*>(node);
175 CHECK_NULL_VOID(frameNode);
176 NG::PickerTextStyle pickerTextStyle;
177 auto context = frameNode->GetContext();
178 CHECK_NULL_VOID(context);
179 auto themeManager = context->GetThemeManager();
180 CHECK_NULL_VOID(themeManager);
181 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
182 TextPickerModelNG::SetNormalTextStyle(frameNode, pickerTheme, pickerTextStyle);
183 }
184
SetTextPickerSelectedTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style)185 void SetTextPickerSelectedTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo, ArkUI_Int32 style)
186 {
187 auto* frameNode = reinterpret_cast<FrameNode*>(node);
188 CHECK_NULL_VOID(frameNode);
189 auto pipeline = frameNode->GetContext();
190 CHECK_NULL_VOID(pipeline);
191 auto themeManager = pipeline->GetThemeManager();
192 CHECK_NULL_VOID(themeManager);
193 auto theme = themeManager->GetTheme<PickerTheme>();
194 CHECK_NULL_VOID(theme);
195
196 NG::PickerTextStyle textStyle;
197 std::vector<std::string> res;
198 std::string fontValues = std::string(fontInfo);
199 StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
200 if (res.size() != NUM_3) {
201 return;
202 }
203 textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
204 if (style >= 0 && style < static_cast<int32_t>(FONT_STYLES.size())) {
205 textStyle.fontStyle = FONT_STYLES[style];
206 } else {
207 textStyle.fontStyle = FONT_STYLES[0];
208 }
209 textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
210 textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1]);
211 textStyle.textColor = Color(color);
212 TextPickerModelNG::SetSelectedTextStyle(frameNode, theme, textStyle);
213 }
214
ResetTextPickerSelectedTextStyle(ArkUINodeHandle node)215 void ResetTextPickerSelectedTextStyle(ArkUINodeHandle node)
216 {
217 auto* frameNode = reinterpret_cast<FrameNode*>(node);
218 CHECK_NULL_VOID(frameNode);
219 NG::PickerTextStyle pickerTextStyle;
220 auto context = frameNode->GetContext();
221 CHECK_NULL_VOID(context);
222 auto themeManager = context->GetThemeManager();
223 CHECK_NULL_VOID(themeManager);
224 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
225 TextPickerModelNG::SetSelectedTextStyle(frameNode, pickerTheme, pickerTextStyle);
226 }
227
SetTextPickerDisappearTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style)228 void SetTextPickerDisappearTextStyle(
229 ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo, ArkUI_Int32 style)
230 {
231 auto* frameNode = reinterpret_cast<FrameNode*>(node);
232 CHECK_NULL_VOID(frameNode);
233 auto pipeline = frameNode->GetContext();
234 CHECK_NULL_VOID(pipeline);
235 auto themeManager = pipeline->GetThemeManager();
236 CHECK_NULL_VOID(themeManager);
237 auto theme = themeManager->GetTheme<PickerTheme>();
238 CHECK_NULL_VOID(theme);
239
240 NG::PickerTextStyle textStyle;
241 std::vector<std::string> res;
242 std::string fontValues = std::string(fontInfo);
243 StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
244 if (res.size() != NUM_3) {
245 return;
246 }
247 textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
248 if (style >= 0 && style < static_cast<int32_t>(FONT_STYLES.size())) {
249 textStyle.fontStyle = FONT_STYLES[style];
250 } else {
251 textStyle.fontStyle = FONT_STYLES[0];
252 }
253 textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
254 textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1]);
255 textStyle.textColor = Color(color);
256 TextPickerModelNG::SetDisappearTextStyle(frameNode, theme, textStyle);
257 }
258
ResetTextPickerDisappearTextStyle(ArkUINodeHandle node)259 void ResetTextPickerDisappearTextStyle(ArkUINodeHandle node)
260 {
261 auto* frameNode = reinterpret_cast<FrameNode*>(node);
262 CHECK_NULL_VOID(frameNode);
263 NG::PickerTextStyle pickerTextStyle;
264 auto context = frameNode->GetContext();
265 CHECK_NULL_VOID(context);
266 auto themeManager = context->GetThemeManager();
267 CHECK_NULL_VOID(themeManager);
268 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
269 TextPickerModelNG::SetDisappearTextStyle(frameNode, pickerTheme, pickerTextStyle);
270 }
271
GetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node,ArkUI_Int32 dUnit)272 ArkUI_Float32 GetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node, ArkUI_Int32 dUnit)
273 {
274 auto* frameNode = reinterpret_cast<FrameNode*>(node);
275 CHECK_NULL_RETURN(frameNode, -1.0f);
276 return TextPickerModelNG::GetDefaultPickerItemHeight(frameNode).GetNativeValue(static_cast<DimensionUnit>(dUnit));
277 }
278
SetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node,float dVal,ArkUI_Int32 dUnit)279 void SetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node, float dVal, ArkUI_Int32 dUnit)
280 {
281 auto* frameNode = reinterpret_cast<FrameNode*>(node);
282 CHECK_NULL_VOID(frameNode);
283 TextPickerModelNG::SetDefaultPickerItemHeight(frameNode, Dimension(dVal, static_cast<DimensionUnit>(dUnit)));
284 }
285
ResetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node)286 void ResetTextPickerDefaultPickerItemHeight(ArkUINodeHandle node)
287 {
288 auto* frameNode = reinterpret_cast<FrameNode*>(node);
289 CHECK_NULL_VOID(frameNode);
290 auto height = Dimension(0.0);
291 TextPickerModelNG::SetDefaultPickerItemHeight(frameNode, height);
292 }
293
GetTextPickerRangeStr(ArkUINodeHandle node)294 ArkUI_CharPtr GetTextPickerRangeStr(ArkUINodeHandle node)
295 {
296 auto* frameNode = reinterpret_cast<FrameNode*>(node);
297 CHECK_NULL_RETURN(frameNode, "");
298 g_strValue = TextPickerModelNG::getTextPickerRange(frameNode);
299 return g_strValue.c_str();
300 }
301
GetTextPickerSingleRange(ArkUINodeHandle node)302 ArkUI_Int32 GetTextPickerSingleRange(ArkUINodeHandle node)
303 {
304 auto* frameNode = reinterpret_cast<FrameNode*>(node);
305 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
306 return TextPickerModelNG::GetTextPickerRangeType(frameNode);
307 }
308
SetTextCascadePickChildrenRangeContent(std::vector<NG::TextCascadePickerOptions> & multiResult,ArkUITextCascadePickerRangeContentArray arry)309 void SetTextCascadePickChildrenRangeContent(
310 std::vector<NG::TextCascadePickerOptions>& multiResult, ArkUITextCascadePickerRangeContentArray arry)
311 {
312 for (int index = 0; index < arry->rangeContentArraySize; index++) {
313 NG::TextCascadePickerOptions option;
314 if (arry[index].text == nullptr) {
315 continue;
316 }
317 option.rangeResult.push_back(arry[index].text);
318
319 if (arry[index].children != nullptr) {
320 SetTextCascadePickChildrenRangeContent(option.children, arry[index].children);
321 }
322 multiResult.push_back(option);
323 }
324 }
325
SetTextCascadePickRangeContent(ArkUINodeHandle node,ArkUITextCascadePickerRangeContentArray arry,ArkUI_Int32 rangeType)326 void SetTextCascadePickRangeContent(
327 ArkUINodeHandle node, ArkUITextCascadePickerRangeContentArray arry, ArkUI_Int32 rangeType)
328 {
329 auto* frameNode = reinterpret_cast<FrameNode*>(node);
330 CHECK_NULL_VOID(frameNode);
331 std::vector<NG::TextCascadePickerOptions> multiResult;
332
333 SetTextCascadePickChildrenRangeContent(multiResult, arry);
334 TextPickerModelNG::SetHasSelectAttr(frameNode, true);
335 TextPickerModelNG::SetIsCascade(frameNode, true);
336 TextPickerModelNG::SetColumns(frameNode, multiResult);
337
338 std::vector<std::string> values;
339 for (int index = 0; index < arry->rangeContentArraySize; index++) {
340 if (arry[index].text == nullptr) {
341 continue;
342 }
343 values.emplace_back(arry[index].text);
344 }
345 TextPickerModelNG::SetValues(frameNode, values);
346 TextPickerModelNG::SetTextPickerRangeType(frameNode, rangeType);
347 }
348
SetTextPickerIconRangeStr(ArkUINodeHandle node,ArkUITextPickerRangeContentArray arry,ArkUI_Bool isSingleRange,ArkUI_Int32 rangeType)349 void SetTextPickerIconRangeStr(
350 ArkUINodeHandle node, ArkUITextPickerRangeContentArray arry, ArkUI_Bool isSingleRange, ArkUI_Int32 rangeType)
351 {
352 auto* frameNode = reinterpret_cast<FrameNode*>(node);
353 CHECK_NULL_VOID(frameNode);
354 TextPickerModelNG::SetTextPickerSingeRange(static_cast<bool>(isSingleRange));
355 std::vector<NG::RangeContent> result;
356 for (int i = 0; i < arry->rangeContentArraySize; i++) {
357 NG::RangeContent content;
358 if (arry->rangeContent[i].text != nullptr) {
359 content.text_ = arry->rangeContent[i].text;
360 }
361 if (arry->rangeContent[i].icon != nullptr) {
362 content.icon_ = arry->rangeContent[i].icon;
363 }
364 result.emplace_back(content);
365 }
366 TextPickerModelNG::SetColumnKind(frameNode, MIXTURE);
367 TextPickerModelNG::SetRange(frameNode, result);
368 TextPickerModelNG::SetTextPickerRangeType(frameNode, rangeType);
369 }
370
SetTextPickerRangeStr(ArkUINodeHandle node,ArkUI_CharPtr rangeStr,ArkUI_Bool isSingleRange,ArkUI_Int32 rangeType)371 void SetTextPickerRangeStr(
372 ArkUINodeHandle node, ArkUI_CharPtr rangeStr, ArkUI_Bool isSingleRange, ArkUI_Int32 rangeType)
373 {
374 auto* frameNode = reinterpret_cast<FrameNode*>(node);
375 CHECK_NULL_VOID(frameNode);
376 TextPickerModelNG::SetTextPickerSingeRange(static_cast<bool>(isSingleRange));
377 std::vector<std::string> getRangeVector;
378 StringUtils::StringSplitter(std::string(rangeStr), ';', getRangeVector);
379 if (isSingleRange) {
380 std::vector<NG::RangeContent> result;
381 for (const auto& text : getRangeVector) {
382 NG::RangeContent content;
383 content.icon_ = "";
384 content.text_ = text;
385 result.emplace_back(content);
386 }
387 TextPickerModelNG::SetColumnKind(frameNode, TEXT);
388 TextPickerModelNG::SetRange(frameNode, result);
389 } else {
390 std::vector<NG::TextCascadePickerOptions> multiResult;
391 for (const auto& text : getRangeVector) {
392 NG::TextCascadePickerOptions option;
393 StringUtils::StringSplitter(std::string(text), ',', option.rangeResult);
394 multiResult.emplace_back(option);
395 }
396 TextPickerModelNG::SetColumns(frameNode, multiResult);
397 }
398 TextPickerModelNG::SetTextPickerRangeType(frameNode, rangeType);
399 }
400
GetTextPickerValue(ArkUINodeHandle node)401 ArkUI_CharPtr GetTextPickerValue(ArkUINodeHandle node)
402 {
403 auto* frameNode = reinterpret_cast<FrameNode*>(node);
404 CHECK_NULL_RETURN(frameNode, "");
405 if (TextPickerModelNG::IsSingle(frameNode)) {
406 g_strValue = TextPickerModelNG::getTextPickerValue(frameNode);
407 } else {
408 g_strValue = TextPickerModelNG::getTextPickerValues(frameNode);
409 }
410 return g_strValue.c_str();
411 }
412
SetTextPickerValue(ArkUINodeHandle node,ArkUI_CharPtr valueStr)413 void SetTextPickerValue(ArkUINodeHandle node, ArkUI_CharPtr valueStr)
414 {
415 auto* frameNode = reinterpret_cast<FrameNode*>(node);
416 CHECK_NULL_VOID(frameNode);
417 std::vector<std::string> getValueVector;
418 StringUtils::StringSplitter(std::string(valueStr), ';', getValueVector);
419 if (TextPickerModelNG::GetTextPickerSingeRange()) {
420 TextPickerModelNG::SetValue(frameNode, valueStr);
421 } else {
422 TextPickerModelNG::SetValues(frameNode, getValueVector);
423 }
424 }
425
SetTextPickerColumnWidths(ArkUINodeHandle node,ArkUI_Float32 * values,ArkUI_Int32 size)426 void SetTextPickerColumnWidths(ArkUINodeHandle node, ArkUI_Float32* values, ArkUI_Int32 size)
427 {
428 std::vector<Dimension> widths;
429 auto* frameNode = reinterpret_cast<FrameNode*>(node);
430 CHECK_NULL_VOID(frameNode);
431 for (ArkUI_Int32 i = 0; i < size; i++) {
432 widths.emplace_back(Dimension(values[i] * MAX_PERCENT, DimensionUnit::PERCENT));
433 }
434 TextPickerModelNG::SetColumnWidths(frameNode, widths);
435 }
436
ResetTextPickerColumnWidths(ArkUINodeHandle node)437 void ResetTextPickerColumnWidths(ArkUINodeHandle node)
438 {
439 std::vector<Dimension> widths;
440 auto* frameNode = reinterpret_cast<FrameNode*>(node);
441 CHECK_NULL_VOID(frameNode);
442 auto childCount = frameNode->GetChildren().size();
443 for (size_t i = 0; i < childCount; i++) {
444 widths.emplace_back(Dimension(MAX_PERCENT / static_cast<float>(childCount), DimensionUnit::PERCENT));
445 }
446 TextPickerModelNG::SetColumnWidths(frameNode, widths);
447 }
448
GetTextPickerColumnWidthsSize(ArkUINodeHandle node)449 ArkUI_Int32 GetTextPickerColumnWidthsSize(ArkUINodeHandle node)
450 {
451 auto* frameNode = reinterpret_cast<FrameNode*>(node);
452 CHECK_NULL_RETURN(frameNode, 0);
453 return TextPickerModelNG::GetColumnWidthsSize(frameNode);
454 }
455
GetTextPickerColumnWidths(ArkUINodeHandle node,ArkUI_Float32 * values)456 void GetTextPickerColumnWidths(ArkUINodeHandle node, ArkUI_Float32* values)
457 {
458 auto* frameNode = reinterpret_cast<FrameNode*>(node);
459 CHECK_NULL_VOID(frameNode);
460 auto size = GetTextPickerColumnWidthsSize(node);
461 std::vector<Dimension> widths = TextPickerModelNG::GetColumnWidths(frameNode);
462 for (int32_t i = 0; i < size; i++) {
463 values[i] = widths[i].Value() / MAX_PERCENT;
464 }
465 }
466
GetTextPickerSelectedTextStyle(ArkUINodeHandle node)467 ArkUI_CharPtr GetTextPickerSelectedTextStyle(ArkUINodeHandle node)
468 {
469 auto* frameNode = reinterpret_cast<FrameNode*>(node);
470 CHECK_NULL_RETURN(frameNode, "");
471 PickerTextStyle pickerTextStyle = TextPickerModelNG::getSelectedTextStyle(frameNode);
472 std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
473 std::string families;
474 if (fontFamilies.size() == 0) {
475 fontFamilies.emplace_back("HarmonyOS Sans");
476 }
477 //set index start
478 int index = 0;
479 for (auto& family : fontFamilies) {
480 families += family;
481 if (index != static_cast<int>(fontFamilies.size()) - 1) {
482 families += ",";
483 }
484 index++;
485 }
486 g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
487 g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
488 g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
489 g_strValue = g_strValue + families + ";";
490 g_strValue =
491 g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
492 return g_strValue.c_str();
493 }
494
GetTextPickerTextStyle(ArkUINodeHandle node)495 ArkUI_CharPtr GetTextPickerTextStyle(ArkUINodeHandle node)
496 {
497 auto* frameNode = reinterpret_cast<FrameNode*>(node);
498 CHECK_NULL_RETURN(frameNode, "");
499 PickerTextStyle pickerTextStyle = TextPickerModelNG::getNormalTextStyle(frameNode);
500 std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
501 std::string families;
502 if (fontFamilies.size() == 0) {
503 fontFamilies.emplace_back("HarmonyOS Sans");
504 }
505 //set index start
506 int index = 0;
507 for (auto& family : fontFamilies) {
508 families += family;
509 if (index != static_cast<int>(fontFamilies.size()) - 1) {
510 families += ",";
511 }
512 index++;
513 }
514 g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
515 g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
516 g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
517 g_strValue = g_strValue + families + ";";
518 g_strValue =
519 g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
520 return g_strValue.c_str();
521 }
522
GetTextPickerDisappearTextStyle(ArkUINodeHandle node)523 ArkUI_CharPtr GetTextPickerDisappearTextStyle(ArkUINodeHandle node)
524 {
525 auto* frameNode = reinterpret_cast<FrameNode*>(node);
526 CHECK_NULL_RETURN(frameNode, "");
527 PickerTextStyle pickerTextStyle = TextPickerModelNG::getDisappearTextStyle(frameNode);
528 std::vector<std::string> fontFamilies = pickerTextStyle.fontFamily.value_or(std::vector<std::string>());
529 std::string families;
530 if (fontFamilies.size() == 0) {
531 fontFamilies.emplace_back("HarmonyOS Sans");
532 }
533 //set index start
534 int index = 0;
535 for (auto& family : fontFamilies) {
536 families += family;
537 if (index != static_cast<int>(fontFamilies.size()) - 1) {
538 families += ",";
539 }
540 index++;
541 }
542 g_strValue = pickerTextStyle.textColor->ColorToString() + ";";
543 g_strValue = g_strValue + std::to_string(static_cast<int>(pickerTextStyle.fontSize->ConvertToFp())) + ";";
544 g_strValue = g_strValue + StringUtils::ToString(pickerTextStyle.fontWeight.value_or(FontWeight::W100)) + ";";
545 g_strValue = g_strValue + families + ";";
546 g_strValue =
547 g_strValue + StringUtils::ToStringNDK(pickerTextStyle.fontStyle.value_or(OHOS::Ace::FontStyle::NORMAL));
548 return g_strValue.c_str();
549 }
550
SetTextPickerDivider(ArkUINodeHandle node,ArkUI_Uint32 color,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length)551 void SetTextPickerDivider(
552 ArkUINodeHandle node, ArkUI_Uint32 color, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length)
553 {
554 auto* frameNode = reinterpret_cast<FrameNode*>(node);
555 CHECK_NULL_VOID(frameNode);
556
557 if (length != DEFAULT_GROUP_DIVIDER_VALUES_COUNT) {
558 return;
559 }
560
561 NG::ItemDivider divider;
562 divider.color = Color(color);
563 divider.strokeWidth = Dimension(values[POS_0], static_cast<OHOS::Ace::DimensionUnit>(units[POS_0]));
564 divider.startMargin = Dimension(values[POS_1], static_cast<OHOS::Ace::DimensionUnit>(units[POS_1]));
565 divider.endMargin = Dimension(values[POS_2], static_cast<OHOS::Ace::DimensionUnit>(units[POS_2]));
566
567 TextPickerModelNG::SetDivider(frameNode, divider);
568 }
569
ResetTextPickerDivider(ArkUINodeHandle node)570 void ResetTextPickerDivider(ArkUINodeHandle node)
571 {
572 auto* frameNode = reinterpret_cast<FrameNode*>(node);
573 CHECK_NULL_VOID(frameNode);
574 auto context = frameNode->GetContext();
575 CHECK_NULL_VOID(context);
576 auto themeManager = context->GetThemeManager();
577 CHECK_NULL_VOID(themeManager);
578 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
579 NG::ItemDivider divider;
580 Dimension defaultStrokeWidth = 0.0_vp;
581 Color defaultColor = Color::TRANSPARENT;
582 if (pickerTheme) {
583 defaultStrokeWidth = pickerTheme->GetDividerThickness();
584 defaultColor = pickerTheme->GetDividerColor();
585 divider.strokeWidth = defaultStrokeWidth;
586 divider.color = defaultColor;
587 }
588 TextPickerModelNG::SetDivider(frameNode, divider);
589 }
590
ResetTextPickerDividerNull(ArkUINodeHandle node)591 void ResetTextPickerDividerNull(ArkUINodeHandle node)
592 {
593 auto* frameNode = reinterpret_cast<FrameNode*>(node);
594 CHECK_NULL_VOID(frameNode);
595 NG::ItemDivider divider;
596 TextPickerModelNG::SetDivider(frameNode, divider);
597 }
598
SetTextPickerGradientHeight(ArkUINodeHandle node,ArkUI_Float32 dVal,ArkUI_Int32 dUnit)599 void SetTextPickerGradientHeight(ArkUINodeHandle node, ArkUI_Float32 dVal, ArkUI_Int32 dUnit)
600 {
601 auto* frameNode = reinterpret_cast<FrameNode*>(node);
602 CHECK_NULL_VOID(frameNode);
603 TextPickerModelNG::SetGradientHeight(frameNode, Dimension(dVal, static_cast<DimensionUnit>(dUnit)));
604 }
605
ResetTextPickerGradientHeight(ArkUINodeHandle node)606 void ResetTextPickerGradientHeight(ArkUINodeHandle node)
607 {
608 auto* frameNode = reinterpret_cast<FrameNode*>(node);
609 CHECK_NULL_VOID(frameNode);
610
611 auto pipeline = frameNode->GetContext();
612 CHECK_NULL_VOID(pipeline);
613 auto themeManager = pipeline->GetThemeManager();
614 CHECK_NULL_VOID(themeManager);
615 auto pickerTheme = themeManager->GetTheme<PickerTheme>();
616 CHECK_NULL_VOID(pickerTheme);
617
618 CalcDimension height;
619 if (pickerTheme) {
620 height = pickerTheme->GetGradientHeight();
621 } else {
622 height = 0.0_vp;
623 }
624
625 TextPickerModelNG::SetGradientHeight(frameNode, height);
626 }
627
SetTextPickerDisableTextStyleAnimation(ArkUINodeHandle node,int disableTextStyleAnimation)628 void SetTextPickerDisableTextStyleAnimation(ArkUINodeHandle node, int disableTextStyleAnimation)
629 {
630 auto* frameNode = reinterpret_cast<FrameNode*>(node);
631 CHECK_NULL_VOID(frameNode);
632 TextPickerModelNG::SetDisableTextStyleAnimation(frameNode, disableTextStyleAnimation);
633 }
634
ResetTextPickerDisableTextStyleAnimation(ArkUINodeHandle node)635 void ResetTextPickerDisableTextStyleAnimation(ArkUINodeHandle node)
636 {
637 auto* frameNode = reinterpret_cast<FrameNode*>(node);
638 CHECK_NULL_VOID(frameNode);
639 TextPickerModelNG::SetDisableTextStyleAnimation(frameNode, false);
640 }
641
SetTextPickerDefaultTextStyle(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_CharPtr fontInfo,ArkUI_Int32 style,ArkUI_CharPtr minFontSize,ArkUI_CharPtr maxFontSize,ArkUI_Int32 overflow)642 void SetTextPickerDefaultTextStyle(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_CharPtr fontInfo, ArkUI_Int32 style,
643 ArkUI_CharPtr minFontSize, ArkUI_CharPtr maxFontSize, ArkUI_Int32 overflow)
644 {
645 auto* frameNode = reinterpret_cast<FrameNode*>(node);
646 CHECK_NULL_VOID(frameNode);
647 auto pipeline = frameNode->GetContext();
648 CHECK_NULL_VOID(pipeline);
649 auto themeManager = pipeline->GetThemeManager();
650 CHECK_NULL_VOID(themeManager);
651 auto theme = themeManager->GetTheme<TextTheme>();
652 CHECK_NULL_VOID(theme);
653
654 NG::PickerTextStyle textStyle;
655 std::vector<std::string> res;
656 std::string fontValues = std::string(fontInfo);
657 StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
658 if (res.size() != NUM_3) {
659 return;
660 }
661 textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
662 if (style >= 0 && style < static_cast<int32_t>(FONT_STYLES.size())) {
663 textStyle.fontStyle = FONT_STYLES[style];
664 } else {
665 textStyle.fontStyle = FONT_STYLES[0];
666 }
667 textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
668 textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1]);
669 textStyle.textColor = Color(color);
670 textStyle.minFontSize = StringUtils::StringToCalcDimension(minFontSize, false, DimensionUnit::FP);
671 textStyle.maxFontSize = StringUtils::StringToCalcDimension(maxFontSize, false, DimensionUnit::FP);
672 if (overflow >= 0 && overflow < static_cast<int32_t>(TEXT_OVERFLOWS.size())) {
673 textStyle.textOverflow = TEXT_OVERFLOWS[overflow];
674 } else {
675 textStyle.textOverflow = TEXT_OVERFLOWS[0];
676 }
677
678 TextPickerModelNG::SetDefaultTextStyle(frameNode, theme, textStyle);
679 }
680
ResetTextPickerDefaultTextStyle(ArkUINodeHandle node)681 void ResetTextPickerDefaultTextStyle(ArkUINodeHandle node)
682 {
683 auto* frameNode = reinterpret_cast<FrameNode*>(node);
684 CHECK_NULL_VOID(frameNode);
685 auto pipeline = frameNode->GetContext();
686 CHECK_NULL_VOID(pipeline);
687 auto themeManager = pipeline->GetThemeManager();
688 CHECK_NULL_VOID(themeManager);
689 auto theme = themeManager->GetTheme<TextTheme>();
690 CHECK_NULL_VOID(theme);
691 NG::PickerTextStyle pickerTextStyle;
692 TextPickerModelNG::SetDefaultTextStyle(frameNode, theme, pickerTextStyle);
693 }
694
GetTextPickerSelectedSize(ArkUINodeHandle node)695 ArkUI_Int32 GetTextPickerSelectedSize(ArkUINodeHandle node)
696 {
697 auto* frameNode = reinterpret_cast<FrameNode*>(node);
698 CHECK_NULL_RETURN(frameNode, 0);
699 if (TextPickerModelNG::IsSingle(frameNode)) {
700 return 1;
701 }
702 return TextPickerModelNG::GetSelectedSize(frameNode);
703 }
SetTextPickerOnChangeExt(ArkUINodeHandle node,void * callback)704 void SetTextPickerOnChangeExt(ArkUINodeHandle node, void* callback)
705 {
706 auto* frameNode = reinterpret_cast<FrameNode*>(node);
707 CHECK_NULL_VOID(frameNode);
708 auto onChange =
709 reinterpret_cast<std::function<void(const std::vector<std::string>&, const std::vector<double>&)>*>(callback);
710 TextPickerModelNG::SetOnCascadeChange(frameNode, std::move(*onChange));
711 }
ResetTextPickerOnChange(ArkUINodeHandle node)712 void ResetTextPickerOnChange(ArkUINodeHandle node)
713 {
714 auto* frameNode = reinterpret_cast<FrameNode*>(node);
715 CHECK_NULL_VOID(frameNode);
716 TextPickerModelNG::SetOnCascadeChange(frameNode, nullptr);
717 }
SetTextPickerOnScrollStopExt(ArkUINodeHandle node,void * callback)718 void SetTextPickerOnScrollStopExt(ArkUINodeHandle node, void* callback)
719 {
720 auto* frameNode = reinterpret_cast<FrameNode*>(node);
721 CHECK_NULL_VOID(frameNode);
722 auto onChange =
723 reinterpret_cast<std::function<void(const std::vector<std::string>&, const std::vector<double>&)>*>(callback);
724 TextPickerModelNG::SetOnScrollStop(frameNode, std::move(*onChange));
725 }
ResetTextPickerOnScrollStop(ArkUINodeHandle node)726 void ResetTextPickerOnScrollStop(ArkUINodeHandle node)
727 {
728 auto* frameNode = reinterpret_cast<FrameNode*>(node);
729 CHECK_NULL_VOID(frameNode);
730 TextPickerModelNG::SetOnScrollStop(frameNode, nullptr);
731 }
732 } // namespace
733
734 namespace NodeModifier {
GetTextPickerModifier()735 const ArkUITextPickerModifier* GetTextPickerModifier()
736 {
737 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
738 static const ArkUITextPickerModifier modifier = {
739 .setTextPickerBackgroundColor = SetTextPickerBackgroundColor,
740 .setTextPickerCanLoop = SetTextPickerCanLoop,
741 .getTextPickerSelectedIndex = GetTextPickerSelectedIndex,
742 .setTextPickerSelectedIndex = SetTextPickerSelectedIndex,
743 .getTextPickerTextStyle = GetTextPickerTextStyle,
744 .setTextPickerTextStyle = SetTextPickerTextStyle,
745 .getTextPickerSelectedTextStyle = GetTextPickerSelectedTextStyle,
746 .setTextPickerSelectedTextStyle = SetTextPickerSelectedTextStyle,
747 .getTextPickerDisappearTextStyle = GetTextPickerDisappearTextStyle,
748 .setTextPickerDisappearTextStyle = SetTextPickerDisappearTextStyle,
749 .setTextPickerDefaultPickerItemHeight = SetTextPickerDefaultPickerItemHeight,
750 .resetTextPickerCanLoop = ResetTextPickerCanLoop,
751 .resetTextPickerSelectedIndex = ResetTextPickerSelectedIndex,
752 .resetTextPickerTextStyle = ResetTextPickerTextStyle,
753 .resetTextPickerSelectedTextStyle = ResetTextPickerSelectedTextStyle,
754 .resetTextPickerDisappearTextStyle = ResetTextPickerDisappearTextStyle,
755 .resetTextPickerDefaultPickerItemHeight = ResetTextPickerDefaultPickerItemHeight,
756 .resetTextPickerBackgroundColor = ResetTextPickerBackgroundColor,
757 .getTextPickerRangeStr = GetTextPickerRangeStr,
758 .getTextPickerSingleRange = GetTextPickerSingleRange,
759 .setTextPickerRangeStr = SetTextPickerRangeStr,
760 .getTextPickerValue = GetTextPickerValue,
761 .setTextPickerValue = SetTextPickerValue,
762 .setTextPickerColumnWidths = SetTextPickerColumnWidths,
763 .resetTextPickerColumnWidths = ResetTextPickerColumnWidths,
764 .getTextPickerColumnWidths = GetTextPickerColumnWidths,
765 .getTextPickerColumnWidthsSize = GetTextPickerColumnWidthsSize,
766 .setTextPickerDivider = SetTextPickerDivider,
767 .resetTextPickerDivider = ResetTextPickerDivider,
768 .setTextPickerGradientHeight = SetTextPickerGradientHeight,
769 .resetTextPickerGradientHeight = ResetTextPickerGradientHeight,
770 .getTextPickerSelectedSize = GetTextPickerSelectedSize,
771 .getTextPickerCanLoop = GetTextPickerCanLoop,
772 .getTextPickerDefaultPickerItemHeight = GetTextPickerDefaultPickerItemHeight,
773 .resetTextPickerDividerNull = ResetTextPickerDividerNull,
774 .setTextPickerDisableTextStyleAnimation = SetTextPickerDisableTextStyleAnimation,
775 .resetTextPickerDisableTextStyleAnimation = ResetTextPickerDisableTextStyleAnimation,
776 .setTextPickerDefaultTextStyle = SetTextPickerDefaultTextStyle,
777 .resetTextPickerDefaultTextStyle = ResetTextPickerDefaultTextStyle,
778 .getTextPickerEnableHapticFeedback = GetTextPickerEnableHapticFeedback,
779 .setTextPickerEnableHapticFeedback = SetTextPickerEnableHapticFeedback,
780 .resetTextPickerEnableHapticFeedback = ResetTextPickerEnableHapticFeedback,
781 .setTextPickerDigitalCrownSensitivity = SetTextPickerDigitalCrownSensitivity,
782 .resetTextPickerDigitalCrownSensitivity = ResetTextPickerDigitalCrownSensitivity,
783 .setTextPickerOnChange = SetTextPickerOnChangeExt,
784 .resetTextPickerOnChange = ResetTextPickerOnChange,
785 .setTextPickerOnScrollStop = SetTextPickerOnScrollStopExt,
786 .resetTextPickerOnScrollStop = ResetTextPickerOnScrollStop,
787 .setTextPickerIconRangeStr = SetTextPickerIconRangeStr,
788 .setTextCascadePickRangeContent = SetTextCascadePickRangeContent,
789 };
790 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
791
792 return &modifier;
793 }
794
GetCJUITextPickerModifier()795 const CJUITextPickerModifier* GetCJUITextPickerModifier()
796 {
797 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
798 static const CJUITextPickerModifier modifier = {
799 .setTextPickerBackgroundColor = SetTextPickerBackgroundColor,
800 .setTextPickerCanLoop = SetTextPickerCanLoop,
801 .getTextPickerSelectedIndex = GetTextPickerSelectedIndex,
802 .setTextPickerSelectedIndex = SetTextPickerSelectedIndex,
803 .getTextPickerTextStyle = GetTextPickerTextStyle,
804 .setTextPickerTextStyle = SetTextPickerTextStyle,
805 .getTextPickerSelectedTextStyle = GetTextPickerSelectedTextStyle,
806 .setTextPickerSelectedTextStyle = SetTextPickerSelectedTextStyle,
807 .getTextPickerDisappearTextStyle = GetTextPickerDisappearTextStyle,
808 .setTextPickerDisappearTextStyle = SetTextPickerDisappearTextStyle,
809 .setTextPickerDefaultPickerItemHeight = SetTextPickerDefaultPickerItemHeight,
810 .resetTextPickerCanLoop = ResetTextPickerCanLoop,
811 .resetTextPickerSelectedIndex = ResetTextPickerSelectedIndex,
812 .resetTextPickerTextStyle = ResetTextPickerTextStyle,
813 .resetTextPickerSelectedTextStyle = ResetTextPickerSelectedTextStyle,
814 .resetTextPickerDisappearTextStyle = ResetTextPickerDisappearTextStyle,
815 .resetTextPickerDefaultPickerItemHeight = ResetTextPickerDefaultPickerItemHeight,
816 .resetTextPickerBackgroundColor = ResetTextPickerBackgroundColor,
817 .getTextPickerRangeStr = GetTextPickerRangeStr,
818 .getTextPickerSingleRange = GetTextPickerSingleRange,
819 .setTextPickerRangeStr = SetTextPickerRangeStr,
820 .getTextPickerValue = GetTextPickerValue,
821 .setTextPickerValue = SetTextPickerValue,
822 .setTextPickerDivider = SetTextPickerDivider,
823 .resetTextPickerDivider = ResetTextPickerDivider,
824 .setTextPickerGradientHeight = SetTextPickerGradientHeight,
825 .resetTextPickerGradientHeight = ResetTextPickerGradientHeight,
826 .getTextPickerSelectedSize = GetTextPickerSelectedSize,
827 .getTextPickerCanLoop = GetTextPickerCanLoop,
828 .getTextPickerDefaultPickerItemHeight = GetTextPickerDefaultPickerItemHeight,
829 };
830 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
831
832 return &modifier;
833 }
834
GetPickerTextStyle(uint32_t color,ArkUI_CharPtr fontInfo,int32_t styleVal,NG::PickerTextStyle & textStyle)835 void GetPickerTextStyle(uint32_t color, ArkUI_CharPtr fontInfo, int32_t styleVal, NG::PickerTextStyle& textStyle)
836 {
837 textStyle.textColor = Color(color);
838
839 std::vector<std::string> res;
840 std::string fontValues = std::string(fontInfo);
841 StringUtils::StringSplitter(fontValues, DEFAULT_DELIMITER, res);
842
843 if (res.size() != SIZE_OF_THREE) {
844 return;
845 }
846
847 if (res[POS_0] != "-1") {
848 textStyle.fontSize = StringUtils::StringToCalcDimension(res[POS_0], false, DimensionUnit::FP);
849 } else {
850 textStyle.fontSize = Dimension(-1);
851 }
852
853 if (res[POS_1] != "-1") {
854 textStyle.fontWeight = StringUtils::StringToFontWeight(res[POS_1], FontWeight::NORMAL);
855 }
856
857 if (res[POS_2] != "-1") {
858 textStyle.fontFamily = Framework::ConvertStrToFontFamilies(res[POS_2]);
859 }
860 textStyle.fontStyle = static_cast<Ace::FontStyle>(styleVal);
861 }
862
SetSelectedIndexSingle(FrameNode * frameNode,uint32_t * selectedValues,const int32_t size)863 void SetSelectedIndexSingle(FrameNode* frameNode, uint32_t* selectedValues, const int32_t size)
864 {
865 std::vector<NG::RangeContent> rangeResult;
866 TextPickerModelNG::GetSingleRange(frameNode, rangeResult);
867 if (selectedValues[0] >= rangeResult.size()) {
868 TextPickerModelNG::SetSelected(frameNode, 0);
869 } else {
870 TextPickerModelNG::SetSelected(frameNode, selectedValues[0]);
871 }
872 }
873
SetSelectedIndexMultiInternal(FrameNode * frameNode,uint32_t count,std::vector<NG::TextCascadePickerOptions> & options,std::vector<uint32_t> & selectedValues)874 void SetSelectedIndexMultiInternal(FrameNode* frameNode, uint32_t count,
875 std::vector<NG::TextCascadePickerOptions>& options, std::vector<uint32_t>& selectedValues)
876 {
877 if (!TextPickerModelNG::IsCascade(frameNode)) {
878 NodeModifier::SetSelectedInternal(count, options, selectedValues);
879 } else {
880 TextPickerModelNG::SetHasSelectAttr(frameNode, true);
881 NodeModifier::ProcessCascadeSelected(options, 0, selectedValues);
882 uint32_t maxCount = TextPickerModelNG::GetMaxCount(frameNode);
883 if (selectedValues.size() < maxCount) {
884 auto differ = maxCount - selectedValues.size();
885 for (uint32_t i = 0; i < differ; i++) {
886 selectedValues.emplace_back(0);
887 }
888 }
889 }
890 }
891
SetSelectedIndexSingleInternal(const std::vector<NG::TextCascadePickerOptions> & options,uint32_t count,uint32_t & selectedValue,std::vector<uint32_t> & selectedValues)892 void SetSelectedIndexSingleInternal(const std::vector<NG::TextCascadePickerOptions>& options, uint32_t count,
893 uint32_t& selectedValue, std::vector<uint32_t>& selectedValues)
894 {
895 if (options.size() > 0) {
896 if (selectedValue >= options[0].rangeResult.size()) {
897 selectedValue = 0;
898 }
899 selectedValues.emplace_back(selectedValue);
900 for (uint32_t i = 1; i < count; i++) {
901 selectedValues.emplace_back(0);
902 }
903 } else {
904 for (uint32_t i = 0; i < count; i++) {
905 selectedValues.emplace_back(0);
906 }
907 }
908 }
909
SetSelectedInternal(uint32_t count,std::vector<NG::TextCascadePickerOptions> & options,std::vector<uint32_t> & selectedValues)910 void SetSelectedInternal(
911 uint32_t count, std::vector<NG::TextCascadePickerOptions>& options, std::vector<uint32_t>& selectedValues)
912 {
913 for (uint32_t i = 0; i < count; i++) {
914 uint32_t val = selectedValues.size() > 0 ? selectedValues.size() - 1 : 0;
915 if (i > val) {
916 selectedValues.emplace_back(0);
917 } else {
918 if (selectedValues[i] >= options[i].rangeResult.size()) {
919 selectedValues[i] = 0;
920 }
921 }
922 }
923 }
924
SetSelectedIndexMulti(FrameNode * frameNode,uint32_t * inputs,const int32_t size)925 void SetSelectedIndexMulti(FrameNode* frameNode, uint32_t* inputs, const int32_t size)
926 {
927 std::vector<NG::TextCascadePickerOptions> options;
928 TextPickerModelNG::GetMultiOptions(frameNode, options);
929
930 auto count = TextPickerModelNG::IsCascade(frameNode) ? TextPickerModelNG::GetMaxCount(frameNode) : options.size();
931 std::vector<uint32_t> selectedValues;
932
933 if (size >= 0) {
934 selectedValues.assign(inputs, inputs + size);
935 SetSelectedIndexMultiInternal(frameNode, count, options, selectedValues);
936 } else {
937 TextPickerModelNG::SetHasSelectAttr(frameNode, true);
938 SetSelectedIndexSingleInternal(options, count, inputs[0], selectedValues);
939 }
940 TextPickerModelNG::SetSelecteds(frameNode, selectedValues);
941 }
942
ProcessCascadeSelected(const std::vector<NG::TextCascadePickerOptions> & options,uint32_t index,std::vector<uint32_t> & selectedValues)943 void ProcessCascadeSelected(
944 const std::vector<NG::TextCascadePickerOptions>& options, uint32_t index, std::vector<uint32_t>& selectedValues)
945 {
946 const size_t size = options.size();
947 if (size == 0) {
948 return;
949 }
950 std::vector<std::string> rangeResultValue;
951 for (size_t i = 0; i < size; i++) {
952 rangeResultValue.emplace_back(options[i].rangeResult[0]);
953 }
954 uint32_t val = selectedValues.size() > 0 ? selectedValues.size() - 1 : 0;
955 if (index > val) {
956 selectedValues.emplace_back(0);
957 }
958 if (selectedValues[index] >= rangeResultValue.size()) {
959 selectedValues[index] = 0;
960 }
961 if ((selectedValues[index] <= size - 1) && (options[selectedValues[index]].children.size() > 0)) {
962 ProcessCascadeSelected(options[selectedValues[index]].children, index + 1, selectedValues);
963 }
964 }
965
SetTextPickerOnChange(ArkUINodeHandle node,void * extraParam)966 void SetTextPickerOnChange(ArkUINodeHandle node, void* extraParam)
967 {
968 auto* frameNode = reinterpret_cast<FrameNode*>(node);
969 CHECK_NULL_VOID(frameNode);
970 auto onChangeEvent = [node, extraParam](
971 const std::vector<std::string>& value, const std::vector<double>& indexVector) {
972 ArkUINodeEvent event;
973 event.kind = COMPONENT_ASYNC_EVENT;
974 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
975 event.componentAsyncEvent.subKind = ON_TEXT_PICKER_CHANGE;
976 for (size_t i = 0; i < indexVector.size() && i < MAX_SIZE; i++) {
977 event.componentAsyncEvent.data[i].i32 = static_cast<int32_t>(indexVector[i]);
978 }
979 SendArkUISyncEvent(&event);
980 };
981 TextPickerModelNG::SetOnCascadeChange(frameNode, std::move(onChangeEvent));
982 }
983
SetTextPickerOnScrollStop(ArkUINodeHandle node,void * extraParam)984 void SetTextPickerOnScrollStop(ArkUINodeHandle node, void* extraParam)
985 {
986 auto* frameNode = reinterpret_cast<FrameNode*>(node);
987 CHECK_NULL_VOID(frameNode);
988 auto onScrollStopEvent = [node, extraParam](
989 const std::vector<std::string>& value, const std::vector<double>& indexVector) {
990 ArkUINodeEvent event;
991 event.kind = COMPONENT_ASYNC_EVENT;
992 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
993 event.componentAsyncEvent.subKind = ON_TEXT_PICKER_SCROLL_STOP;
994 for (size_t i = 0; i < indexVector.size() && i < MAX_SIZE; i++) {
995 event.componentAsyncEvent.data[i].i32 = static_cast<int32_t>(indexVector[i]);
996 }
997 SendArkUISyncEvent(&event);
998 };
999 TextPickerModelNG::SetOnScrollStop(frameNode, std::move(onScrollStopEvent));
1000 }
1001
SetTextPickerEnableHapticFeedback(ArkUINodeHandle node,ArkUI_Bool isEnableHapticFeedback)1002 void SetTextPickerEnableHapticFeedback(ArkUINodeHandle node, ArkUI_Bool isEnableHapticFeedback)
1003 {
1004 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1005 CHECK_NULL_VOID(frameNode);
1006 TextPickerModelNG::SetEnableHapticFeedback(frameNode, isEnableHapticFeedback);
1007 }
1008
ResetTextPickerEnableHapticFeedback(ArkUINodeHandle node)1009 void ResetTextPickerEnableHapticFeedback(ArkUINodeHandle node)
1010 {
1011 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1012 CHECK_NULL_VOID(frameNode);
1013 TextPickerModelNG::SetEnableHapticFeedback(frameNode, DEFAULT_ENABLE_HAPTIC_FEEDBACK);
1014 }
1015
GetTextPickerEnableHapticFeedback(ArkUINodeHandle node)1016 ArkUI_Bool GetTextPickerEnableHapticFeedback(ArkUINodeHandle node)
1017 {
1018 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1019 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
1020 return static_cast<ArkUI_Bool>(TextPickerModelNG::GetEnableHapticFeedback(frameNode));
1021 }
1022 } // namespace NodeModifier
1023 } // namespace OHOS::Ace::NG
1024