1 /*
2 * Copyright (c) 2022-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
16 #include "core/components_ng/pattern/slider/slider_model_ng.h"
17
18 #include "base/geometry/dimension.h"
19 #include "base/utils/utils.h"
20 #include "core/components/slider/slider_theme.h"
21 #include "core/components_ng/base/view_stack_processor.h"
22 #include "core/components_ng/pattern/slider/slider_layout_property.h"
23 #include "core/components_ng/pattern/slider/slider_paint_property.h"
24 #include "core/components_ng/pattern/slider/slider_pattern.h"
25 #include "core/components_v2/inspector/inspector_constants.h"
26 #include "core/pipeline/pipeline_base.h"
27 #include "core/pipeline_ng/pipeline_context.h"
28
29 namespace OHOS::Ace::NG {
30 const float DEFAULT_STEP = 1.0f;
31 const float DEFAULT_MIN_VALUE = 0.0f;
32 const float DEFAULT_MAX_VALUE = 100.0f;
33 constexpr uint32_t BLOCK_COLOR = 0xffffffff;
34 constexpr uint32_t TRACK_COLOR = 0x19182431;
35 constexpr uint32_t SELECTED_COLOR = 0xff007dff;
36
Create(float value,float step,float min,float max)37 void SliderModelNG::Create(float value, float step, float min, float max)
38 {
39 auto* stack = ViewStackProcessor::GetInstance();
40 auto nodeId = stack->ClaimNodeId();
41 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::SLIDER_ETS_TAG, nodeId);
42 auto frameNode = FrameNode::GetOrCreateFrameNode(
43 V2::SLIDER_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<SliderPattern>(); });
44 stack->Push(frameNode);
45 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, Step, step);
46 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, Min, min);
47 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, Max, max);
48 SetSliderValue(value);
49 }
SetSliderValue(float value)50 void SliderModelNG::SetSliderValue(float value)
51 {
52 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
53 CHECK_NULL_VOID(frameNode);
54 auto pattern = frameNode->GetPattern<SliderPattern>();
55 CHECK_NULL_VOID(pattern);
56 pattern->UpdateValue(value);
57 auto sliderEventHub = frameNode->GetEventHub<SliderEventHub>();
58 CHECK_NULL_VOID(sliderEventHub);
59 sliderEventHub->SetValue(value);
60 }
SetSliderMode(const SliderMode & value)61 void SliderModelNG::SetSliderMode(const SliderMode& value)
62 {
63 ACE_UPDATE_LAYOUT_PROPERTY(SliderLayoutProperty, SliderMode, value);
64 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, SliderMode, value);
65 }
SetDirection(Axis value)66 void SliderModelNG::SetDirection(Axis value)
67 {
68 ACE_UPDATE_LAYOUT_PROPERTY(SliderLayoutProperty, Direction, value);
69 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, Direction, value);
70 }
SetReverse(bool value)71 void SliderModelNG::SetReverse(bool value)
72 {
73 ACE_UPDATE_LAYOUT_PROPERTY(SliderLayoutProperty, Reverse, value);
74 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, Reverse, value);
75 }
SetBlockColor(const Color & value)76 void SliderModelNG::SetBlockColor(const Color& value)
77 {
78 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, BlockColor, value);
79 }
SetTrackBackgroundColor(const Gradient & value,bool isResourceColor)80 void SliderModelNG::SetTrackBackgroundColor(const Gradient& value, bool isResourceColor)
81 {
82 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, TrackBackgroundColor, value);
83 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, TrackBackgroundIsResourceColor, isResourceColor);
84 }
SetSelectColor(const Color & value)85 void SliderModelNG::SetSelectColor(const Color& value)
86 {
87 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, SelectColor, value);
88 }
SetMinLabel(float value)89 void SliderModelNG::SetMinLabel(float value)
90 {
91 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, Min, value);
92 }
SetMaxLabel(float value)93 void SliderModelNG::SetMaxLabel(float value)
94 {
95 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, Max, value);
96 }
SetMinResponsiveDistance(float value)97 void SliderModelNG::SetMinResponsiveDistance(float value)
98 {
99 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
100 CHECK_NULL_VOID(frameNode);
101 auto layoutProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
102 CHECK_NULL_VOID(layoutProperty);
103 auto minResponse = 0.0f;
104 auto minValue = layoutProperty->GetMinValue(0.0f);
105 auto maxValue = layoutProperty->GetMaxValue(100.0f);
106 auto diff = maxValue - minValue;
107 if (LessOrEqual(value, diff) && GreatNotEqual(value, minResponse)) {
108 minResponse = value;
109 }
110 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, MinResponsiveDistance, minResponse);
111 }
112
SetValidSlideRange(float from,float to)113 void SliderModelNG::SetValidSlideRange(float from, float to)
114 {
115 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
116 SliderModelNG::SetValidSlideRange(frameNode, from, to);
117 }
118
SetShowSteps(bool value)119 void SliderModelNG::SetShowSteps(bool value)
120 {
121 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, ShowSteps, value);
122 }
SetSliderInteractionMode(SliderInteraction mode)123 void SliderModelNG::SetSliderInteractionMode(SliderInteraction mode)
124 {
125 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, SliderInteractionMode, mode);
126 }
SetShowTips(bool value,const std::optional<std::string> & content)127 void SliderModelNG::SetShowTips(bool value, const std::optional<std::string>& content)
128 {
129 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, ShowTips, value);
130 if (content.has_value()) {
131 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, CustomContent, content.value());
132 } else {
133 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, CustomContent, PROPERTY_UPDATE_RENDER);
134 }
135 }
SetThickness(const Dimension & value)136 void SliderModelNG::SetThickness(const Dimension& value)
137 {
138 if (value.IsNonPositive()) {
139 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
140 CHECK_NULL_VOID(frameNode);
141 auto layoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
142 CHECK_NULL_VOID(layoutProperty);
143 auto pipeline = PipelineBase::GetCurrentContext();
144 CHECK_NULL_VOID(pipeline);
145 auto theme = pipeline->GetTheme<SliderTheme>();
146 CHECK_NULL_VOID(theme);
147 auto sliderMode = layoutProperty->GetSliderModeValue(SliderModel::SliderMode::OUTSET);
148 Dimension themeTrackThickness;
149 if (sliderMode == SliderModel::SliderMode::OUTSET) {
150 themeTrackThickness = theme->GetOutsetTrackThickness();
151 } else if (sliderMode == SliderModel::SliderMode::INSET) {
152 themeTrackThickness = theme->GetInsetTrackThickness();
153 } else {
154 themeTrackThickness = theme->GetNoneTrackThickness();
155 }
156 ACE_UPDATE_LAYOUT_PROPERTY(SliderLayoutProperty, Thickness, themeTrackThickness);
157 } else {
158 ACE_UPDATE_LAYOUT_PROPERTY(SliderLayoutProperty, Thickness, value);
159 }
160 }
SetBlockBorderColor(const Color & value)161 void SliderModelNG::SetBlockBorderColor(const Color& value)
162 {
163 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, BlockBorderColor, value);
164 }
SetBlockBorderWidth(const Dimension & value)165 void SliderModelNG::SetBlockBorderWidth(const Dimension& value)
166 {
167 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, BlockBorderWidth, value);
168 }
SetStepColor(const Color & value)169 void SliderModelNG::SetStepColor(const Color& value)
170 {
171 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, StepColor, value);
172 }
SetTrackBorderRadius(const Dimension & value)173 void SliderModelNG::SetTrackBorderRadius(const Dimension& value)
174 {
175 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, TrackBorderRadius, value);
176 }
SetSelectedBorderRadius(const Dimension & value)177 void SliderModelNG::SetSelectedBorderRadius(const Dimension& value)
178 {
179 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, SelectedBorderRadius, value);
180 }
SetBlockSize(const Dimension & width,const Dimension & height)181 void SliderModelNG::SetBlockSize(const Dimension& width, const Dimension& height)
182 {
183 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
184 CHECK_NULL_VOID(frameNode);
185 auto layoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
186 CHECK_NULL_VOID(layoutProperty);
187 auto pipeline = PipelineBase::GetCurrentContext();
188 CHECK_NULL_VOID(pipeline);
189 SizeT<Dimension> blockSize;
190 auto theme = pipeline->GetTheme<SliderTheme>();
191 if (theme != nullptr) {
192 auto mode = layoutProperty->GetSliderModeValue(SliderMode::OUTSET);
193 auto themeBlockSize = mode == SliderMode::OUTSET ? theme->GetOutsetBlockSize() : theme->GetInsetBlockSize();
194 blockSize = layoutProperty->GetBlockSizeValue(SizeT<Dimension>(themeBlockSize, themeBlockSize));
195 }
196
197 if (LessOrEqual(width.Value(), 0.0) || LessOrEqual(height.Value(), 0.0)) {
198 ResetBlockSize();
199 } else {
200 blockSize.SetWidth(width);
201 blockSize.SetHeight(height);
202 ACE_UPDATE_LAYOUT_PROPERTY(SliderLayoutProperty, BlockSize, blockSize);
203 }
204 }
SetBlockType(BlockStyleType value)205 void SliderModelNG::SetBlockType(BlockStyleType value)
206 {
207 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, BlockType, value);
208 }
SetBlockImage(const std::string & value,const std::string & bundleName,const std::string & moduleName)209 void SliderModelNG::SetBlockImage(
210 const std::string& value, const std::string& bundleName, const std::string& moduleName)
211 {
212 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, BlockImage, value);
213 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, BlockImageBundleName, bundleName);
214 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, BlockImageModuleName, moduleName);
215 }
SetBlockShape(const RefPtr<BasicShape> & value)216 void SliderModelNG::SetBlockShape(const RefPtr<BasicShape>& value)
217 {
218 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, BlockShape, value);
219 }
SetStepSize(const Dimension & value)220 void SliderModelNG::SetStepSize(const Dimension& value)
221 {
222 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, StepSize, value);
223 }
SetOnChange(SliderOnChangeEvent && eventOnChange)224 void SliderModelNG::SetOnChange(SliderOnChangeEvent&& eventOnChange)
225 {
226 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
227 CHECK_NULL_VOID(frameNode);
228 auto eventHub = frameNode->GetEventHub<SliderEventHub>();
229 CHECK_NULL_VOID(eventHub);
230 eventHub->SetOnChange(std::move(eventOnChange));
231 }
232
SetOnChangeEvent(SliderOnValueChangeEvent && onChangeEvent)233 void SliderModelNG::SetOnChangeEvent(SliderOnValueChangeEvent&& onChangeEvent)
234 {
235 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
236 CHECK_NULL_VOID(frameNode);
237 auto eventHub = frameNode->GetEventHub<SliderEventHub>();
238 CHECK_NULL_VOID(eventHub);
239 eventHub->SetOnChangeEvent(std::move(onChangeEvent));
240 }
241
ResetBlockBorderColor()242 void SliderModelNG::ResetBlockBorderColor()
243 {
244 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockBorderColor, PROPERTY_UPDATE_RENDER);
245 }
246
ResetBlockBorderWidth()247 void SliderModelNG::ResetBlockBorderWidth()
248 {
249 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockBorderWidth, PROPERTY_UPDATE_RENDER);
250 }
251
ResetStepColor()252 void SliderModelNG::ResetStepColor()
253 {
254 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, StepColor, PROPERTY_UPDATE_RENDER);
255 }
256
ResetTrackBorderRadius()257 void SliderModelNG::ResetTrackBorderRadius()
258 {
259 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, TrackBorderRadius, PROPERTY_UPDATE_RENDER);
260 }
261
ResetSelectedBorderRadius()262 void SliderModelNG::ResetSelectedBorderRadius()
263 {
264 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, SelectedBorderRadius, PROPERTY_UPDATE_RENDER);
265 }
266
ResetBlockSize()267 void SliderModelNG::ResetBlockSize()
268 {
269 ACE_RESET_LAYOUT_PROPERTY_WITH_FLAG(SliderLayoutProperty, BlockSize, PROPERTY_UPDATE_MEASURE);
270 }
271
ResetBlockType()272 void SliderModelNG::ResetBlockType()
273 {
274 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockType, PROPERTY_UPDATE_RENDER);
275 }
276
ResetBlockImage()277 void SliderModelNG::ResetBlockImage()
278 {
279 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockImage, PROPERTY_UPDATE_RENDER);
280 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockImageBundleName, PROPERTY_UPDATE_RENDER);
281 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockImageModuleName, PROPERTY_UPDATE_RENDER);
282 }
283
ResetBlockShape()284 void SliderModelNG::ResetBlockShape()
285 {
286 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockShape, PROPERTY_UPDATE_RENDER);
287 }
288
ResetStepSize()289 void SliderModelNG::ResetStepSize()
290 {
291 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, StepSize, PROPERTY_UPDATE_RENDER);
292 }
293
ResetSliderInteractionMode()294 void SliderModelNG::ResetSliderInteractionMode()
295 {
296 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, SliderInteractionMode, PROPERTY_UPDATE_RENDER);
297 }
298
ResetMinResponsiveDistance()299 void SliderModelNG::ResetMinResponsiveDistance()
300 {
301 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, MinResponsiveDistance, PROPERTY_UPDATE_RENDER);
302 }
303
ResetValidSlideRange()304 void SliderModelNG::ResetValidSlideRange()
305 {
306 ACE_RESET_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, ValidSlideRange, PROPERTY_UPDATE_RENDER);
307 }
308
SetShowTips(FrameNode * frameNode,bool value,const std::optional<std::string> & content)309 void SliderModelNG::SetShowTips(FrameNode* frameNode, bool value, const std::optional<std::string>& content)
310 {
311 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, ShowTips, value, frameNode);
312 if (content.has_value()) {
313 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, CustomContent, content.value(), frameNode);
314 } else {
315 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, CustomContent, PROPERTY_UPDATE_RENDER, frameNode);
316 }
317 }
318
SetThickness(FrameNode * frameNode,const Dimension & value)319 void SliderModelNG::SetThickness(FrameNode* frameNode, const Dimension& value)
320 {
321 if (value.IsNonPositive()) {
322 CHECK_NULL_VOID(frameNode);
323 auto layoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
324 CHECK_NULL_VOID(layoutProperty);
325 auto pipeline = frameNode->GetContext();
326 CHECK_NULL_VOID(pipeline);
327 auto theme = pipeline->GetTheme<SliderTheme>();
328 CHECK_NULL_VOID(theme);
329 auto sliderMode = layoutProperty->GetSliderModeValue(SliderModel::SliderMode::OUTSET);
330 Dimension themeTrackThickness;
331 if (sliderMode == SliderModel::SliderMode::OUTSET) {
332 themeTrackThickness = theme->GetOutsetTrackThickness();
333 } else if (sliderMode == SliderModel::SliderMode::INSET) {
334 themeTrackThickness = theme->GetInsetTrackThickness();
335 } else {
336 themeTrackThickness = theme->GetNoneTrackThickness();
337 }
338 ACE_UPDATE_NODE_LAYOUT_PROPERTY(SliderLayoutProperty, Thickness, themeTrackThickness, frameNode);
339 } else {
340 ACE_UPDATE_NODE_LAYOUT_PROPERTY(SliderLayoutProperty, Thickness, value, frameNode);
341 }
342 }
SetStepSize(FrameNode * frameNode,const Dimension & value)343 void SliderModelNG::SetStepSize(FrameNode* frameNode, const Dimension& value)
344 {
345 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, StepSize, value, frameNode);
346 }
SetBlockType(FrameNode * frameNode,BlockStyleType value)347 void SliderModelNG::SetBlockType(FrameNode* frameNode, BlockStyleType value)
348 {
349 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockType, value, frameNode);
350 }
SetBlockShape(FrameNode * frameNode,const RefPtr<BasicShape> & value)351 void SliderModelNG::SetBlockShape(FrameNode* frameNode, const RefPtr<BasicShape>& value)
352 {
353 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockShape, value, frameNode);
354 }
SetBlockSize(FrameNode * frameNode,const Dimension & width,const Dimension & height)355 void SliderModelNG::SetBlockSize(FrameNode* frameNode, const Dimension& width, const Dimension& height)
356 {
357 CHECK_NULL_VOID(frameNode);
358 auto layoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
359 CHECK_NULL_VOID(layoutProperty);
360 auto pipeline = frameNode->GetContext();
361 CHECK_NULL_VOID(pipeline);
362 SizeT<Dimension> blockSize;
363 auto theme = pipeline->GetTheme<SliderTheme>();
364 if (theme != nullptr) {
365 auto mode = layoutProperty->GetSliderModeValue(SliderMode::OUTSET);
366 auto themeBlockSize = mode == SliderMode::OUTSET ? theme->GetOutsetBlockSize() : theme->GetInsetBlockSize();
367 blockSize = layoutProperty->GetBlockSizeValue(SizeT<Dimension>(themeBlockSize, themeBlockSize));
368 }
369
370 if (LessOrEqual(width.Value(), 0.0) || LessOrEqual(height.Value(), 0.0)) {
371 ResetBlockSize(frameNode);
372 } else {
373 blockSize.SetWidth(width);
374 blockSize.SetHeight(height);
375 ACE_UPDATE_NODE_LAYOUT_PROPERTY(SliderLayoutProperty, BlockSize, blockSize, frameNode);
376 }
377 }
SetTrackBorderRadius(FrameNode * frameNode,const Dimension & value)378 void SliderModelNG::SetTrackBorderRadius(FrameNode* frameNode, const Dimension& value)
379 {
380 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, TrackBorderRadius, value, frameNode);
381 }
SetStepColor(FrameNode * frameNode,const Color & value)382 void SliderModelNG::SetStepColor(FrameNode* frameNode, const Color& value)
383 {
384 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, StepColor, value, frameNode);
385 }
SetBlockBorderColor(FrameNode * frameNode,const Color & value)386 void SliderModelNG::SetBlockBorderColor(FrameNode* frameNode, const Color& value)
387 {
388 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockBorderColor, value, frameNode);
389 }
SetBlockBorderWidth(FrameNode * frameNode,const Dimension & value)390 void SliderModelNG::SetBlockBorderWidth(FrameNode* frameNode, const Dimension& value)
391 {
392 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockBorderWidth, value, frameNode);
393 }
SetBlockColor(FrameNode * frameNode,const Color & value)394 void SliderModelNG::SetBlockColor(FrameNode* frameNode, const Color& value)
395 {
396 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockColor, value, frameNode);
397 }
SetTrackBackgroundColor(FrameNode * frameNode,const Gradient & value,bool isResourceColor)398 void SliderModelNG::SetTrackBackgroundColor(FrameNode* frameNode, const Gradient& value, bool isResourceColor)
399 {
400 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, TrackBackgroundColor, value, frameNode);
401 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, TrackBackgroundIsResourceColor, isResourceColor, frameNode);
402 }
SetSelectColor(FrameNode * frameNode,const Color & value)403 void SliderModelNG::SetSelectColor(FrameNode* frameNode, const Color& value)
404 {
405 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, SelectColor, value, frameNode);
406 }
SetShowSteps(FrameNode * frameNode,bool value)407 void SliderModelNG::SetShowSteps(FrameNode* frameNode, bool value)
408 {
409 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, ShowSteps, value, frameNode);
410 }
SetSliderInteractionMode(FrameNode * frameNode,SliderInteraction mode)411 void SliderModelNG::SetSliderInteractionMode(FrameNode* frameNode, SliderInteraction mode)
412 {
413 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, SliderInteractionMode, mode, frameNode);
414 }
SetMinResponsiveDistance(FrameNode * frameNode,float value)415 void SliderModelNG::SetMinResponsiveDistance(FrameNode* frameNode, float value)
416 {
417 CHECK_NULL_VOID(frameNode);
418 auto layoutProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
419 CHECK_NULL_VOID(layoutProperty);
420 auto minResponse = 0.0f;
421 auto minValue = layoutProperty->GetMinValue(0.0f);
422 auto maxValue = layoutProperty->GetMaxValue(100.0f);
423 auto diff = maxValue - minValue;
424 if (LessOrEqual(value, diff) && GreatOrEqual(value, minResponse)) {
425 minResponse = value;
426 }
427 ACE_UPDATE_PAINT_PROPERTY(SliderPaintProperty, MinResponsiveDistance, minResponse);
428 }
429
SetBlockImage(FrameNode * frameNode,const std::string & value,const std::string & bundleName,const std::string & moduleName)430 void SliderModelNG::SetBlockImage(
431 FrameNode* frameNode, const std::string& value, const std::string& bundleName, const std::string& moduleName)
432 {
433 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockImage, value, frameNode);
434 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockImageBundleName, bundleName, frameNode);
435 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockImageModuleName, moduleName, frameNode);
436 }
437
ResetStepSize(FrameNode * frameNode)438 void SliderModelNG::ResetStepSize(FrameNode* frameNode)
439 {
440 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, StepSize, PROPERTY_UPDATE_RENDER, frameNode);
441 }
442
ResetBlockType(FrameNode * frameNode)443 void SliderModelNG::ResetBlockType(FrameNode* frameNode)
444 {
445 ACE_RESET_NODE_PAINT_PROPERTY(SliderPaintProperty, BlockType, frameNode);
446 }
447
ResetBlockShape(FrameNode * frameNode)448 void SliderModelNG::ResetBlockShape(FrameNode* frameNode)
449 {
450 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockShape, PROPERTY_UPDATE_RENDER, frameNode);
451 }
452
ResetBlockSize(FrameNode * frameNode)453 void SliderModelNG::ResetBlockSize(FrameNode* frameNode)
454 {
455 ACE_RESET_NODE_LAYOUT_PROPERTY_WITH_FLAG(SliderLayoutProperty, BlockSize, PROPERTY_UPDATE_MEASURE, frameNode);
456 }
457
ResetTrackBorderRadius(FrameNode * frameNode)458 void SliderModelNG::ResetTrackBorderRadius(FrameNode* frameNode)
459 {
460 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, TrackBorderRadius, PROPERTY_UPDATE_RENDER, frameNode);
461 }
462
ResetStepColor(FrameNode * frameNode)463 void SliderModelNG::ResetStepColor(FrameNode* frameNode)
464 {
465 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, StepColor, PROPERTY_UPDATE_RENDER, frameNode);
466 }
467
ResetBlockBorderColor(FrameNode * frameNode)468 void SliderModelNG::ResetBlockBorderColor(FrameNode* frameNode)
469 {
470 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockBorderColor, PROPERTY_UPDATE_RENDER, frameNode);
471 }
472
ResetBlockBorderWidth(FrameNode * frameNode)473 void SliderModelNG::ResetBlockBorderWidth(FrameNode* frameNode)
474 {
475 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockBorderWidth, PROPERTY_UPDATE_RENDER, frameNode);
476 }
477
ResetBlockColor(FrameNode * frameNode)478 void SliderModelNG::ResetBlockColor(FrameNode* frameNode)
479 {
480 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, BlockColor, PROPERTY_UPDATE_RENDER, frameNode);
481 }
482
ResetBlockImage(FrameNode * frameNode)483 void SliderModelNG::ResetBlockImage(FrameNode* frameNode)
484 {
485 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(
486 SliderPaintProperty, BlockImage, PROPERTY_UPDATE_RENDER, frameNode);
487 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(
488 SliderPaintProperty, BlockImageBundleName, PROPERTY_UPDATE_RENDER, frameNode);
489 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(
490 SliderPaintProperty, BlockImageModuleName, PROPERTY_UPDATE_RENDER, frameNode);
491 }
492
ResetValidSlideRange(FrameNode * frameNode)493 void SliderModelNG::ResetValidSlideRange(FrameNode* frameNode)
494 {
495 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(SliderPaintProperty, ValidSlideRange, PROPERTY_UPDATE_RENDER, frameNode);
496 }
497
CreateFrameNode(int32_t nodeId)498 RefPtr<FrameNode> SliderModelNG::CreateFrameNode(int32_t nodeId)
499 {
500 auto frameNode = FrameNode::GetOrCreateFrameNode(
501 V2::SLIDER_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<SliderPattern>(); });
502
503 SetMinLabel(AceType::RawPtr(frameNode), DEFAULT_MIN_VALUE);
504 SetMaxLabel(AceType::RawPtr(frameNode), DEFAULT_MAX_VALUE);
505 SetStep(AceType::RawPtr(frameNode), DEFAULT_STEP);
506 SetSliderValue(AceType::RawPtr(frameNode), DEFAULT_MIN_VALUE);
507
508 return frameNode;
509 }
510
SetOnChange(FrameNode * frameNode,SliderOnChangeEvent && eventOnChange)511 void SliderModelNG::SetOnChange(FrameNode* frameNode, SliderOnChangeEvent&& eventOnChange)
512 {
513 CHECK_NULL_VOID(frameNode);
514 auto eventHub = frameNode->GetEventHub<SliderEventHub>();
515 CHECK_NULL_VOID(eventHub);
516 eventHub->SetOnChange(std::move(eventOnChange));
517 }
518
SetSliderValue(FrameNode * frameNode,float value)519 void SliderModelNG::SetSliderValue(FrameNode* frameNode, float value)
520 {
521 CHECK_NULL_VOID(frameNode);
522 auto pattern = frameNode->GetPattern<SliderPattern>();
523 CHECK_NULL_VOID(pattern);
524 pattern->UpdateValue(value);
525 }
526
SetMinLabel(FrameNode * frameNode,float value)527 void SliderModelNG::SetMinLabel(FrameNode* frameNode, float value)
528 {
529 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, Min, value, frameNode);
530 }
SetMaxLabel(FrameNode * frameNode,float value)531 void SliderModelNG::SetMaxLabel(FrameNode* frameNode, float value)
532 {
533 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, Max, value, frameNode);
534 }
535
SetSliderMode(FrameNode * frameNode,const SliderMode & value)536 void SliderModelNG::SetSliderMode(FrameNode* frameNode, const SliderMode& value)
537 {
538 ACE_UPDATE_NODE_LAYOUT_PROPERTY(SliderLayoutProperty, SliderMode, value, frameNode);
539 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, SliderMode, value, frameNode);
540 }
SetDirection(FrameNode * frameNode,Axis value)541 void SliderModelNG::SetDirection(FrameNode* frameNode, Axis value)
542 {
543 ACE_UPDATE_NODE_LAYOUT_PROPERTY(SliderLayoutProperty, Direction, value, frameNode);
544 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, Direction, value, frameNode);
545 }
SetReverse(FrameNode * frameNode,bool value)546 void SliderModelNG::SetReverse(FrameNode* frameNode, bool value)
547 {
548 ACE_UPDATE_NODE_LAYOUT_PROPERTY(SliderLayoutProperty, Reverse, value, frameNode);
549 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, Reverse, value, frameNode);
550 }
SetStep(FrameNode * frameNode,float value)551 void SliderModelNG::SetStep(FrameNode* frameNode, float value)
552 {
553 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, Step, value, frameNode);
554 }
555
SetValidSlideRange(FrameNode * frameNode,float from,float to)556 void SliderModelNG::SetValidSlideRange(FrameNode* frameNode, float from, float to)
557 {
558 if (std::isnan(from) || std::isnan(to)) {
559 return SliderModelNG::ResetValidSlideRange(frameNode);
560 }
561 CHECK_NULL_VOID(frameNode);
562 auto paintProperty = frameNode->GetPaintProperty<SliderPaintProperty>();
563 CHECK_NULL_VOID(paintProperty);
564 auto minValue = paintProperty->GetMinValue(0.0f);
565 auto maxValue = paintProperty->GetMaxValue(100.0f);
566 auto step = paintProperty->GetStepValue(1.0f);
567 float fromValue = minValue;
568 float toValue = maxValue;
569 if (std::isfinite(from)) {
570 fromValue = from;
571 }
572 if (std::isfinite(to)) {
573 toValue = to;
574 }
575 if (GreatOrEqual(fromValue, minValue) && LessOrEqual(toValue, maxValue) && LessOrEqual(fromValue, toValue) &&
576 GreatNotEqual(step, 0.0f)) {
577 auto toValueCorrection = NearEqual(toValue - step * std::floor(toValue / step), 0) ? 0 : 1;
578 fromValue = LessOrEqual(fromValue, minValue) ? minValue : std::floor(fromValue / step) * step;
579 toValue = GreatOrEqual(toValue, maxValue) ?
580 maxValue : (std::floor(toValue / step) + toValueCorrection) * step;
581 auto sliderValue = std::clamp(paintProperty->GetValueValue(fromValue), fromValue, toValue);
582 RefPtr<SliderModel::SliderValidRange> rangeValue =
583 AceType::MakeRefPtr<SliderModel::SliderValidRange>(fromValue, toValue);
584 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, Value, sliderValue, frameNode);
585 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, ValidSlideRange, rangeValue, frameNode);
586 } else {
587 SliderModelNG::ResetValidSlideRange(frameNode);
588 }
589 }
590
GetBlockColor(FrameNode * frameNode)591 Color SliderModelNG::GetBlockColor(FrameNode* frameNode)
592 {
593 Color value;
594 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
595 SliderPaintProperty, BlockColor, value, frameNode, Color(BLOCK_COLOR));
596 return value;
597 }
598
GetTrackBackgroundColor(FrameNode * frameNode)599 Gradient SliderModelNG::GetTrackBackgroundColor(FrameNode* frameNode)
600 {
601 Gradient value;
602 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
603 SliderPaintProperty, TrackBackgroundColor, value, frameNode,
604 SliderModelNG::CreateSolidGradient(Color(TRACK_COLOR)));
605 return value;
606 }
607
GetSelectColor(FrameNode * frameNode)608 Color SliderModelNG::GetSelectColor(FrameNode* frameNode)
609 {
610 Color value;
611 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
612 SliderPaintProperty, SelectColor, value, frameNode, Color(SELECTED_COLOR));
613 return value;
614 }
615
GetShowSteps(FrameNode * frameNode)616 bool SliderModelNG::GetShowSteps(FrameNode* frameNode)
617 {
618 bool value = false;
619 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
620 SliderPaintProperty, ShowSteps, value, frameNode, false);
621 return value;
622 }
623
GetBlockType(FrameNode * frameNode)624 SliderModel::BlockStyleType SliderModelNG::GetBlockType(FrameNode* frameNode)
625 {
626 SliderModel::BlockStyleType value = SliderModel::BlockStyleType::DEFAULT;
627 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
628 SliderPaintProperty, BlockType, value, frameNode, SliderModel::BlockStyleType::DEFAULT);
629 return value;
630 }
631
GetSliderValue(FrameNode * frameNode)632 float SliderModelNG::GetSliderValue(FrameNode* frameNode)
633 {
634 float value = DEFAULT_MIN_VALUE;
635 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
636 SliderPaintProperty, Value, value, frameNode, DEFAULT_MIN_VALUE);
637 return value;
638 }
639
GetMinLabel(FrameNode * frameNode)640 float SliderModelNG::GetMinLabel(FrameNode* frameNode)
641 {
642 float value = DEFAULT_MIN_VALUE;
643 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
644 SliderPaintProperty, Min, value, frameNode, DEFAULT_MIN_VALUE);
645 return value;
646 }
GetMaxLabel(FrameNode * frameNode)647 float SliderModelNG::GetMaxLabel(FrameNode* frameNode)
648 {
649 float value = DEFAULT_MAX_VALUE;
650 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
651 SliderPaintProperty, Max, value, frameNode, DEFAULT_MAX_VALUE);
652 return value;
653 }
654
GetSliderMode(FrameNode * frameNode)655 SliderModel::SliderMode SliderModelNG::GetSliderMode(FrameNode* frameNode)
656 {
657 SliderModel::SliderMode value = SliderModel::SliderMode::OUTSET;
658 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
659 SliderPaintProperty, SliderMode, value, frameNode, SliderModel::SliderMode::OUTSET);
660 return value;
661 }
GetDirection(FrameNode * frameNode)662 OHOS::Ace::Axis SliderModelNG::GetDirection(FrameNode* frameNode)
663 {
664 OHOS::Ace::Axis value = OHOS::Ace::Axis::HORIZONTAL;
665 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
666 SliderPaintProperty, Direction, value, frameNode, OHOS::Ace::Axis::HORIZONTAL);
667 return value;
668 }
GetReverse(FrameNode * frameNode)669 bool SliderModelNG::GetReverse(FrameNode* frameNode)
670 {
671 bool value = false;
672 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
673 SliderPaintProperty, Reverse, value, frameNode, false);
674 return value;
675 }
GetStep(FrameNode * frameNode)676 float SliderModelNG::GetStep(FrameNode* frameNode)
677 {
678 float value = DEFAULT_STEP;
679 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
680 SliderPaintProperty, Step, value, frameNode, DEFAULT_STEP);
681 return value;
682 }
683
GetBlockImageValue(FrameNode * frameNode)684 std::string SliderModelNG::GetBlockImageValue(FrameNode* frameNode)
685 {
686 std::string value = "";
687 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(
688 SliderPaintProperty, BlockImage, value, frameNode, value);
689 return value;
690 }
691
GetBlockShape(FrameNode * frameNode)692 RefPtr<BasicShape> SliderModelNG::GetBlockShape(FrameNode* frameNode)
693 {
694 RefPtr<BasicShape> value = AceType::MakeRefPtr<BasicShape>();
695 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(SliderPaintProperty, BlockShape, value, frameNode, value);
696 return value;
697 }
698
GetValidSlideRange(FrameNode * frameNode)699 RefPtr<SliderModel::SliderValidRange> SliderModelNG::GetValidSlideRange(FrameNode* frameNode)
700 {
701 RefPtr<SliderModel::SliderValidRange> value = AceType::MakeRefPtr<SliderModel::SliderValidRange>();
702 ACE_GET_NODE_PAINT_PROPERTY_WITH_DEFAULT_VALUE(SliderPaintProperty, ValidSlideRange, value, frameNode, value);
703 return value;
704 }
705
CreateSolidGradient(Color value)706 Gradient SliderModelNG::CreateSolidGradient(Color value)
707 {
708 Gradient gradient;
709 GradientColor gradientColorBegin;
710 gradientColorBegin.SetLinearColor(LinearColor(value));
711 gradientColorBegin.SetDimension(Dimension(0.0f));
712 gradient.AddColor(gradientColorBegin);
713 OHOS::Ace::NG::GradientColor gradientColorEnd;
714 gradientColorEnd.SetLinearColor(LinearColor(value));
715 gradientColorEnd.SetDimension(Dimension(1.0f));
716 gradient.AddColor(gradientColorEnd);
717 return gradient;
718 }
719
SetBuilderFunc(FrameNode * frameNode,SliderMakeCallback && makeFunc)720 void SliderModelNG::SetBuilderFunc(FrameNode* frameNode, SliderMakeCallback&& makeFunc)
721 {
722 CHECK_NULL_VOID(frameNode);
723 auto pattern = frameNode->GetPattern<SliderPattern>();
724 CHECK_NULL_VOID(pattern);
725 pattern->SetBuilderFunc(std::move(makeFunc));
726 }
727
SetChangeValue(FrameNode * frameNode,double value,int32_t mode)728 void SliderModelNG::SetChangeValue(FrameNode* frameNode, double value, int32_t mode)
729 {
730 auto pattern = frameNode->GetPattern<SliderPattern>();
731 CHECK_NULL_VOID(pattern);
732 pattern->SetSliderValue(value, mode);
733 }
734
GetThickness(FrameNode * frameNode)735 Dimension SliderModelNG::GetThickness(FrameNode* frameNode)
736 {
737 Dimension defaultTrackThickness = Dimension(0.0f);
738 CHECK_NULL_RETURN(frameNode, defaultTrackThickness);
739 auto layoutProperty = frameNode->GetLayoutProperty<SliderLayoutProperty>();
740 CHECK_NULL_RETURN(layoutProperty, defaultTrackThickness);
741 auto pipeline = frameNode->GetContext();
742 CHECK_NULL_RETURN(pipeline, defaultTrackThickness);
743 auto theme = pipeline->GetTheme<SliderTheme>();
744 CHECK_NULL_RETURN(theme, defaultTrackThickness);
745 auto sliderMode = layoutProperty->GetSliderModeValue(SliderModel::SliderMode::OUTSET);
746 if (sliderMode == SliderModel::SliderMode::OUTSET) {
747 defaultTrackThickness = theme->GetOutsetTrackThickness();
748 } else if (sliderMode == SliderModel::SliderMode::INSET) {
749 defaultTrackThickness = theme->GetInsetTrackThickness();
750 } else {
751 defaultTrackThickness = theme->GetNoneTrackThickness();
752 }
753
754 Dimension trackThickness = Dimension(0.0f);
755 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
756 SliderLayoutProperty, Thickness, trackThickness, frameNode, defaultTrackThickness);
757 return trackThickness;
758 }
759
SetSelectedBorderRadius(FrameNode * frameNode,const Dimension & value)760 void SliderModelNG::SetSelectedBorderRadius(FrameNode* frameNode, const Dimension& value)
761 {
762 ACE_UPDATE_NODE_PAINT_PROPERTY(SliderPaintProperty, SelectedBorderRadius, value, frameNode);
763 }
764
ResetSelectedBorderRadius(FrameNode * frameNode)765 void SliderModelNG::ResetSelectedBorderRadius(FrameNode* frameNode)
766 {
767 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(
768 SliderPaintProperty, SelectedBorderRadius, PROPERTY_UPDATE_RENDER, frameNode);
769 }
770
ResetSliderInteractionMode(FrameNode * frameNode)771 void SliderModelNG::ResetSliderInteractionMode(FrameNode* frameNode)
772 {
773 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(
774 SliderPaintProperty, SliderInteractionMode, PROPERTY_UPDATE_RENDER, frameNode);
775 }
776
ResetMinResponsiveDistance(FrameNode * frameNode)777 void SliderModelNG::ResetMinResponsiveDistance(FrameNode* frameNode)
778 {
779 ACE_RESET_NODE_PAINT_PROPERTY_WITH_FLAG(
780 SliderPaintProperty, MinResponsiveDistance, PROPERTY_UPDATE_RENDER, frameNode);
781 }
782 } // namespace OHOS::Ace::NG
783