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/node_slider_modifier.h"
16 
17 #include "core/components_ng/pattern/slider/slider_model_ng.h"
18 #include "core/components/common/layout/constants.h"
19 #include "core/components/slider/slider_theme.h"
20 #include "core/components_ng/base/frame_node.h"
21 #include "core/interfaces/arkoala/arkoala_api.h"
22 #include "core/pipeline/base/element_register.h"
23 #include "core/pipeline_ng/pipeline_context.h"
24 
25 namespace OHOS::Ace::NG {
26 const bool DEFAULT_SHOW_STEPS = false;
27 const bool DEFAULT_SHOW_TIPS = false;
28 const std::vector<SliderModel::SliderMode> SLIDER_MODE = { SliderModel::SliderMode::OUTSET,
29     SliderModel::SliderMode::INSET, SliderModel::SliderMode::NONE, SliderModel::SliderMode::CAPSULE, };
30 const std::vector<SliderModel::BlockStyleType> SLIDER_STYLE_TYPE = { SliderModel::BlockStyleType::DEFAULT,
31     SliderModel::BlockStyleType::IMAGE, SliderModel::BlockStyleType::SHAPE };
32 std::map<SliderModel::SliderMode, int> SLIDER_MODE_MAP = {
33     { SliderModel::SliderMode::OUTSET, 0 },
34     { SliderModel::SliderMode::INSET, 1 },
35     { SliderModel::SliderMode::NONE, 2 },
36     { SliderModel::SliderMode::CAPSULE, 3 } };
37 std::map<SliderModel::BlockStyleType, int> SLIDER_STYLE_TYPE_MAP = {
38     { SliderModel::BlockStyleType::DEFAULT, 0 },
39     { SliderModel::BlockStyleType::IMAGE, 1 },
40     { SliderModel::BlockStyleType::SHAPE, 2 } };
41 
42 std::map<BasicShapeType, int> SHAPE_TYPE_MAP = {
43     { BasicShapeType::RECT, 0 },
44     { BasicShapeType::CIRCLE, 1 },
45     { BasicShapeType::ELLIPSE, 2 },
46     { BasicShapeType::PATH, 3 } };
47 
48 const float DEFAULT_VALUE = 0.0;
49 const float DEFAULT_MAX_VALUE = 100.0;
50 const float DEFAULT_MIN_VALUE = 0.0;
51 const float DEFAULT_STEP_VALUE = 1.0;
52 
53 const uint32_t ERROR_UINT_CODE = -1;
54 const float ERROR_FLOAT_CODE = -1.0f;
55 const int32_t ERROR_INT_CODE = -1;
56 namespace SliderModifier {
57 
58 std::string g_strValue;
59 
SetShowTips(ArkUINodeHandle node,ArkUI_Bool isShow,const char * value)60 void SetShowTips(ArkUINodeHandle node, ArkUI_Bool isShow, const char *value)
61 {
62     auto *frameNode = reinterpret_cast<FrameNode *>(node);
63     CHECK_NULL_VOID(frameNode);
64     std::optional<std::string> content;
65 
66     if (value == nullptr) {
67         content = std::nullopt;
68     } else {
69         content = std::string(value);
70     }
71     SliderModelNG::SetShowTips(frameNode, static_cast<bool>(isShow), content);
72 }
73 
ResetShowTips(ArkUINodeHandle node)74 void ResetShowTips(ArkUINodeHandle node)
75 {
76     auto *frameNode = reinterpret_cast<FrameNode *>(node);
77     CHECK_NULL_VOID(frameNode);
78     std::optional<std::string> content;
79     SliderModelNG::SetShowTips(frameNode, DEFAULT_SHOW_TIPS, content);
80 }
81 
SetSliderStepSize(ArkUINodeHandle node,ArkUI_Float32 value,int unit)82 void SetSliderStepSize(ArkUINodeHandle node, ArkUI_Float32 value, int unit)
83 {
84     auto *frameNode = reinterpret_cast<FrameNode *>(node);
85     CHECK_NULL_VOID(frameNode);
86     Dimension size = Dimension(static_cast<double>(value),
87     static_cast<OHOS::Ace::DimensionUnit>(unit));
88     SliderModelNG::SetStepSize(frameNode, size);
89 }
90 
ResetSliderStepSize(ArkUINodeHandle node)91 void ResetSliderStepSize(ArkUINodeHandle node)
92 {
93     auto *frameNode = reinterpret_cast<FrameNode *>(node);
94     CHECK_NULL_VOID(frameNode);
95 
96     auto pipelineContext = frameNode->GetContext();
97     CHECK_NULL_VOID(pipelineContext);
98     auto theme = pipelineContext->GetTheme<SliderTheme>();
99 
100     Dimension stepSize = theme->GetMarkerSize();
101     SliderModelNG::SetStepSize(frameNode, stepSize);
102 }
103 
SetBlockSize(ArkUINodeHandle node,ArkUI_Float32 widthVal,int widthUnit,ArkUI_Float32 heightVal,int heightUnit)104 void SetBlockSize(ArkUINodeHandle node, ArkUI_Float32 widthVal,
105     int widthUnit, ArkUI_Float32 heightVal, int heightUnit)
106 {
107     auto *frameNode = reinterpret_cast<FrameNode *>(node);
108     CHECK_NULL_VOID(frameNode);
109     Dimension blockWidth = Dimension(static_cast<double>(widthVal),
110     static_cast<OHOS::Ace::DimensionUnit>(widthUnit));
111     Dimension blockHeight = Dimension(static_cast<double>(heightVal),
112     static_cast<OHOS::Ace::DimensionUnit>(heightUnit));
113 
114     if (LessNotEqual(blockWidth.Value(), 0.0)) {
115         blockWidth.SetValue(0.0);
116     }
117     if (LessNotEqual(blockHeight.Value(), 0.0)) {
118         blockHeight.SetValue(0.0);
119     }
120     SliderModelNG::SetBlockSize(frameNode, blockWidth, blockHeight);
121 }
122 
ResetBlockSize(ArkUINodeHandle node)123 void ResetBlockSize(ArkUINodeHandle node)
124 {
125     auto *frameNode = reinterpret_cast<FrameNode *>(node);
126     CHECK_NULL_VOID(frameNode);
127     SliderModelNG::ResetBlockSize(frameNode);
128 }
129 
SetTrackBorderRadius(ArkUINodeHandle node,float value,int unit)130 void SetTrackBorderRadius(ArkUINodeHandle node, float value, int unit)
131 {
132     auto *frameNode = reinterpret_cast<FrameNode *>(node);
133     CHECK_NULL_VOID(frameNode);
134     Dimension radius =
135         Dimension(static_cast<double>(value), static_cast<OHOS::Ace::DimensionUnit>(unit));
136     SliderModelNG::SetTrackBorderRadius(frameNode, radius);
137 }
138 
ResetTrackBorderRadius(ArkUINodeHandle node)139 void ResetTrackBorderRadius(ArkUINodeHandle node)
140 {
141     auto *frameNode = reinterpret_cast<FrameNode *>(node);
142     CHECK_NULL_VOID(frameNode);
143     SliderModelNG::ResetTrackBorderRadius(frameNode);
144 }
145 
SetStepColor(ArkUINodeHandle node,uint32_t color)146 void SetStepColor(ArkUINodeHandle node, uint32_t color)
147 {
148     auto *frameNode = reinterpret_cast<FrameNode *>(node);
149     CHECK_NULL_VOID(frameNode);
150     SliderModelNG::SetStepColor(frameNode, Color(color));
151 }
152 
ResetStepColor(ArkUINodeHandle node)153 void ResetStepColor(ArkUINodeHandle node)
154 {
155     auto *frameNode = reinterpret_cast<FrameNode *>(node);
156     CHECK_NULL_VOID(frameNode);
157     SliderModelNG::ResetStepColor(frameNode);
158 }
159 
SetBlockBorderColor(ArkUINodeHandle node,uint32_t color)160 void SetBlockBorderColor(ArkUINodeHandle node, uint32_t color)
161 {
162     auto *frameNode = reinterpret_cast<FrameNode *>(node);
163     CHECK_NULL_VOID(frameNode);
164     SliderModelNG::SetBlockBorderColor(frameNode, Color(color));
165 }
166 
ResetBlockBorderColor(ArkUINodeHandle node)167 void ResetBlockBorderColor(ArkUINodeHandle node)
168 {
169     auto *frameNode = reinterpret_cast<FrameNode *>(node);
170     CHECK_NULL_VOID(frameNode);
171     SliderModelNG::ResetBlockBorderColor(frameNode);
172 }
173 
SetBlockBorderWidth(ArkUINodeHandle node,ArkUI_Float32 value,int unit)174 void SetBlockBorderWidth(ArkUINodeHandle node, ArkUI_Float32 value, int unit)
175 {
176     auto *frameNode = reinterpret_cast<FrameNode *>(node);
177     CHECK_NULL_VOID(frameNode);
178     Dimension width =
179         Dimension(static_cast<double>(value), static_cast<OHOS::Ace::DimensionUnit>(unit));
180     SliderModelNG::SetBlockBorderWidth(frameNode, width);
181 }
182 
ResetBlockBorderWidth(ArkUINodeHandle node)183 void ResetBlockBorderWidth(ArkUINodeHandle node)
184 {
185     auto *frameNode = reinterpret_cast<FrameNode *>(node);
186     CHECK_NULL_VOID(frameNode);
187     SliderModelNG::ResetBlockBorderWidth(frameNode);
188 }
189 
SetBlockColor(ArkUINodeHandle node,uint32_t color)190 void SetBlockColor(ArkUINodeHandle node, uint32_t color)
191 {
192     auto *frameNode = reinterpret_cast<FrameNode *>(node);
193     CHECK_NULL_VOID(frameNode);
194     SliderModelNG::SetBlockColor(frameNode, Color(color));
195 }
196 
ResetBlockColor(ArkUINodeHandle node)197 void ResetBlockColor(ArkUINodeHandle node)
198 {
199     auto *frameNode = reinterpret_cast<FrameNode *>(node);
200     CHECK_NULL_VOID(frameNode);
201     SliderModelNG::ResetBlockColor(frameNode);
202 }
203 
SetTrackBackgroundColor(ArkUINodeHandle node,uint32_t color)204 void SetTrackBackgroundColor(ArkUINodeHandle node, uint32_t color)
205 {
206     auto *frameNode = reinterpret_cast<FrameNode *>(node);
207     CHECK_NULL_VOID(frameNode);
208     SliderModelNG::SetTrackBackgroundColor(frameNode, SliderModelNG::CreateSolidGradient(Color(color)), true);
209 }
210 
ResetTrackBackgroundColor(ArkUINodeHandle node)211 void ResetTrackBackgroundColor(ArkUINodeHandle node)
212 {
213     auto *frameNode = reinterpret_cast<FrameNode *>(node);
214     CHECK_NULL_VOID(frameNode);
215     auto pipelineContext = frameNode->GetContext();
216     CHECK_NULL_VOID(pipelineContext);
217     auto theme = pipelineContext->GetTheme<SliderTheme>();
218     CHECK_NULL_VOID(theme);
219 
220     SliderModelNG::SetTrackBackgroundColor(
221         frameNode, SliderModelNG::CreateSolidGradient(theme->GetTrackBgColor()), true);
222 }
223 
SetSelectColor(ArkUINodeHandle node,uint32_t color)224 void SetSelectColor(ArkUINodeHandle node, uint32_t color)
225 {
226     auto *frameNode = reinterpret_cast<FrameNode *>(node);
227     CHECK_NULL_VOID(frameNode);
228     SliderModelNG::SetSelectColor(frameNode, Color(color));
229 }
230 
ResetSelectColor(ArkUINodeHandle node)231 void ResetSelectColor(ArkUINodeHandle node)
232 {
233     auto *frameNode = reinterpret_cast<FrameNode *>(node);
234     CHECK_NULL_VOID(frameNode);
235     auto pipelineContext = frameNode->GetContext();
236     CHECK_NULL_VOID(pipelineContext);
237     auto theme = pipelineContext->GetTheme<SliderTheme>();
238     CHECK_NULL_VOID(theme);
239     SliderModelNG::SetSelectColor(frameNode, theme->GetTrackSelectedColor());
240 }
241 
SetShowSteps(ArkUINodeHandle node,int showSteps)242 void SetShowSteps(ArkUINodeHandle node, int showSteps)
243 {
244     auto *frameNode = reinterpret_cast<FrameNode *>(node);
245     CHECK_NULL_VOID(frameNode);
246     SliderModelNG::SetShowSteps(frameNode, static_cast<bool>(showSteps));
247 }
248 
ResetShowSteps(ArkUINodeHandle node)249 void ResetShowSteps(ArkUINodeHandle node)
250 {
251     auto *frameNode = reinterpret_cast<FrameNode *>(node);
252     CHECK_NULL_VOID(frameNode);
253     SliderModelNG::SetShowSteps(frameNode, DEFAULT_SHOW_STEPS);
254 }
255 
SetThickness(ArkUINodeHandle node,ArkUI_Float32 value,int unit)256 void SetThickness(ArkUINodeHandle node, ArkUI_Float32 value, int unit)
257 {
258     auto *frameNode = reinterpret_cast<FrameNode *>(node);
259     CHECK_NULL_VOID(frameNode);
260     Dimension thickness =
261         Dimension(static_cast<double>(value), static_cast<OHOS::Ace::DimensionUnit>(unit));
262     SliderModelNG::SetThickness(frameNode, thickness);
263 }
264 
ResetThickness(ArkUINodeHandle node)265 void ResetThickness(ArkUINodeHandle node)
266 {
267     auto *frameNode = reinterpret_cast<FrameNode *>(node);
268     CHECK_NULL_VOID(frameNode);
269     SliderModelNG::SetThickness(frameNode, CalcDimension(0.0));
270 }
271 
SetSliderValue(ArkUINodeHandle node,float value)272 void SetSliderValue(ArkUINodeHandle node, float value)
273 {
274     auto *frameNode = reinterpret_cast<FrameNode *>(node);
275     CHECK_NULL_VOID(frameNode);
276     SliderModelNG::SetSliderValue(frameNode, value);
277 }
278 
SetMinLabel(ArkUINodeHandle node,float value)279 void SetMinLabel(ArkUINodeHandle node, float value)
280 {
281     auto *frameNode = reinterpret_cast<FrameNode *>(node);
282     CHECK_NULL_VOID(frameNode);
283     SliderModelNG::SetMinLabel(frameNode, value);
284 }
285 
SetMaxLabel(ArkUINodeHandle node,float value)286 void SetMaxLabel(ArkUINodeHandle node, float value)
287 {
288     auto *frameNode = reinterpret_cast<FrameNode *>(node);
289     CHECK_NULL_VOID(frameNode);
290     SliderModelNG::SetMaxLabel(frameNode, value);
291 }
292 
SetDirection(ArkUINodeHandle node,int value)293 void SetDirection(ArkUINodeHandle node, int value)
294 {
295     auto *frameNode = reinterpret_cast<FrameNode *>(node);
296     CHECK_NULL_VOID(frameNode);
297     SliderModelNG::SetDirection(frameNode, static_cast<Axis>(value));
298 }
299 
SetStep(ArkUINodeHandle node,float value)300 void SetStep(ArkUINodeHandle node, float value)
301 {
302     auto *frameNode = reinterpret_cast<FrameNode *>(node);
303     CHECK_NULL_VOID(frameNode);
304     SliderModelNG::SetStep(frameNode, value);
305 }
306 
SetReverse(ArkUINodeHandle node,int value)307 void SetReverse(ArkUINodeHandle node, int value)
308 {
309     auto *frameNode = reinterpret_cast<FrameNode *>(node);
310     CHECK_NULL_VOID(frameNode);
311     SliderModelNG::SetReverse(frameNode, static_cast<bool>(value));
312 }
313 
SetSliderStyle(ArkUINodeHandle node,int value)314 void SetSliderStyle(ArkUINodeHandle node, int value)
315 {
316     auto *frameNode = reinterpret_cast<FrameNode *>(node);
317     CHECK_NULL_VOID(frameNode);
318     if (value >= static_cast<int32_t>(SLIDER_MODE.size())) {
319         return;
320     }
321     SliderModelNG::SetSliderMode(frameNode, SLIDER_MODE[value]);
322 }
323 
ResetSliderValue(ArkUINodeHandle node)324 void ResetSliderValue(ArkUINodeHandle node)
325 {
326     auto *frameNode = reinterpret_cast<FrameNode *>(node);
327     CHECK_NULL_VOID(frameNode);
328     SliderModelNG::SetSliderValue(frameNode, DEFAULT_VALUE);
329 }
330 
ResetMinLabel(ArkUINodeHandle node)331 void ResetMinLabel(ArkUINodeHandle node)
332 {
333     auto *frameNode = reinterpret_cast<FrameNode *>(node);
334     CHECK_NULL_VOID(frameNode);
335     SliderModelNG::SetMinLabel(frameNode, DEFAULT_MIN_VALUE);
336 }
337 
ResetMaxLabel(ArkUINodeHandle node)338 void ResetMaxLabel(ArkUINodeHandle node)
339 {
340     auto *frameNode = reinterpret_cast<FrameNode *>(node);
341     CHECK_NULL_VOID(frameNode);
342     SliderModelNG::SetMaxLabel(frameNode, DEFAULT_MAX_VALUE);
343 }
344 
ResetDirection(ArkUINodeHandle node)345 void ResetDirection(ArkUINodeHandle node)
346 {
347     auto *frameNode = reinterpret_cast<FrameNode *>(node);
348     CHECK_NULL_VOID(frameNode);
349     SliderModelNG::SetDirection(frameNode, Axis::HORIZONTAL);
350 }
351 
ResetStep(ArkUINodeHandle node)352 void ResetStep(ArkUINodeHandle node)
353 {
354     auto *frameNode = reinterpret_cast<FrameNode *>(node);
355     CHECK_NULL_VOID(frameNode);
356     SliderModelNG::SetStep(frameNode, DEFAULT_STEP_VALUE);
357 }
358 
ResetReverse(ArkUINodeHandle node)359 void ResetReverse(ArkUINodeHandle node)
360 {
361     auto *frameNode = reinterpret_cast<FrameNode *>(node);
362     CHECK_NULL_VOID(frameNode);
363     SliderModelNG::SetReverse(frameNode, false);
364 }
365 
ResetSliderStyle(ArkUINodeHandle node)366 void ResetSliderStyle(ArkUINodeHandle node)
367 {
368     auto *frameNode = reinterpret_cast<FrameNode *>(node);
369     CHECK_NULL_VOID(frameNode);
370     SliderModelNG::SetSliderMode(frameNode, SliderModel::SliderMode::OUTSET);
371 }
372 
SetSliderBlockImage(ArkUINodeHandle node,const char * src,const char * bundle,const char * module)373 void SetSliderBlockImage(
374     ArkUINodeHandle node, const char* src, const char* bundle, const char* module)
375 {
376     auto* frameNode = reinterpret_cast<FrameNode*>(node);
377     CHECK_NULL_VOID(frameNode);
378     std::string srcStr(src);
379     std::string bundleStr(bundle);
380     std::string moduleStr(module);
381     SliderModelNG::SetBlockImage(frameNode, srcStr, bundleStr, moduleStr);
382 }
383 
ResetSliderBlockImage(ArkUINodeHandle node)384 void ResetSliderBlockImage(ArkUINodeHandle node)
385 {
386     auto *frameNode = reinterpret_cast<FrameNode *>(node);
387     CHECK_NULL_VOID(frameNode);
388     SliderModelNG::ResetBlockImage(frameNode);
389 }
390 
SetSliderBlockPath(ArkUINodeHandle node,const char * type,const ArkUI_Float32 (* attribute)[2],const char * commands)391 void SetSliderBlockPath(
392     ArkUINodeHandle node, const char* type, const ArkUI_Float32 (*attribute)[2], const char* commands)
393 {
394     auto* frameNode = reinterpret_cast<FrameNode*>(node);
395     CHECK_NULL_VOID(frameNode);
396     auto path = AceType::MakeRefPtr<Path>();
397     auto width = Dimension((*attribute)[0], static_cast<OHOS::Ace::DimensionUnit>(1));
398     auto height = Dimension((*attribute)[1], static_cast<OHOS::Ace::DimensionUnit>(1));
399     std::string pathCommands(commands);
400     path->SetWidth(width);
401     path->SetHeight(height);
402     path->SetValue(StringUtils::TrimStr(pathCommands));
403     SliderModelNG::SetBlockShape(frameNode, path);
404 }
405 
SetSliderBlockShape(ArkUINodeHandle node,const char * type,const ArkUI_Float32 * attribute,int length)406 void SetSliderBlockShape(ArkUINodeHandle node, const char* type, const ArkUI_Float32* attribute, int length)
407 {
408     auto* frameNode = reinterpret_cast<FrameNode*>(node);
409     CHECK_NULL_VOID(frameNode);
410     if (std::strcmp(type, "rect") == 0) {
411         auto shape = AceType::MakeRefPtr<ShapeRect>();
412         // 0 width 1 height 2 radiusWith 3 radius Height
413         auto width = Dimension(attribute[0], static_cast<OHOS::Ace::DimensionUnit>(1));
414         auto height = Dimension(attribute[1], static_cast<OHOS::Ace::DimensionUnit>(1));
415         auto radiusWidth = Dimension(attribute[2], static_cast<OHOS::Ace::DimensionUnit>(1));
416         auto radiusHeight = Dimension(attribute[3], static_cast<OHOS::Ace::DimensionUnit>(1));
417         shape->SetWidth(width);
418         shape->SetHeight(height);
419         shape->SetRadiusWidth(radiusWidth);
420         shape->SetRadiusHeight(radiusHeight);
421         SliderModelNG::SetBlockShape(frameNode, shape);
422     }
423     if (std::strcmp(type, "circle") == 0) {
424         auto shape = AceType::MakeRefPtr<Circle>();
425         // 0 width 1 height
426         auto width = Dimension(attribute[0], static_cast<OHOS::Ace::DimensionUnit>(1));
427         auto height = Dimension(attribute[1], static_cast<OHOS::Ace::DimensionUnit>(1));
428         shape->SetWidth(width);
429         shape->SetHeight(height);
430         SliderModelNG::SetBlockShape(frameNode, shape);
431     }
432     if (std::strcmp(type, "ellipse") == 0) {
433         auto shape = AceType::MakeRefPtr<Ellipse>();
434         // 0 width 1 height
435         auto width = Dimension(attribute[0], static_cast<OHOS::Ace::DimensionUnit>(1));
436         auto height = Dimension(attribute[1], static_cast<OHOS::Ace::DimensionUnit>(1));
437         shape->SetWidth(width);
438         shape->SetHeight(height);
439         SliderModelNG::SetBlockShape(frameNode, shape);
440     }
441 }
442 
ResetSliderBlockShape(ArkUINodeHandle node)443 void ResetSliderBlockShape(ArkUINodeHandle node)
444 {
445     auto *frameNode = reinterpret_cast<FrameNode *>(node);
446     CHECK_NULL_VOID(frameNode);
447     SliderModelNG::ResetBlockImage(frameNode);
448 }
449 
SetSliderBlockType(ArkUINodeHandle node,int value)450 void SetSliderBlockType(ArkUINodeHandle node, int value)
451 {
452     auto *frameNode = reinterpret_cast<FrameNode *>(node);
453     CHECK_NULL_VOID(frameNode);
454     SliderModelNG::SetBlockType(frameNode, SLIDER_STYLE_TYPE[value]);
455 }
456 
ResetSliderBlockType(ArkUINodeHandle node)457 void ResetSliderBlockType(ArkUINodeHandle node)
458 {
459     auto *frameNode = reinterpret_cast<FrameNode *>(node);
460     CHECK_NULL_VOID(frameNode);
461     SliderModelNG::ResetBlockType(frameNode);
462 }
463 
SetSliderValidSlideRange(ArkUINodeHandle node,float from,float to)464 void SetSliderValidSlideRange(ArkUINodeHandle node, float from, float to)
465 {
466     auto *frameNode = reinterpret_cast<FrameNode *>(node);
467     CHECK_NULL_VOID(frameNode);
468     SliderModelNG::SetValidSlideRange(frameNode, from, to);
469 }
470 
ResetSliderValidSlideRange(ArkUINodeHandle node)471 void ResetSliderValidSlideRange(ArkUINodeHandle node)
472 {
473     auto *frameNode = reinterpret_cast<FrameNode *>(node);
474     CHECK_NULL_VOID(frameNode);
475     SliderModelNG::ResetValidSlideRange(frameNode);
476 }
477 
SetSelectedBorderRadius(ArkUINodeHandle node,float value,int unit)478 void SetSelectedBorderRadius(ArkUINodeHandle node, float value, int unit)
479 {
480     auto* frameNode = reinterpret_cast<FrameNode*>(node);
481     CHECK_NULL_VOID(frameNode);
482     Dimension radius = Dimension(static_cast<double>(value), static_cast<OHOS::Ace::DimensionUnit>(unit));
483     SliderModelNG::SetSelectedBorderRadius(frameNode, radius);
484 }
485 
ResetSelectedBorderRadius(ArkUINodeHandle node)486 void ResetSelectedBorderRadius(ArkUINodeHandle node)
487 {
488     auto* frameNode = reinterpret_cast<FrameNode*>(node);
489     CHECK_NULL_VOID(frameNode);
490     SliderModelNG::ResetSelectedBorderRadius(frameNode);
491 }
492 
SetInteractionMode(ArkUINodeHandle node,int value)493 void SetInteractionMode(ArkUINodeHandle node, int value)
494 {
495     auto* frameNode = reinterpret_cast<FrameNode*>(node);
496     CHECK_NULL_VOID(frameNode);
497     SliderModelNG::SetSliderInteractionMode(frameNode, static_cast<SliderModel::SliderInteraction>(value));
498 }
499 
ResetInteractionMode(ArkUINodeHandle node)500 void ResetInteractionMode(ArkUINodeHandle node)
501 {
502     auto* frameNode = reinterpret_cast<FrameNode*>(node);
503     CHECK_NULL_VOID(frameNode);
504     SliderModelNG::ResetSliderInteractionMode(frameNode);
505 }
506 
SetMinResponsiveDistance(ArkUINodeHandle node,float value)507 void SetMinResponsiveDistance(ArkUINodeHandle node, float value)
508 {
509     auto* frameNode = reinterpret_cast<FrameNode*>(node);
510     CHECK_NULL_VOID(frameNode);
511     SliderModelNG::SetMinResponsiveDistance(frameNode, value);
512 }
513 
ResetMinResponsiveDistance(ArkUINodeHandle node)514 void ResetMinResponsiveDistance(ArkUINodeHandle node)
515 {
516     auto* frameNode = reinterpret_cast<FrameNode*>(node);
517     CHECK_NULL_VOID(frameNode);
518     SliderModelNG::ResetMinResponsiveDistance(frameNode);
519 }
520 
GetBlockColor(ArkUINodeHandle node)521 ArkUI_Uint32 GetBlockColor(ArkUINodeHandle node)
522 {
523     auto *frameNode = reinterpret_cast<FrameNode *>(node);
524     CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
525     return SliderModelNG::GetBlockColor(frameNode).GetValue();
526 }
527 
GetTrackBackgroundColor(ArkUINodeHandle node)528 ArkUI_Uint32 GetTrackBackgroundColor(ArkUINodeHandle node)
529 {
530     auto *frameNode = reinterpret_cast<FrameNode *>(node);
531     CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
532     NG::Gradient gradient = SliderModelNG::GetTrackBackgroundColor(frameNode);
533     return gradient.GetColors().at(0).GetLinearColor().ToColor().GetValue();
534 }
535 
GetSelectColor(ArkUINodeHandle node)536 ArkUI_Uint32 GetSelectColor(ArkUINodeHandle node)
537 {
538     auto *frameNode = reinterpret_cast<FrameNode *>(node);
539     CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
540     return SliderModelNG::GetSelectColor(frameNode).GetValue();
541 }
542 
GetShowSteps(ArkUINodeHandle node)543 ArkUI_Bool GetShowSteps(ArkUINodeHandle node)
544 {
545     auto *frameNode = reinterpret_cast<FrameNode *>(node);
546     CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
547     return static_cast<ArkUI_Bool>(SliderModelNG::GetShowSteps(frameNode));
548 }
549 
GetBlockType(ArkUINodeHandle node)550 ArkUI_Int32 GetBlockType(ArkUINodeHandle node)
551 {
552     auto *frameNode = reinterpret_cast<FrameNode *>(node);
553     CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
554     return SLIDER_STYLE_TYPE_MAP[SliderModelNG::GetBlockType(frameNode)];
555 }
556 
GetSliderValue(ArkUINodeHandle node)557 ArkUI_Float32 GetSliderValue(ArkUINodeHandle node)
558 {
559     auto *frameNode = reinterpret_cast<FrameNode *>(node);
560     CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
561     return SliderModelNG::GetSliderValue(frameNode);
562 }
563 
GetMinLabel(ArkUINodeHandle node)564 ArkUI_Float32 GetMinLabel(ArkUINodeHandle node)
565 {
566     auto *frameNode = reinterpret_cast<FrameNode *>(node);
567     CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
568     return SliderModelNG::GetMinLabel(frameNode);
569 }
570 
GetMaxLabel(ArkUINodeHandle node)571 ArkUI_Float32 GetMaxLabel(ArkUINodeHandle node)
572 {
573     auto *frameNode = reinterpret_cast<FrameNode *>(node);
574     CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
575     return SliderModelNG::GetMaxLabel(frameNode);
576 }
577 
GetDirection(ArkUINodeHandle node)578 ArkUI_Int32 GetDirection(ArkUINodeHandle node)
579 {
580     auto *frameNode = reinterpret_cast<FrameNode *>(node);
581     CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
582     return static_cast<ArkUI_Int32>(SliderModelNG::GetDirection(frameNode));
583 }
584 
GetStep(ArkUINodeHandle node)585 ArkUI_Float32 GetStep(ArkUINodeHandle node)
586 {
587     auto *frameNode = reinterpret_cast<FrameNode *>(node);
588     CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
589     return SliderModelNG::GetStep(frameNode);
590 }
591 
GetReverse(ArkUINodeHandle node)592 ArkUI_Bool GetReverse(ArkUINodeHandle node)
593 {
594     auto *frameNode = reinterpret_cast<FrameNode *>(node);
595     CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
596     return static_cast<ArkUI_Bool>(SliderModelNG::GetReverse(frameNode));
597 }
598 
GetSliderStyle(ArkUINodeHandle node)599 ArkUI_Int32 GetSliderStyle(ArkUINodeHandle node)
600 {
601     auto *frameNode = reinterpret_cast<FrameNode *>(node);
602     CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
603     return SLIDER_MODE_MAP[SliderModelNG::GetSliderMode(frameNode)];
604 }
GetBlockImageValue(ArkUINodeHandle node)605 ArkUI_CharPtr GetBlockImageValue(ArkUINodeHandle node)
606 {
607     auto* frameNode = reinterpret_cast<FrameNode*>(node);
608     CHECK_NULL_RETURN(frameNode, nullptr);
609     g_strValue = SliderModelNG::GetBlockImageValue(frameNode);
610     return g_strValue.c_str();
611 }
612 
GetSliderBlockShape(ArkUINodeHandle node,ArkUI_Float32 (* value)[5])613 ArkUI_CharPtr GetSliderBlockShape(ArkUINodeHandle node, ArkUI_Float32 (*value)[5])
614 {
615     auto* frameNode = reinterpret_cast<FrameNode*>(node);
616     CHECK_NULL_RETURN(frameNode, nullptr);
617     RefPtr<BasicShape> basicShape = SliderModelNG::GetBlockShape(frameNode);
618     auto shapeType = basicShape->GetBasicShapeType();
619     //index 0 shapeType
620     (*value)[0] = SHAPE_TYPE_MAP[shapeType];
621     //index 1 width
622     (*value)[1] = basicShape->GetWidth().Value();
623     //index 2 height
624     (*value)[2] = basicShape->GetHeight().Value();
625     switch (shapeType) {
626         case BasicShapeType::PATH: {
627             auto path = AceType::DynamicCast<Path>(basicShape);
628             g_strValue = path->GetValue();
629             return g_strValue.c_str();
630         }
631         case BasicShapeType::RECT: {
632             auto shapeRect = AceType::DynamicCast<ShapeRect>(basicShape);
633             //index 3 radius x
634             (*value)[3] = shapeRect->GetTopLeftRadius().GetX().Value();
635             //index 4 radius y
636             (*value)[4] = shapeRect->GetTopLeftRadius().GetY().Value();
637             break;
638         }
639         default:
640             break;
641     }
642     return nullptr;
643 }
644 
GetThickness(ArkUINodeHandle node,int unit)645 ArkUI_Float32 GetThickness(ArkUINodeHandle node, int unit)
646 {
647     auto* frameNode = reinterpret_cast<FrameNode*>(node);
648     CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
649     return SliderModelNG::GetThickness(frameNode).GetNativeValue(static_cast<DimensionUnit>(unit));
650 }
651 
GetSliderValidSlideRange(ArkUINodeHandle node)652 ArkUISliderValidSlideRange GetSliderValidSlideRange(ArkUINodeHandle node)
653 {
654     ArkUISliderValidSlideRange errorReturn = {
655         std::numeric_limits<float>::quiet_NaN(),
656         std::numeric_limits<float>::quiet_NaN()
657     };
658     auto* frameNode = reinterpret_cast<FrameNode*>(node);
659     CHECK_NULL_RETURN(frameNode, errorReturn);
660     auto rangeValue = SliderModelNG::GetValidSlideRange(frameNode).GetRawPtr();
661     CHECK_NULL_RETURN(rangeValue && rangeValue->HasValidValues(), errorReturn);
662     return { rangeValue->GetFromValue(), rangeValue->GetToValue() };
663 }
664 } // namespace SliderModifier
665 
666 namespace NodeModifier {
GetSliderModifier()667 const ArkUISliderModifier *GetSliderModifier()
668 {
669     static const ArkUISliderModifier modifier = {
670         SliderModifier::SetShowTips,
671         SliderModifier::ResetShowTips,
672         SliderModifier::SetSliderStepSize,
673         SliderModifier::ResetSliderStepSize,
674         SliderModifier::SetBlockSize,
675         SliderModifier::ResetBlockSize,
676         SliderModifier::SetTrackBorderRadius,
677         SliderModifier::ResetTrackBorderRadius,
678         SliderModifier::SetStepColor,
679         SliderModifier::ResetStepColor,
680         SliderModifier::SetBlockBorderColor,
681         SliderModifier::ResetBlockBorderColor,
682         SliderModifier::SetBlockBorderWidth,
683         SliderModifier::ResetBlockBorderWidth,
684         SliderModifier::SetBlockColor,
685         SliderModifier::ResetBlockColor,
686         SliderModifier::SetTrackBackgroundColor,
687         SliderModifier::ResetTrackBackgroundColor,
688         SliderModifier::SetSelectColor,
689         SliderModifier::ResetSelectColor,
690         SliderModifier::SetShowSteps,
691         SliderModifier::ResetShowSteps,
692         SliderModifier::SetThickness,
693         SliderModifier::ResetThickness,
694         SliderModifier::SetSliderValue,
695         SliderModifier::SetMinLabel,
696         SliderModifier::SetMaxLabel,
697         SliderModifier::SetDirection,
698         SliderModifier::SetStep,
699         SliderModifier::SetReverse,
700         SliderModifier::SetSliderStyle,
701         SliderModifier::ResetSliderValue,
702         SliderModifier::ResetMinLabel,
703         SliderModifier::ResetMaxLabel,
704         SliderModifier::ResetDirection,
705         SliderModifier::ResetStep,
706         SliderModifier::ResetReverse,
707         SliderModifier::ResetSliderStyle,
708         SliderModifier::SetSliderBlockImage,
709         SliderModifier::ResetSliderBlockImage,
710         SliderModifier::SetSliderBlockPath,
711         SliderModifier::SetSliderBlockShape,
712         SliderModifier::ResetSliderBlockShape,
713         SliderModifier::SetSliderBlockType,
714         SliderModifier::ResetSliderBlockType,
715         SliderModifier::SetSliderValidSlideRange,
716         SliderModifier::ResetSliderValidSlideRange,
717         SliderModifier::SetSelectedBorderRadius,
718         SliderModifier::ResetSelectedBorderRadius,
719         SliderModifier::SetInteractionMode,
720         SliderModifier::ResetInteractionMode,
721         SliderModifier::SetMinResponsiveDistance,
722         SliderModifier::ResetMinResponsiveDistance,
723         SliderModifier::GetBlockColor,
724         SliderModifier::GetTrackBackgroundColor,
725         SliderModifier::GetSelectColor,
726         SliderModifier::GetShowSteps,
727         SliderModifier::GetBlockType,
728         SliderModifier::GetSliderValue,
729         SliderModifier::GetMinLabel,
730         SliderModifier::GetMaxLabel,
731         SliderModifier::GetDirection,
732         SliderModifier::GetStep,
733         SliderModifier::GetReverse,
734         SliderModifier::GetSliderStyle,
735         SliderModifier::GetBlockImageValue,
736         SliderModifier::GetSliderBlockShape,
737         SliderModifier::GetThickness,
738         SliderModifier::GetSliderValidSlideRange,
739     };
740 
741     return &modifier;
742 }
743 
GetCJUISliderModifier()744 const CJUISliderModifier* GetCJUISliderModifier()
745 {
746     static const CJUISliderModifier modifier = {
747         SliderModifier::SetShowTips,
748         SliderModifier::ResetShowTips,
749         SliderModifier::SetSliderStepSize,
750         SliderModifier::ResetSliderStepSize,
751         SliderModifier::SetBlockSize,
752         SliderModifier::ResetBlockSize,
753         SliderModifier::SetTrackBorderRadius,
754         SliderModifier::ResetTrackBorderRadius,
755         SliderModifier::SetStepColor,
756         SliderModifier::ResetStepColor,
757         SliderModifier::SetBlockBorderColor,
758         SliderModifier::ResetBlockBorderColor,
759         SliderModifier::SetBlockBorderWidth,
760         SliderModifier::ResetBlockBorderWidth,
761         SliderModifier::SetBlockColor,
762         SliderModifier::ResetBlockColor,
763         SliderModifier::SetTrackBackgroundColor,
764         SliderModifier::ResetTrackBackgroundColor,
765         SliderModifier::SetSelectColor,
766         SliderModifier::ResetSelectColor,
767         SliderModifier::SetShowSteps,
768         SliderModifier::ResetShowSteps,
769         SliderModifier::SetThickness,
770         SliderModifier::ResetThickness,
771         SliderModifier::SetSliderValue,
772         SliderModifier::SetMinLabel,
773         SliderModifier::SetMaxLabel,
774         SliderModifier::SetDirection,
775         SliderModifier::SetStep,
776         SliderModifier::SetReverse,
777         SliderModifier::SetSliderStyle,
778         SliderModifier::ResetSliderValue,
779         SliderModifier::ResetMinLabel,
780         SliderModifier::ResetMaxLabel,
781         SliderModifier::ResetDirection,
782         SliderModifier::ResetStep,
783         SliderModifier::ResetReverse,
784         SliderModifier::ResetSliderStyle,
785         SliderModifier::SetSliderBlockImage,
786         SliderModifier::ResetSliderBlockImage,
787         SliderModifier::SetSliderBlockPath,
788         SliderModifier::SetSliderBlockShape,
789         SliderModifier::ResetSliderBlockShape,
790         SliderModifier::SetSliderBlockType,
791         SliderModifier::ResetSliderBlockType,
792         SliderModifier::SetSliderValidSlideRange,
793         SliderModifier::ResetSliderValidSlideRange,
794         SliderModifier::SetSelectedBorderRadius,
795         SliderModifier::ResetSelectedBorderRadius,
796         SliderModifier::SetInteractionMode,
797         SliderModifier::ResetInteractionMode,
798         SliderModifier::SetMinResponsiveDistance,
799         SliderModifier::ResetMinResponsiveDistance,
800         SliderModifier::GetBlockColor,
801         SliderModifier::GetTrackBackgroundColor,
802         SliderModifier::GetSelectColor,
803         SliderModifier::GetShowSteps,
804         SliderModifier::GetBlockType,
805         SliderModifier::GetSliderValue,
806         SliderModifier::GetMinLabel,
807         SliderModifier::GetMaxLabel,
808         SliderModifier::GetDirection,
809         SliderModifier::GetStep,
810         SliderModifier::GetReverse,
811         SliderModifier::GetSliderStyle,
812         SliderModifier::GetBlockImageValue,
813         SliderModifier::GetSliderBlockShape,
814         SliderModifier::GetThickness,
815         SliderModifier::GetSliderValidSlideRange,
816     };
817 
818     return &modifier;
819 }
820 
SetSliderChange(ArkUINodeHandle node,void * extraParam)821 void SetSliderChange(ArkUINodeHandle node, void* extraParam)
822 {
823     auto* frameNode = reinterpret_cast<FrameNode*>(node);
824     CHECK_NULL_VOID(frameNode);
825     auto onEvent = [node, extraParam](float value, int32_t mode) {
826         ArkUINodeEvent event;
827         event.kind = COMPONENT_ASYNC_EVENT;
828         event.extraParam = reinterpret_cast<intptr_t>(extraParam);
829         event.componentAsyncEvent.subKind = ON_SLIDER_CHANGE;
830         event.componentAsyncEvent.data[0].f32 = value;
831         event.componentAsyncEvent.data[1].i32 = mode;
832         SendArkUIAsyncEvent(&event);
833     };
834     SliderModelNG::SetOnChange(frameNode, std::move(onEvent));
835 }
836 
837 }
838 }
839