1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "core/interfaces/native/node/select_modifier.h"
16
17 #include "core/components/select/select_theme.h"
18 #include "core/components_ng/base/view_abstract_model_ng.h"
19 #include "core/components_ng/pattern/select/select_model_ng.h"
20 #include "frameworks/bridge/common/utils/utils.h"
21
22 namespace OHOS::Ace::NG {
23 constexpr int32_t DEFAULT_GROUP_DIVIDER_VALUES_COUNT = 3;
24 const char DELIMITER = '|';
25 const char* ERR_CODE = "-1";
26 const int32_t SIZE_OF_FONT_INFO = 3;
27 const int32_t SIZE_OF_TWO = 2;
28 const int32_t DEFAULT_SELECT = 0;
29 constexpr int32_t OFFSET_OF_VALUE = 1;
30 constexpr int32_t OFFSET_OF_UNIT = 2;
31 constexpr int32_t OFFSET_OF_NEXT = 3;
32 constexpr int32_t SIZE_OF_COLOR_ARRAY = 8;
33 constexpr int32_t SIZE_OF_WIDTH_ARRAY = 12;
34 constexpr TextDirection DEFAULT_SELECT_DIRECTION = TextDirection::AUTO;
35
SetSpace(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)36 void SetSpace(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
37 {
38 auto* frameNode = reinterpret_cast<FrameNode*>(node);
39 CHECK_NULL_VOID(frameNode);
40 Dimension space = Dimension(value, static_cast<DimensionUnit>(unit));
41 SelectModelNG::SetSpace(frameNode, space);
42 }
43
SetValue(ArkUINodeHandle node,ArkUI_CharPtr value)44 void SetValue(ArkUINodeHandle node, ArkUI_CharPtr value)
45 {
46 auto* frameNode = reinterpret_cast<FrameNode*>(node);
47 CHECK_NULL_VOID(frameNode);
48 SelectModelNG::SetValue(frameNode, value);
49 }
50
SetValuePtr(ArkUINodeHandle node,ArkUI_CharPtr value,void * valueRawPtr)51 void SetValuePtr(ArkUINodeHandle node, ArkUI_CharPtr value, void* valueRawPtr)
52 {
53 CHECK_NULL_VOID(node);
54 SetValue(node, value);
55 if (SystemProperties::ConfigChangePerform()) {
56 auto* frameNode = reinterpret_cast<FrameNode*>(node);
57 CHECK_NULL_VOID(frameNode);
58 if (valueRawPtr) {
59 auto* selectobj = reinterpret_cast<ResourceObject*>(valueRawPtr);
60 auto valueResObj = AceType::Claim(selectobj);
61 SelectModelNG::CreateWithStringResourceObj(frameNode, valueResObj);
62 } else {
63 SelectModelNG::CreateWithStringResourceObj(frameNode, nullptr);
64 }
65 }
66 }
67
SetSelected(ArkUINodeHandle node,ArkUI_Int32 idx)68 void SetSelected(ArkUINodeHandle node, ArkUI_Int32 idx)
69 {
70 auto* frameNode = reinterpret_cast<FrameNode*>(node);
71 CHECK_NULL_VOID(frameNode);
72 if (idx < -1) {
73 idx = -1;
74 }
75 SelectModelNG::SetSelected(frameNode, idx);
76 }
77
SetSelectedPtr(ArkUINodeHandle node,ArkUI_Int32 idx,void * selectedRawPtr)78 void SetSelectedPtr(ArkUINodeHandle node, ArkUI_Int32 idx, void* selectedRawPtr)
79 {
80 CHECK_NULL_VOID(node);
81 SetSelected(node, idx);
82 if (SystemProperties::ConfigChangePerform()) {
83 auto* frameNode = reinterpret_cast<FrameNode*>(node);
84 CHECK_NULL_VOID(frameNode);
85 if (selectedRawPtr) {
86 auto* selectobj = reinterpret_cast<ResourceObject*>(selectedRawPtr);
87 auto selectedResObj = AceType::Claim(selectobj);
88 SelectModelNG::CreateWithIntegerResourceObj(frameNode, selectedResObj);
89 } else {
90 SelectModelNG::CreateWithIntegerResourceObj(frameNode, nullptr);
91 }
92 }
93 }
94
SetSelectFontColor(ArkUINodeHandle node,ArkUI_Uint32 color)95 void SetSelectFontColor(ArkUINodeHandle node, ArkUI_Uint32 color)
96 {
97 auto* frameNode = reinterpret_cast<FrameNode*>(node);
98 CHECK_NULL_VOID(frameNode);
99 SelectModelNG::SetFontColor(frameNode, Color(color));
100 }
101
SetSelectFontColorPtr(ArkUINodeHandle node,ArkUI_Uint32 color,void * fontColorRawPtr)102 void SetSelectFontColorPtr(ArkUINodeHandle node, ArkUI_Uint32 color, void* fontColorRawPtr)
103 {
104 CHECK_NULL_VOID(node);
105 SetSelectFontColor(node, color);
106 if (SystemProperties::ConfigChangePerform()) {
107 auto* frameNode = reinterpret_cast<FrameNode*>(node);
108 CHECK_NULL_VOID(frameNode);
109 SelectModelNG::SetFontColorByUser(frameNode);
110 if (fontColorRawPtr) {
111 auto* fontColor = reinterpret_cast<ResourceObject*>(fontColorRawPtr);
112 auto fontColorResObj = AceType::Claim(fontColor);
113 SelectModelNG::CreateWithColorResourceObj(frameNode, fontColorResObj, SelectColorType::FONT_COLOR);
114 } else {
115 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::FONT_COLOR);
116 }
117 }
118 }
119
SetSelectedOptionBgColor(ArkUINodeHandle node,ArkUI_Uint32 color)120 void SetSelectedOptionBgColor(ArkUINodeHandle node, ArkUI_Uint32 color)
121 {
122 auto* frameNode = reinterpret_cast<FrameNode*>(node);
123 CHECK_NULL_VOID(frameNode);
124 SelectModelNG::SetSelectedOptionBgColor(frameNode, Color(color));
125 }
126
SetSelectedOptionBgColorPtr(ArkUINodeHandle node,ArkUI_Uint32 color,void * optionBgColorRawPtr)127 void SetSelectedOptionBgColorPtr(ArkUINodeHandle node, ArkUI_Uint32 color, void* optionBgColorRawPtr)
128 {
129 CHECK_NULL_VOID(node);
130 SetSelectedOptionBgColor(node, color);
131 if (SystemProperties::ConfigChangePerform()) {
132 auto* frameNode = reinterpret_cast<FrameNode*>(node);
133 CHECK_NULL_VOID(frameNode);
134 SelectModelNG::SetSelectedOptionBgColorByUser(frameNode);
135 if (optionBgColorRawPtr) {
136 auto* bgColor = reinterpret_cast<ResourceObject*>(optionBgColorRawPtr);
137 auto bgColorResObj = AceType::Claim(bgColor);
138 SelectModelNG::CreateWithColorResourceObj(
139 frameNode, bgColorResObj, SelectColorType::SELECTED_OPTION_BG_COLOR);
140 } else {
141 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::SELECTED_OPTION_BG_COLOR);
142 }
143 }
144 }
145
SetOptionBgColor(ArkUINodeHandle node,ArkUI_Uint32 color)146 void SetOptionBgColor(ArkUINodeHandle node, ArkUI_Uint32 color)
147 {
148 auto* frameNode = reinterpret_cast<FrameNode*>(node);
149 CHECK_NULL_VOID(frameNode);
150 SelectModelNG::SetOptionBgColor(frameNode, Color(color));
151 }
152
SetOptionBgColorPtr(ArkUINodeHandle node,ArkUI_Uint32 color,void * optionBgColorRawPtr)153 void SetOptionBgColorPtr(ArkUINodeHandle node, ArkUI_Uint32 color, void* optionBgColorRawPtr)
154 {
155 CHECK_NULL_VOID(node);
156 SetOptionBgColor(node, color);
157 if (SystemProperties::ConfigChangePerform()) {
158 auto* frameNode = reinterpret_cast<FrameNode*>(node);
159 CHECK_NULL_VOID(frameNode);
160 SelectModelNG::SetOptionBgColorByUser(frameNode);
161 if (optionBgColorRawPtr) {
162 auto* bgColor = reinterpret_cast<ResourceObject*>(optionBgColorRawPtr);
163 auto bgColorResObj = AceType::Claim(bgColor);
164 SelectModelNG::CreateWithColorResourceObj(frameNode, bgColorResObj, SelectColorType::OPTION_BG_COLOR);
165 } else {
166 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::OPTION_BG_COLOR);
167 }
168 }
169 }
170
SetOptionFontColor(ArkUINodeHandle node,ArkUI_Uint32 color)171 void SetOptionFontColor(ArkUINodeHandle node, ArkUI_Uint32 color)
172 {
173 auto* frameNode = reinterpret_cast<FrameNode*>(node);
174 CHECK_NULL_VOID(frameNode);
175 SelectModelNG::SetOptionFontColor(frameNode, Color(color));
176 }
177
SetOptionFontColorPtr(ArkUINodeHandle node,ArkUI_Uint32 color,void * fontColorRawPtr)178 void SetOptionFontColorPtr(ArkUINodeHandle node, ArkUI_Uint32 color, void* fontColorRawPtr)
179 {
180 CHECK_NULL_VOID(node);
181 SetOptionFontColor(node, color);
182 if (SystemProperties::ConfigChangePerform()) {
183 auto* frameNode = reinterpret_cast<FrameNode*>(node);
184 CHECK_NULL_VOID(frameNode);
185 SelectModelNG::SetOptionFontColorByUser(frameNode);
186 if (fontColorRawPtr) {
187 auto* fontColor = reinterpret_cast<ResourceObject*>(fontColorRawPtr);
188 auto fontColorResObj = AceType::Claim(fontColor);
189 SelectModelNG::CreateWithColorResourceObj(frameNode, fontColorResObj, SelectColorType::OPTION_FONT_COLOR);
190 } else {
191 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::OPTION_FONT_COLOR);
192 }
193 }
194 }
195
SetSelectedOptionFontColor(ArkUINodeHandle node,ArkUI_Uint32 color)196 void SetSelectedOptionFontColor(ArkUINodeHandle node, ArkUI_Uint32 color)
197 {
198 auto* frameNode = reinterpret_cast<FrameNode*>(node);
199 CHECK_NULL_VOID(frameNode);
200 SelectModelNG::SetSelectedOptionFontColor(frameNode, Color(color));
201 }
202
SetSelectedOptionFontColorPtr(ArkUINodeHandle node,ArkUI_Uint32 color,void * fontColorRawPtr)203 void SetSelectedOptionFontColorPtr(ArkUINodeHandle node, ArkUI_Uint32 color, void* fontColorRawPtr)
204 {
205 CHECK_NULL_VOID(node);
206 SetSelectedOptionFontColor(node, color);
207 if (SystemProperties::ConfigChangePerform()) {
208 auto* frameNode = reinterpret_cast<FrameNode*>(node);
209 CHECK_NULL_VOID(frameNode);
210 SelectModelNG::SetSelectedOptionFontColorByUser(frameNode);
211 if (fontColorRawPtr) {
212 auto* fontColor = reinterpret_cast<ResourceObject*>(fontColorRawPtr);
213 auto fontColorResObj = AceType::Claim(fontColor);
214 SelectModelNG::CreateWithColorResourceObj(
215 frameNode, fontColorResObj, SelectColorType::SELECTED_OPTION_FONT_COLOR);
216 } else {
217 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::SELECTED_OPTION_FONT_COLOR);
218 }
219 }
220 }
221
SetArrowPosition(ArkUINodeHandle node,ArkUI_Int32 arrowPosition)222 void SetArrowPosition(ArkUINodeHandle node, ArkUI_Int32 arrowPosition)
223 {
224 auto* frameNode = reinterpret_cast<FrameNode*>(node);
225 CHECK_NULL_VOID(frameNode);
226 if (static_cast<OHOS::Ace::ArrowPosition>(arrowPosition) != OHOS::Ace::ArrowPosition::START &&
227 static_cast<OHOS::Ace::ArrowPosition>(arrowPosition) != OHOS::Ace::ArrowPosition::END) {
228 arrowPosition = 0;
229 }
230 SelectModelNG::SetArrowPosition(frameNode, static_cast<ArrowPosition>(arrowPosition));
231 }
232
SetMenuAlign(ArkUINodeHandle node,ArkUI_Int32 alignType,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 size)233 void SetMenuAlign(
234 ArkUINodeHandle node, ArkUI_Int32 alignType, const ArkUI_Float32* values,
235 const ArkUI_Int32* units, ArkUI_Int32 size)
236 {
237 auto* frameNode = reinterpret_cast<FrameNode*>(node);
238 CHECK_NULL_VOID(frameNode);
239 MenuAlign menuAlignObj;
240 menuAlignObj.alignType = static_cast<MenuAlignType>(alignType);
241 if (values != nullptr && units != nullptr && size == SIZE_OF_TWO) {
242 Dimension dx = Dimension(values[0], static_cast<OHOS::Ace::DimensionUnit>(units[0]));
243 Dimension dy = Dimension(values[1], static_cast<OHOS::Ace::DimensionUnit>(units[1]));
244
245 menuAlignObj.offset = DimensionOffset(dx, dy);
246 }
247 SelectModelNG::SetMenuAlign(frameNode, menuAlignObj);
248 }
249
SetFont(ArkUINodeHandle node,ArkUI_CharPtr fontInfo,ArkUI_Int32 styleVal)250 void SetFont(ArkUINodeHandle node, ArkUI_CharPtr fontInfo, ArkUI_Int32 styleVal)
251 {
252 auto* frameNode = reinterpret_cast<FrameNode*>(node);
253 CHECK_NULL_VOID(frameNode);
254
255 std::vector<std::string> res;
256 std::string fontValues = std::string(fontInfo);
257 StringUtils::StringSplitter(fontValues, DELIMITER, res);
258 if (res.size() != SIZE_OF_FONT_INFO) {
259 return;
260 }
261
262 auto selectTheme = GetTheme<SelectTheme>();
263 CHECK_NULL_VOID(selectTheme);
264 auto textTheme = GetTheme<TextTheme>();
265 CHECK_NULL_VOID(textTheme);
266
267 CalcDimension fontSize = selectTheme->GetFontSize();
268 if (res[0] != ERR_CODE) { // 0: index of font size data
269 fontSize = StringUtils::StringToCalcDimension(res[0], false, DimensionUnit::FP);
270 }
271 SelectModelNG::SetFontSize(frameNode, fontSize);
272
273 FontWeight weight = FontWeight::MEDIUM;
274 if (res[1] != ERR_CODE) { // 1: index of font weight data
275 weight = StringUtils::StringToFontWeight(res[1], FontWeight::MEDIUM);
276 }
277 SelectModelNG::SetFontWeight(frameNode, weight);
278
279 std::vector<std::string> fontFamilies = textTheme->GetTextStyle().GetFontFamilies();
280 if (res[2] != ERR_CODE) { // 2: index of font family data
281 fontFamilies = Framework::ConvertStrToFontFamilies(res[2]);
282 }
283 SelectModelNG::SetFontFamily(frameNode, fontFamilies);
284
285 auto style = static_cast<Ace::FontStyle>(styleVal);
286 SelectModelNG::SetItalicFontStyle(frameNode, style);
287 }
288
SetOptionFont(ArkUINodeHandle node,ArkUI_CharPtr fontInfo,ArkUI_Int32 styleVal)289 void SetOptionFont(ArkUINodeHandle node, ArkUI_CharPtr fontInfo, ArkUI_Int32 styleVal)
290 {
291 auto* frameNode = reinterpret_cast<FrameNode*>(node);
292 CHECK_NULL_VOID(frameNode);
293 std::vector<std::string> res;
294 std::string fontValues = std::string(fontInfo);
295 StringUtils::StringSplitter(fontValues, DELIMITER, res);
296 if (res.size() != SIZE_OF_FONT_INFO) {
297 return;
298 }
299
300 auto selectTheme = GetTheme<SelectTheme>();
301 CHECK_NULL_VOID(selectTheme);
302 auto textTheme = GetTheme<TextTheme>();
303 CHECK_NULL_VOID(textTheme);
304
305 CalcDimension fontSize = selectTheme->GetMenuFontSize();
306 if (res[0] != ERR_CODE) { // 0: index of font size data
307 fontSize = StringUtils::StringToCalcDimension(res[0], false, DimensionUnit::FP);
308 }
309 SelectModelNG::SetOptionFontSize(frameNode, fontSize);
310
311 FontWeight weight = textTheme->GetTextStyle().GetFontWeight();
312 if (res[1] != ERR_CODE) { // 1: index of font weight data
313 weight = StringUtils::StringToFontWeight(res[1], FontWeight::REGULAR);
314 }
315 SelectModelNG::SetOptionFontWeight(frameNode, weight);
316
317 std::vector<std::string> fontFamilies = textTheme->GetTextStyle().GetFontFamilies();
318 if (res[2] != ERR_CODE) { // 2: index of font family data
319 fontFamilies = Framework::ConvertStrToFontFamilies(res[2]);
320 }
321 SelectModelNG::SetOptionFontFamily(frameNode, fontFamilies);
322
323 auto style = static_cast<Ace::FontStyle>(styleVal);
324 SelectModelNG::SetOptionItalicFontStyle(frameNode, style);
325 }
326
SetSelectedOptionFont(ArkUINodeHandle node,ArkUI_CharPtr fontInfo,ArkUI_Int32 styleVal)327 void SetSelectedOptionFont(ArkUINodeHandle node, ArkUI_CharPtr fontInfo, ArkUI_Int32 styleVal)
328 {
329 auto* frameNode = reinterpret_cast<FrameNode*>(node);
330 CHECK_NULL_VOID(frameNode);
331 std::vector<std::string> res;
332 std::string fontValues = std::string(fontInfo);
333 StringUtils::StringSplitter(fontValues, DELIMITER, res);
334 if (res.size() != SIZE_OF_FONT_INFO) {
335 return;
336 }
337
338 auto selectTheme = GetTheme<SelectTheme>();
339 CHECK_NULL_VOID(selectTheme);
340 auto textTheme = GetTheme<TextTheme>();
341 CHECK_NULL_VOID(textTheme);
342
343 CalcDimension fontSize = selectTheme->GetFontSize();
344 if (res[0] != ERR_CODE) { // 0: index of font size data
345 fontSize = StringUtils::StringToCalcDimension(res[0], false, DimensionUnit::FP);
346 }
347 SelectModelNG::SetSelectedOptionFontSize(frameNode, fontSize);
348
349 FontWeight weight = textTheme->GetTextStyle().GetFontWeight();
350 if (res[1] != ERR_CODE) { // 1: index of font weight data
351 weight = StringUtils::StringToFontWeight(res[1], FontWeight::REGULAR);
352 }
353 SelectModelNG::SetSelectedOptionFontWeight(frameNode, weight);
354
355 std::vector<std::string> fontFamilies = textTheme->GetTextStyle().GetFontFamilies();
356 if (res[2] != ERR_CODE) { // 2: index of font family data
357 fontFamilies = Framework::ConvertStrToFontFamilies(res[2]);
358 }
359 SelectModelNG::SetSelectedOptionFontFamily(frameNode, fontFamilies);
360
361 auto style = static_cast<Ace::FontStyle>(styleVal);
362 SelectModelNG::SetSelectedOptionItalicFontStyle(frameNode, style);
363 }
364
ResetSpace(ArkUINodeHandle node)365 void ResetSpace(ArkUINodeHandle node)
366 {
367 auto* frameNode = reinterpret_cast<FrameNode*>(node);
368 CHECK_NULL_VOID(frameNode);
369 auto selectTheme = GetTheme<SelectTheme>();
370 CHECK_NULL_VOID(selectTheme);
371 Dimension space = selectTheme->GetContentSpinnerPadding();
372 SelectModelNG::SetSpace(frameNode, space);
373 }
374
ResetValue(ArkUINodeHandle node)375 void ResetValue(ArkUINodeHandle node)
376 {
377 auto* frameNode = reinterpret_cast<FrameNode*>(node);
378 CHECK_NULL_VOID(frameNode);
379 SelectModelNG::SetValue(frameNode, "");
380 if (SystemProperties::ConfigChangePerform()) {
381 SelectModelNG::CreateWithStringResourceObj(frameNode, nullptr);
382 }
383 }
384
ResetSelected(ArkUINodeHandle node)385 void ResetSelected(ArkUINodeHandle node)
386 {
387 auto* frameNode = reinterpret_cast<FrameNode*>(node);
388 CHECK_NULL_VOID(frameNode);
389 SelectModelNG::SetSelected(frameNode, DEFAULT_SELECT);
390 if (SystemProperties::ConfigChangePerform()) {
391 SelectModelNG::CreateWithIntegerResourceObj(frameNode, nullptr);
392 }
393 }
394
ResetSelectFontColor(ArkUINodeHandle node)395 void ResetSelectFontColor(ArkUINodeHandle node)
396 {
397 auto* frameNode = reinterpret_cast<FrameNode*>(node);
398 CHECK_NULL_VOID(frameNode);
399 auto selectTheme = GetTheme<SelectTheme>();
400 CHECK_NULL_VOID(selectTheme);
401 SelectModelNG::SetFontColor(frameNode, selectTheme->GetFontColor());
402 if (SystemProperties::ConfigChangePerform()) {
403 SelectModelNG::SetFontColorByUser(frameNode, false);
404 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::FONT_COLOR);
405 }
406 }
407
ResetSelectedOptionBgColor(ArkUINodeHandle node)408 void ResetSelectedOptionBgColor(ArkUINodeHandle node)
409 {
410 auto* frameNode = reinterpret_cast<FrameNode*>(node);
411 CHECK_NULL_VOID(frameNode);
412 auto selectTheme = GetTheme<SelectTheme>();
413 CHECK_NULL_VOID(selectTheme);
414 SelectModelNG::SetSelectedOptionBgColor(frameNode, selectTheme->GetSelectedColor());
415 if (SystemProperties::ConfigChangePerform()) {
416 SelectModelNG::SetSelectedOptionBgColorByUser(frameNode, false);
417 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::SELECTED_OPTION_BG_COLOR);
418 }
419 }
420
ResetOptionBgColor(ArkUINodeHandle node)421 void ResetOptionBgColor(ArkUINodeHandle node)
422 {
423 auto* frameNode = reinterpret_cast<FrameNode*>(node);
424 CHECK_NULL_VOID(frameNode);
425 auto selectTheme = GetTheme<SelectTheme>();
426 CHECK_NULL_VOID(selectTheme);
427 SelectModelNG::SetOptionBgColor(frameNode, selectTheme->GetBackgroundColor());
428 if (SystemProperties::ConfigChangePerform()) {
429 SelectModelNG::SetOptionBgColorByUser(frameNode, false);
430 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::OPTION_BG_COLOR);
431 }
432 }
433
ResetOptionFontColor(ArkUINodeHandle node)434 void ResetOptionFontColor(ArkUINodeHandle node)
435 {
436 auto* frameNode = reinterpret_cast<FrameNode*>(node);
437 CHECK_NULL_VOID(frameNode);
438 auto selectTheme = GetTheme<SelectTheme>();
439 CHECK_NULL_VOID(selectTheme);
440 SelectModelNG::SetOptionFontColor(frameNode, selectTheme->GetMenuFontColor());
441 if (SystemProperties::ConfigChangePerform()) {
442 SelectModelNG::SetOptionFontColorByUser(frameNode, false);
443 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::OPTION_FONT_COLOR);
444 }
445 }
446
ResetSelectedOptionFontColor(ArkUINodeHandle node)447 void ResetSelectedOptionFontColor(ArkUINodeHandle node)
448 {
449 auto* frameNode = reinterpret_cast<FrameNode*>(node);
450 CHECK_NULL_VOID(frameNode);
451 auto selectTheme = GetTheme<SelectTheme>();
452 CHECK_NULL_VOID(selectTheme);
453 SelectModelNG::SetSelectedOptionFontColor(frameNode, selectTheme->GetSelectedColorText());
454 if (SystemProperties::ConfigChangePerform()) {
455 SelectModelNG::SetSelectedOptionFontColorByUser(frameNode, false);
456 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::SELECTED_OPTION_FONT_COLOR);
457 }
458 }
459
ResetArrowPosition(ArkUINodeHandle node)460 void ResetArrowPosition(ArkUINodeHandle node)
461 {
462 auto* frameNode = reinterpret_cast<FrameNode*>(node);
463 CHECK_NULL_VOID(frameNode);
464 SelectModelNG::SetArrowPosition(frameNode, ArrowPosition::END);
465 }
466
ResetMenuAlign(ArkUINodeHandle node)467 void ResetMenuAlign(ArkUINodeHandle node)
468 {
469 auto* frameNode = reinterpret_cast<FrameNode*>(node);
470 CHECK_NULL_VOID(frameNode);
471 MenuAlign menuAlignObj;
472 SelectModelNG::SetMenuAlign(frameNode, menuAlignObj);
473 }
474
ResetFont(ArkUINodeHandle node)475 void ResetFont(ArkUINodeHandle node)
476 {
477 auto* frameNode = reinterpret_cast<FrameNode*>(node);
478 CHECK_NULL_VOID(frameNode);
479
480 auto selectTheme = GetTheme<SelectTheme>();
481 CHECK_NULL_VOID(selectTheme);
482 auto textTheme = GetTheme<TextTheme>();
483 CHECK_NULL_VOID(textTheme);
484
485 auto controlSize = SelectModelNG::GetControlSize(frameNode);
486 SelectModelNG::SetFontSize(frameNode, selectTheme->GetFontSize(controlSize));
487 SelectModelNG::SetFontWeight(frameNode, FontWeight::MEDIUM);
488 SelectModelNG::SetFontFamily(frameNode, textTheme->GetTextStyle().GetFontFamilies());
489 SelectModelNG::SetItalicFontStyle(frameNode, textTheme->GetTextStyle().GetFontStyle());
490 }
491
ResetOptionFont(ArkUINodeHandle node)492 void ResetOptionFont(ArkUINodeHandle node)
493 {
494 auto* frameNode = reinterpret_cast<FrameNode*>(node);
495 CHECK_NULL_VOID(frameNode);
496
497 auto selectTheme = GetTheme<SelectTheme>();
498 CHECK_NULL_VOID(selectTheme);
499 auto textTheme = GetTheme<TextTheme>();
500 CHECK_NULL_VOID(textTheme);
501
502 SelectModelNG::SetOptionFontSize(frameNode, selectTheme->GetMenuFontSize());
503 SelectModelNG::SetOptionFontWeight(frameNode, textTheme->GetTextStyle().GetFontWeight());
504 SelectModelNG::SetOptionFontFamily(frameNode, textTheme->GetTextStyle().GetFontFamilies());
505 SelectModelNG::SetOptionItalicFontStyle(frameNode, textTheme->GetTextStyle().GetFontStyle());
506 }
507
ResetSelectedOptionFont(ArkUINodeHandle node)508 void ResetSelectedOptionFont(ArkUINodeHandle node)
509 {
510 auto* frameNode = reinterpret_cast<FrameNode*>(node);
511 CHECK_NULL_VOID(frameNode);
512
513 auto selectTheme = GetTheme<SelectTheme>();
514 CHECK_NULL_VOID(selectTheme);
515 auto textTheme = GetTheme<TextTheme>();
516 CHECK_NULL_VOID(textTheme);
517
518 SelectModelNG::SetSelectedOptionFontSize(frameNode, selectTheme->GetFontSize());
519 SelectModelNG::SetSelectedOptionFontWeight(frameNode, textTheme->GetTextStyle().GetFontWeight());
520 SelectModelNG::SetSelectedOptionFontFamily(frameNode, textTheme->GetTextStyle().GetFontFamilies());
521 SelectModelNG::SetSelectedOptionItalicFontStyle(frameNode, textTheme->GetTextStyle().GetFontStyle());
522 }
523
SetSelectOptionWidthFitTrigger(ArkUINodeHandle node,ArkUI_Bool trigger)524 void SetSelectOptionWidthFitTrigger(ArkUINodeHandle node, ArkUI_Bool trigger)
525 {
526 auto* frameNode = reinterpret_cast<FrameNode*>(node);
527 CHECK_NULL_VOID(frameNode);
528 SelectModelNG::SetOptionWidthFitTrigger(frameNode, trigger);
529 }
530
SetSelectOptionWidth(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)531 void SetSelectOptionWidth(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
532 {
533 auto* frameNode = reinterpret_cast<FrameNode*>(node);
534 CHECK_NULL_VOID(frameNode);
535 Dimension optionWidth = Dimension(value, static_cast<DimensionUnit>(unit));
536 SelectModelNG::SetHasOptionWidth(frameNode, true);
537 SelectModelNG::SetOptionWidth(frameNode, optionWidth);
538 }
539
ResetSelectOptionWidth(ArkUINodeHandle node)540 void ResetSelectOptionWidth(ArkUINodeHandle node)
541 {
542 auto* frameNode = reinterpret_cast<FrameNode*>(node);
543 CHECK_NULL_VOID(frameNode);
544 Dimension optionWidth;
545 SelectModelNG::SetHasOptionWidth(frameNode, false);
546 SelectModelNG::SetOptionWidth(frameNode, optionWidth);
547 }
548
SetSelectOptionHeight(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)549 void SetSelectOptionHeight(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
550 {
551 auto* frameNode = reinterpret_cast<FrameNode*>(node);
552 CHECK_NULL_VOID(frameNode);
553 Dimension optionHeight = Dimension(value, static_cast<DimensionUnit>(unit));
554 SelectModelNG::SetOptionHeight(frameNode, optionHeight);
555 }
556
ResetSelectOptionHeight(ArkUINodeHandle node)557 void ResetSelectOptionHeight(ArkUINodeHandle node) {}
558
SetSelectWidth(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit,ArkUI_CharPtr calcValue)559 void SetSelectWidth(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit, ArkUI_CharPtr calcValue)
560 {
561 auto *frameNode = reinterpret_cast<FrameNode *>(node);
562 CHECK_NULL_VOID(frameNode);
563 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(unit);
564 if (unitEnum == DimensionUnit::CALC) {
565 ViewAbstract::SetWidth(
566 frameNode, CalcLength(CalcLength(std::string(calcValue))));
567 } else {
568 ViewAbstract::SetWidth(frameNode, CalcLength(value, unitEnum));
569 }
570 }
571
ResetSelectWidth(ArkUINodeHandle node)572 void ResetSelectWidth(ArkUINodeHandle node)
573 {
574 auto *frameNode = reinterpret_cast<FrameNode *>(node);
575 CHECK_NULL_VOID(frameNode);
576 ViewAbstract::ClearWidthOrHeight(frameNode, true);
577 }
578
SetSelectHeight(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit,ArkUI_CharPtr calcValue)579 void SetSelectHeight(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit, ArkUI_CharPtr calcValue)
580 {
581 auto *frameNode = reinterpret_cast<FrameNode *>(node);
582 CHECK_NULL_VOID(frameNode);
583 auto unitEnum = static_cast<OHOS::Ace::DimensionUnit>(unit);
584 if (unitEnum == DimensionUnit::CALC) {
585 ViewAbstract::SetHeight(
586 frameNode, CalcLength(CalcLength(std::string(calcValue))));
587 } else {
588 ViewAbstract::SetHeight(frameNode, CalcLength(value, unitEnum));
589 }
590 }
591
ResetSelectHeight(ArkUINodeHandle node)592 void ResetSelectHeight(ArkUINodeHandle node)
593 {
594 auto *frameNode = reinterpret_cast<FrameNode *>(node);
595 CHECK_NULL_VOID(frameNode);
596 ViewAbstract::ClearWidthOrHeight(frameNode, false);
597 }
598
SetSelectSize(ArkUINodeHandle node,const ArkUI_Float32 * number,const ArkUI_Int32 * unit,ArkUI_CharPtr * calc)599 void SetSelectSize(ArkUINodeHandle node, const ArkUI_Float32* number, const ArkUI_Int32* unit, ArkUI_CharPtr* calc)
600 {
601 CHECK_NULL_VOID(number);
602 CHECK_NULL_VOID(unit);
603 int32_t widthIndex = 0;
604 int32_t heightIndex = 1;
605 auto* frameNode = reinterpret_cast<FrameNode*>(node);
606 CHECK_NULL_VOID(frameNode);
607 if (*(unit + widthIndex) == static_cast<int8_t>(DimensionUnit::CALC) && *(calc + widthIndex) != nullptr) {
608 ViewAbstract::SetWidth(frameNode, CalcLength(std::string(*(calc + widthIndex))));
609 } else {
610 ViewAbstract::SetWidth(
611 frameNode, CalcLength(*(number + widthIndex), static_cast<DimensionUnit>(*(unit + widthIndex))));
612 }
613 if (*(unit + heightIndex) == static_cast<int8_t>(DimensionUnit::CALC) && *(calc + heightIndex) != nullptr) {
614 ViewAbstract::SetHeight(frameNode, CalcLength(std::string(*(calc + heightIndex))));
615 } else {
616 ViewAbstract::SetHeight(
617 frameNode, CalcLength(*(number + heightIndex), static_cast<DimensionUnit>(*(unit + heightIndex))));
618 }
619 }
620
ResetSelectSize(ArkUINodeHandle node)621 void ResetSelectSize(ArkUINodeHandle node)
622 {
623 auto* frameNode = reinterpret_cast<FrameNode*>(node);
624 CHECK_NULL_VOID(frameNode);
625 ViewAbstract::ClearWidthOrHeight(frameNode, true);
626 ViewAbstract::ClearWidthOrHeight(frameNode, false);
627 }
628
SetControlSize(ArkUINodeHandle node,ArkUI_Int32 value)629 void SetControlSize(ArkUINodeHandle node, ArkUI_Int32 value)
630 {
631 auto* frameNode = reinterpret_cast<FrameNode*>(node);
632 CHECK_NULL_VOID(frameNode);
633 auto controlSize = static_cast<ControlSize>(value);
634 SelectModelNG::SetControlSize(frameNode, controlSize);
635 }
636
ResetControlSize(ArkUINodeHandle node)637 void ResetControlSize(ArkUINodeHandle node) {}
638
SetSelectValue(ArkUINodeHandle node,ArkUI_CharPtr * values,ArkUI_CharPtr * icons,ArkUI_Uint32 length)639 void SetSelectValue(ArkUINodeHandle node, ArkUI_CharPtr* values, ArkUI_CharPtr* icons, ArkUI_Uint32 length)
640 {
641 auto* frameNode = reinterpret_cast<FrameNode*>(node);
642 CHECK_NULL_VOID(frameNode);
643 CHECK_NULL_VOID(values);
644 CHECK_NULL_VOID(icons);
645 std::vector<SelectParam> params;
646 for (uint32_t i = 0; i < length; i++) {
647 if (!values[i]) {
648 return;
649 }
650 SelectParam param;
651 param.text = values[i];
652 param.icon = icons[i];
653 params.emplace_back(param);
654 }
655 SelectModelNG::InitSelect(frameNode, params);
656 }
657
ResetSelectValue(ArkUINodeHandle node)658 void ResetSelectValue(ArkUINodeHandle node)
659 {
660 auto* frameNode = reinterpret_cast<FrameNode*>(node);
661 CHECK_NULL_VOID(frameNode);
662 std::vector<SelectParam> params;
663 SelectModelNG::InitSelect(frameNode, params);
664 }
665
SetMenuBgColor(ArkUINodeHandle node,ArkUI_Uint32 color)666 void SetMenuBgColor(ArkUINodeHandle node, ArkUI_Uint32 color)
667 {
668 auto* frameNode = reinterpret_cast<FrameNode*>(node);
669 CHECK_NULL_VOID(frameNode);
670 SelectModelNG::SetMenuBackgroundColor(frameNode, Color(color));
671 }
672
SetMenuBgColorPtr(ArkUINodeHandle node,ArkUI_Uint32 color,void * menuBgColorRawPtr)673 void SetMenuBgColorPtr(ArkUINodeHandle node, ArkUI_Uint32 color, void* menuBgColorRawPtr)
674 {
675 CHECK_NULL_VOID(node);
676 SetMenuBgColor(node, color);
677 if (SystemProperties::ConfigChangePerform()) {
678 auto* frameNode = reinterpret_cast<FrameNode*>(node);
679 CHECK_NULL_VOID(frameNode);
680 SelectModelNG::SetMenuBackgroundColorByUser(frameNode);
681 if (menuBgColorRawPtr) {
682 auto* menuBgColor = reinterpret_cast<ResourceObject*>(menuBgColorRawPtr);
683 auto menuBgColorResObj = AceType::Claim(menuBgColor);
684 SelectModelNG::CreateWithColorResourceObj(
685 frameNode, menuBgColorResObj, SelectColorType::MENU_BACKGROUND_COLOR);
686 } else {
687 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::MENU_BACKGROUND_COLOR);
688 }
689 }
690 }
691
ResetMenuBgColor(ArkUINodeHandle node)692 void ResetMenuBgColor(ArkUINodeHandle node)
693 {
694 auto* frameNode = reinterpret_cast<FrameNode*>(node);
695 CHECK_NULL_VOID(frameNode);
696 auto selectTheme = GetTheme<SelectTheme>();
697 CHECK_NULL_VOID(selectTheme);
698 SelectModelNG::SetMenuBackgroundColor(frameNode, selectTheme->GetBackgroundColor());
699 if (SystemProperties::ConfigChangePerform()) {
700 SelectModelNG::SetMenuBackgroundColorByUser(frameNode, false);
701 SelectModelNG::CreateWithColorResourceObj(frameNode, nullptr, SelectColorType::MENU_BACKGROUND_COLOR);
702 }
703 }
704
SetMenuBgBlurStyle(ArkUINodeHandle node,ArkUI_Int32 style)705 void SetMenuBgBlurStyle(ArkUINodeHandle node, ArkUI_Int32 style)
706 {
707 auto* frameNode = reinterpret_cast<FrameNode*>(node);
708 CHECK_NULL_VOID(frameNode);
709 BlurStyleOption styleOption;
710 styleOption.blurStyle = static_cast<OHOS::Ace::BlurStyle>(style);
711 SelectModelNG::SetMenuBackgroundBlurStyle(frameNode, styleOption);
712 }
713
ResetMenuBgBlurStyle(ArkUINodeHandle node)714 void ResetMenuBgBlurStyle(ArkUINodeHandle node)
715 {
716 auto* frameNode = reinterpret_cast<FrameNode*>(node);
717 CHECK_NULL_VOID(frameNode);
718 BlurStyleOption styleOption;
719 SelectModelNG::SetMenuBackgroundBlurStyle(frameNode, styleOption);
720 }
721
SetSelectDivider(ArkUINodeHandle node,ArkUI_Uint32 color,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Int32 length)722 void SetSelectDivider(ArkUINodeHandle node, ArkUI_Uint32 color, const ArkUI_Float32* values,
723 const ArkUI_Int32* units, ArkUI_Int32 length)
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::SelectDivider divider;
733 divider.color = Color(color);
734 divider.strokeWidth = Dimension(values[0], static_cast<OHOS::Ace::DimensionUnit>(units[0]));
735 divider.startMargin = Dimension(values[1], static_cast<OHOS::Ace::DimensionUnit>(units[1]));
736 divider.endMargin = Dimension(values[2], static_cast<OHOS::Ace::DimensionUnit>(units[2]));
737
738 SelectModelNG::SetDivider(frameNode, divider);
739 }
740
ResetSelectDivider(ArkUINodeHandle node)741 void ResetSelectDivider(ArkUINodeHandle node)
742 {
743 auto* frameNode = reinterpret_cast<FrameNode*>(node);
744 CHECK_NULL_VOID(frameNode);
745 auto context = frameNode->GetContext();
746 CHECK_NULL_VOID(context);
747 auto themeManager = context->GetThemeManager();
748 CHECK_NULL_VOID(themeManager);
749 auto selectTheme = themeManager->GetTheme<SelectTheme>();
750 Dimension defaultStrokeWidth = 0.0_vp;
751 Dimension defaultMargin = -1.0_vp;
752 Color defaultColor = Color::TRANSPARENT;
753 NG::SelectDivider divider;
754 if (selectTheme) {
755 defaultStrokeWidth = selectTheme->GetDefaultDividerWidth();
756 defaultColor = selectTheme->GetLineColor();
757 divider.strokeWidth = defaultStrokeWidth;
758 divider.color = defaultColor;
759 divider.startMargin = defaultMargin;
760 divider.endMargin = defaultMargin;
761 }
762 SelectModelNG::SetDivider(frameNode, divider);
763 }
764
ResetSelectDividerNull(ArkUINodeHandle node)765 void ResetSelectDividerNull(ArkUINodeHandle node)
766 {
767 auto* frameNode = reinterpret_cast<FrameNode*>(node);
768 CHECK_NULL_VOID(frameNode);
769 auto context = frameNode->GetContext();
770 CHECK_NULL_VOID(context);
771 auto themeManager = context->GetThemeManager();
772 CHECK_NULL_VOID(themeManager);
773 auto selectTheme = themeManager->GetTheme<SelectTheme>();
774 Dimension defaultStrokeWidth = 0.0_vp;
775 Dimension defaultMargin = -1.0_vp;
776 Color defaultColor = Color::TRANSPARENT;
777 NG::SelectDivider divider;
778 if (selectTheme) {
779 defaultColor = selectTheme->GetLineColor();
780 divider.strokeWidth = defaultStrokeWidth;
781 divider.color = defaultColor;
782 divider.startMargin = defaultMargin;
783 divider.endMargin = defaultMargin;
784 }
785 SelectModelNG::SetDivider(frameNode, divider);
786 }
787
SetSelectDirection(ArkUINodeHandle node,ArkUI_Int32 direction)788 void SetSelectDirection(ArkUINodeHandle node, ArkUI_Int32 direction)
789 {
790 auto* frameNode = reinterpret_cast<FrameNode*>(node);
791 CHECK_NULL_VOID(frameNode);
792 SelectModelNG::SetLayoutDirection(frameNode, static_cast<TextDirection>(direction));
793 }
794
ResetSelectDirection(ArkUINodeHandle node)795 void ResetSelectDirection(ArkUINodeHandle node)
796 {
797 auto* frameNode = reinterpret_cast<FrameNode*>(node);
798 CHECK_NULL_VOID(frameNode);
799 SelectModelNG::SetLayoutDirection(frameNode, DEFAULT_SELECT_DIRECTION);
800 }
801
SetSelectDividerStyle(ArkUINodeHandle node,ArkUIMenuDividerOptions * dividerInfo)802 void SetSelectDividerStyle(ArkUINodeHandle node, ArkUIMenuDividerOptions* dividerInfo)
803 {
804 auto* frameNode = reinterpret_cast<FrameNode*>(node);
805 CHECK_NULL_VOID(frameNode);
806
807 NG::SelectDivider divider;
808 divider.isDividerStyle = true;
809 divider.strokeWidth = Dimension(dividerInfo->strokeWidth.value,
810 static_cast<OHOS::Ace::DimensionUnit>(dividerInfo->strokeWidth.units));
811 divider.color = Color(dividerInfo->color);
812 divider.startMargin = Dimension(dividerInfo->startMargin.value,
813 static_cast<OHOS::Ace::DimensionUnit>(dividerInfo->startMargin.units));
814 divider.endMargin = Dimension(dividerInfo->endMargin.value,
815 static_cast<OHOS::Ace::DimensionUnit>(dividerInfo->endMargin.units));
816 DividerMode mode = dividerInfo->mode == 1 ? DividerMode::EMBEDDED_IN_MENU: DividerMode::FLOATING_ABOVE_MENU;
817 SelectModelNG::SetDividerStyle(frameNode, divider, mode);
818 }
819
ResetSelectDividerStyle(ArkUINodeHandle node)820 void ResetSelectDividerStyle(ArkUINodeHandle node)
821 {
822 auto* frameNode = reinterpret_cast<FrameNode*>(node);
823 SelectModelNG::ResetDividerStyle(frameNode);
824 }
825
SetOnSelectExt(ArkUINodeHandle node,void (* eventReceiver)(ArkUINodeHandle node,int32_t index,ArkUI_CharPtr text))826 void SetOnSelectExt(ArkUINodeHandle node, void (*eventReceiver)(ArkUINodeHandle node,
827 int32_t index, ArkUI_CharPtr text))
828 {
829 auto* uiNode = reinterpret_cast<UINode*>(node);
830 CHECK_NULL_VOID(uiNode);
831 auto onSelect = [node, eventReceiver](int32_t index, const std::string& text) {
832 eventReceiver(node, index, text.c_str());
833 };
834 SelectModelNG::SetOnSelect(reinterpret_cast<FrameNode*>(node), std::move(onSelect));
835 }
836
SetOptionalBorder(std::optional<Dimension> & optionalDimension,const ArkUI_Float32 * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)837 void SetOptionalBorder(std::optional<Dimension>& optionalDimension, const ArkUI_Float32* values, ArkUI_Int32 valuesSize,
838 ArkUI_Int32& offset)
839 {
840 bool hasValue = static_cast<bool>(values[offset]);
841 if (hasValue) {
842 optionalDimension = Dimension(
843 values[offset + OFFSET_OF_VALUE], static_cast<OHOS::Ace::DimensionUnit>(values[offset + OFFSET_OF_UNIT]));
844 }
845 offset = offset + OFFSET_OF_NEXT;
846 }
847
SetOptionalBorderColor(std::optional<Color> & optionalColor,const uint32_t * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)848 void SetOptionalBorderColor(
849 std::optional<Color>& optionalColor, const uint32_t* values, ArkUI_Int32 valuesSize, ArkUI_Int32& offset)
850 {
851 optionalColor = Color(values[offset + OFFSET_OF_VALUE]);
852 offset = offset + OFFSET_OF_UNIT;
853 }
854
SetMenuOutline(ArkUINodeHandle node,const ArkUI_Float32 * width,ArkUI_Int32 widthSize,const ArkUI_Uint32 * color,ArkUI_Int32 colorSize)855 void SetMenuOutline(ArkUINodeHandle node, const ArkUI_Float32* width, ArkUI_Int32 widthSize, const ArkUI_Uint32* color,
856 ArkUI_Int32 colorSize)
857 {
858 auto* frameNode = reinterpret_cast<FrameNode*>(node);
859 CHECK_NULL_VOID(frameNode);
860 if ((width == nullptr) || (widthSize != SIZE_OF_WIDTH_ARRAY) || (color == nullptr) ||
861 colorSize != SIZE_OF_COLOR_ARRAY) {
862 return;
863 }
864 MenuParam menuParam;
865 int32_t widthoffset = 0;
866 NG::BorderWidthProperty borderWidth;
867 SetOptionalBorder(borderWidth.leftDimen, width, widthSize, widthoffset);
868 SetOptionalBorder(borderWidth.rightDimen, width, widthSize, widthoffset);
869 SetOptionalBorder(borderWidth.topDimen, width, widthSize, widthoffset);
870 SetOptionalBorder(borderWidth.bottomDimen, width, widthSize, widthoffset);
871 menuParam.outlineWidth = borderWidth;
872
873 int32_t colorOffset = 0;
874 NG::BorderColorProperty borderColors;
875 SetOptionalBorderColor(borderColors.leftColor, color, colorSize, colorOffset);
876 SetOptionalBorderColor(borderColors.rightColor, color, colorSize, colorOffset);
877 SetOptionalBorderColor(borderColors.topColor, color, colorSize, colorOffset);
878 SetOptionalBorderColor(borderColors.bottomColor, color, colorSize, colorOffset);
879 menuParam.outlineColor = borderColors;
880 SelectModelNG::SetMenuOutline(frameNode, menuParam);
881 }
882
ResetMenuOutline(ArkUINodeHandle node)883 void ResetMenuOutline(ArkUINodeHandle node)
884 {
885 auto* frameNode = reinterpret_cast<FrameNode*>(node);
886 CHECK_NULL_VOID(frameNode);
887 MenuParam menuParam;
888 SelectModelNG::SetMenuOutline(frameNode, menuParam);
889 }
890
SetSelectSymbolValue(ArkUINodeHandle node,ArkUI_CharPtr * values,void ** symbolFunction,ArkUI_Uint32 length)891 void SetSelectSymbolValue(ArkUINodeHandle node, ArkUI_CharPtr* values,
892 void** symbolFunction, ArkUI_Uint32 length)
893 {
894 auto* frameNode = reinterpret_cast<FrameNode*>(node);
895 CHECK_NULL_VOID(frameNode);
896 CHECK_NULL_VOID(values);
897
898 std::vector<SelectParam> params(length);
899 for (uint32_t i = 0; i < length; i++) {
900 if (values[i] == nullptr) {
901 return;
902 }
903 params[i].text = values[i];
904 if (symbolFunction != nullptr && symbolFunction[i] != nullptr) {
905 auto symbolCallback = reinterpret_cast<std::function<void(WeakPtr<NG::FrameNode>)>*>(symbolFunction[i]);
906 params[i].symbolIcon = *symbolCallback;
907 }
908 }
909 SelectModelNG::InitSelect(frameNode, params);
910 }
911
SetArrowColor(ArkUINodeHandle node,const ArkUI_Uint32 arrowColor)912 void SetArrowColor(ArkUINodeHandle node, const ArkUI_Uint32 arrowColor)
913 {
914 auto* frameNode = reinterpret_cast<FrameNode*>(node);
915 CHECK_NULL_VOID(frameNode);
916 SelectModelNG::SetArrowColor(frameNode, Color(arrowColor));
917 }
918
SetShowDefaultSelectedIcon(ArkUINodeHandle node,ArkUI_Bool show)919 void SetShowDefaultSelectedIcon(ArkUINodeHandle node, ArkUI_Bool show)
920 {
921 auto* frameNode = reinterpret_cast<FrameNode*>(node);
922 CHECK_NULL_VOID(frameNode);
923 SelectModelNG::SetShowDefaultSelectedIcon(frameNode, show);
924 }
925
SetAvoidance(ArkUINodeHandle node,ArkUI_Int32 modeValue)926 void SetAvoidance(ArkUINodeHandle node, ArkUI_Int32 modeValue)
927 {
928 auto* frameNode = reinterpret_cast<FrameNode*>(node);
929 CHECK_NULL_VOID(frameNode);
930 AvoidanceMode mode = AvoidanceMode::COVER_TARGET;
931 switch (modeValue) {
932 case static_cast<ArkUI_Int32>(OHOS::Ace::AvoidanceMode::COVER_TARGET):
933 mode = OHOS::Ace::AvoidanceMode::COVER_TARGET;
934 break;
935 case static_cast<ArkUI_Int32>(OHOS::Ace::AvoidanceMode::AVOID_AROUND_TARGET):
936 mode = OHOS::Ace::AvoidanceMode::AVOID_AROUND_TARGET;
937 break;
938 default:
939 break;
940 }
941 SelectModelNG::SetAvoidance(frameNode, mode);
942 }
943
ResetAvoidance(ArkUINodeHandle node)944 void ResetAvoidance(ArkUINodeHandle node)
945 {
946 auto* frameNode = reinterpret_cast<FrameNode*>(node);
947 CHECK_NULL_VOID(frameNode);
948 SelectModelNG::SetAvoidance(frameNode, AvoidanceMode::COVER_TARGET);
949 }
950
951 namespace NodeModifier {
GetSelectModifier()952 const ArkUISelectModifier* GetSelectModifier()
953 {
954 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
955 static const ArkUISelectModifier modifier = {
956 .setSpace = SetSpace,
957 .setValue = SetValue,
958 .setSelected = SetSelected,
959 .setSelectFontColor = SetSelectFontColor,
960 .setSelectedOptionBgColor = SetSelectedOptionBgColor,
961 .setOptionBgColor = SetOptionBgColor,
962 .setOptionFontColor = SetOptionFontColor,
963 .setSelectedOptionFontColor = SetSelectedOptionFontColor,
964 .setArrowPosition = SetArrowPosition,
965 .setMenuAlign = SetMenuAlign,
966 .setFont = SetFont,
967 .setOptionFont = SetOptionFont,
968 .setSelectedOptionFont = SetSelectedOptionFont,
969 .resetSpace = ResetSpace,
970 .resetValue = ResetValue,
971 .resetSelected = ResetSelected,
972 .resetSelectFontColor = ResetSelectFontColor,
973 .resetSelectedOptionBgColor = ResetSelectedOptionBgColor,
974 .resetOptionBgColor = ResetOptionBgColor,
975 .resetOptionFontColor = ResetOptionFontColor,
976 .resetSelectedOptionFontColor = ResetSelectedOptionFontColor,
977 .resetArrowPosition = ResetArrowPosition,
978 .resetMenuAlign = ResetMenuAlign,
979 .resetFont = ResetFont,
980 .resetOptionFont = ResetOptionFont,
981 .resetSelectedOptionFont = ResetSelectedOptionFont,
982 .setSelectWidth = SetSelectWidth,
983 .resetSelectWidth = ResetSelectWidth,
984 .setSelectHeight = SetSelectHeight,
985 .resetSelectHeight = ResetSelectHeight,
986 .setSelectSize = SetSelectSize,
987 .resetSelectSize = ResetSelectSize,
988 .setOptionWidthFitTrigger = SetSelectOptionWidthFitTrigger,
989 .setSelectOptionWidth = SetSelectOptionWidth,
990 .resetSelectOptionWidth = ResetSelectOptionWidth,
991 .setSelectOptionHeight = SetSelectOptionHeight,
992 .resetSelectOptionHeight = ResetSelectOptionHeight,
993 .setControlSize = SetControlSize,
994 .resetControlSize = ResetControlSize,
995 .setSelectValue = SetSelectValue,
996 .resetSelectValue = ResetSelectValue,
997 .setMenuBgColor = SetMenuBgColor,
998 .resetMenuBgColor = ResetMenuBgColor,
999 .setMenuBgBlurStyle = SetMenuBgBlurStyle,
1000 .resetMenuBgBlurStyle = ResetMenuBgBlurStyle,
1001 .setSelectDivider = SetSelectDivider,
1002 .resetSelectDivider = ResetSelectDivider,
1003 .resetSelectDividerNull = ResetSelectDividerNull,
1004 .setSelectDirection = SetSelectDirection,
1005 .resetSelectDirection = ResetSelectDirection,
1006 .setSelectDividerStyle = SetSelectDividerStyle,
1007 .resetSelectDividerStyle = ResetSelectDividerStyle,
1008 .setAvoidance = SetAvoidance,
1009 .resetAvoidance = ResetAvoidance,
1010 .setOnSelect = SetOnSelectExt,
1011 .setMenuOutline = SetMenuOutline,
1012 .resetMenuOutline = ResetMenuOutline,
1013 .setSelectSymbolValue = SetSelectSymbolValue,
1014 .setValuePtr = SetValuePtr,
1015 .setSelectedPtr = SetSelectedPtr,
1016 .setSelectFontColorPtr = SetSelectFontColorPtr,
1017 .setSelectedOptionBgColorPtr = SetSelectedOptionBgColorPtr,
1018 .setOptionBgColorPtr = SetOptionBgColorPtr,
1019 .setOptionFontColorPtr = SetOptionFontColorPtr,
1020 .setSelectedOptionFontColorPtr = SetSelectedOptionFontColorPtr,
1021 .setMenuBgColorPtr = SetMenuBgColorPtr,
1022 .setArrowColor = SetArrowColor,
1023 .setShowDefaultSelectedIcon = SetShowDefaultSelectedIcon,
1024 };
1025 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1026
1027 return &modifier;
1028 }
1029
GetCJUISelectModifier()1030 const CJUISelectModifier* GetCJUISelectModifier()
1031 {
1032 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1033 static const CJUISelectModifier modifier = {
1034 .setSpace = SetSpace,
1035 .setValue = SetValue,
1036 .setSelected = SetSelected,
1037 .setSelectFontColor = SetSelectFontColor,
1038 .setSelectedOptionBgColor = SetSelectedOptionBgColor,
1039 .setOptionBgColor = SetOptionBgColor,
1040 .setOptionFontColor = SetOptionFontColor,
1041 .setSelectedOptionFontColor = SetSelectedOptionFontColor,
1042 .setArrowPosition = SetArrowPosition,
1043 .setMenuAlign = SetMenuAlign,
1044 .setFont = SetFont,
1045 .setOptionFont = SetOptionFont,
1046 .setSelectedOptionFont = SetSelectedOptionFont,
1047 .resetSpace = ResetSpace,
1048 .resetValue = ResetValue,
1049 .resetSelected = ResetSelected,
1050 .resetSelectFontColor = ResetSelectFontColor,
1051 .resetSelectedOptionBgColor = ResetSelectedOptionBgColor,
1052 .resetOptionBgColor = ResetOptionBgColor,
1053 .resetOptionFontColor = ResetOptionFontColor,
1054 .resetSelectedOptionFontColor = ResetSelectedOptionFontColor,
1055 .resetArrowPosition = ResetArrowPosition,
1056 .resetMenuAlign = ResetMenuAlign,
1057 .resetFont = ResetFont,
1058 .resetOptionFont = ResetOptionFont,
1059 .resetSelectedOptionFont = ResetSelectedOptionFont,
1060 .setSelectWidth = SetSelectWidth,
1061 .resetSelectWidth = ResetSelectWidth,
1062 .setSelectHeight = SetSelectHeight,
1063 .resetSelectHeight = ResetSelectHeight,
1064 .setSelectSize = SetSelectSize,
1065 .resetSelectSize = ResetSelectSize,
1066 .setOptionWidthFitTrigger = SetSelectOptionWidthFitTrigger,
1067 .setSelectOptionWidth = SetSelectOptionWidth,
1068 .resetSelectOptionWidth = ResetSelectOptionWidth,
1069 .setSelectOptionHeight = SetSelectOptionHeight,
1070 .resetSelectOptionHeight = ResetSelectOptionHeight,
1071 .setControlSize = SetControlSize,
1072 .resetControlSize = ResetControlSize,
1073 .setMenuBgColor = SetMenuBgColor,
1074 .resetMenuBgColor = ResetMenuBgColor,
1075 .setMenuBgBlurStyle = SetMenuBgBlurStyle,
1076 .resetMenuBgBlurStyle = ResetMenuBgBlurStyle,
1077 .setSelectValue = SetSelectValue,
1078 .resetSelectValue = ResetSelectValue,
1079 .setSelectDivider = SetSelectDivider,
1080 .resetSelectDivider = ResetSelectDivider,
1081 .resetSelectDividerNull = ResetSelectDividerNull,
1082 .setSelectDirection = SetSelectDirection,
1083 .resetSelectDirection = ResetSelectDirection,
1084 .setAvoidance = SetAvoidance,
1085 .resetAvoidance = ResetAvoidance,
1086 .setMenuOutline = SetMenuOutline,
1087 .resetMenuOutline = ResetMenuOutline,
1088 };
1089 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1090
1091 return &modifier;
1092 }
1093
SetOnSelectSelect(ArkUINodeHandle node,void * extraParam)1094 void SetOnSelectSelect(ArkUINodeHandle node, void* extraParam)
1095 {
1096 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1097 CHECK_NULL_VOID(frameNode);
1098 auto onEvent = [node, extraParam](int32_t index, const std::string& value) {
1099 ArkUINodeEvent event;
1100 event.kind = TEXT_ARRAY;
1101 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1102 auto indexStr = std::to_string(index);
1103 const char* arrayValue[] = {value.c_str(), indexStr.c_str()};
1104 event.textArrayEvent.subKind = ON_SELECT_SELECT;
1105 event.textArrayEvent.nativeStringArrayPtr = reinterpret_cast<intptr_t>(arrayValue);
1106 SendArkUISyncEvent(&event);
1107 };
1108 SelectModelNG::SetOnSelect(frameNode, std::move(onEvent));
1109 }
1110 }
1111 } // namespace OHOS::Ace::NG
1112