1
2 /*
3 * Copyright (c) 2023 Huawei Device Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "core/interfaces/native/node/progress_modifier.h"
18
19 #include <algorithm>
20
21 #include "base/geometry/dimension.h"
22 #include "base/log/log_wrapper.h"
23 #include "base/utils/utils.h"
24 #include "core/components/common/properties/color.h"
25 #include "core/components/progress/progress_component.h"
26 #include "core/components/progress/progress_theme.h"
27 #include "core/components/theme/app_theme.h"
28 #include "core/components_ng/pattern/progress/progress_date.h"
29 #include "core/components_ng/pattern/progress/progress_paint_property.h"
30 #include "core/components_ng/pattern/progress/progress_layout_algorithm.h"
31 #include "core/components_ng/pattern/progress/progress_layout_property.h"
32 #include "core/components_ng/pattern/progress/progress_model_ng.h"
33 #include "core/components_ng/pattern/progress/progress_paint_property.h"
34 #include "core/components_ng/property/measure_property.h"
35 #include "core/pipeline/pipeline_base.h"
36 #include "core/components/select/select_theme.h"
37
38 namespace OHOS::Ace::NG {
39 constexpr double DEFAULT_PROGRESS_VALUE = 0;
40 constexpr int32_t MIN_COLOR_STOPS_VALUE_INDEX = 0;
41 constexpr int32_t MIN_COLOR_STOPS_HAS_DIMENSION_INDEX = 1;
42 constexpr int32_t MIN_COLOR_STOPS_DIMENSION_INDEX = 2;
43 constexpr int32_t MIN_COLOR_STOPS_LENGTH = 3;
44 constexpr double PERCENT_100 = 100;
45 constexpr int32_t DEFAULT_SCALE_COUNT = 120;
46 constexpr double DEFAULT_STROKE_WIDTH = 4;
47 constexpr double DEFAULT_BORDER_WIDTH = 1;
48 constexpr double DEFAULT_SCALE_WIDTHS = 2;
49 constexpr double DEFAULT_FONT_SIZE = 12;
50 const uint32_t ERROR_UINT_CODE = -1;
51 const float ERROR_FLOAT_CODE = -1.0f;
52 const int32_t ERROR_INT_CODE = -1;
53 constexpr float STROKEWIDTH_DEFAULT_VALUE = 4.0f;
54
55 /**
56 * @param colors color value
57 * colors[0], colors[1], colors[2] : color[0](color, hasDimension, dimension)
58 * colors[3], colors[4], colors[5] : color[1](color, hasDimension, dimension)
59 * ...
60 * @param colorsLength colors length
61 */
SetGradientColors(NG::Gradient & gradient,const ArkUI_Float32 * colors,int32_t colorsLength)62 void SetGradientColors(NG::Gradient& gradient, const ArkUI_Float32* colors, int32_t colorsLength)
63 {
64 if ((colors == nullptr) || (colorsLength % MIN_COLOR_STOPS_LENGTH) != 0) {
65 return;
66 }
67 for (int32_t index = 0; index < colorsLength; index += MIN_COLOR_STOPS_LENGTH) {
68 auto colorValue = colors[index + MIN_COLOR_STOPS_VALUE_INDEX];
69 auto colorHasDimension = colors[index + MIN_COLOR_STOPS_HAS_DIMENSION_INDEX];
70 auto colorDimension = colors[index + MIN_COLOR_STOPS_DIMENSION_INDEX];
71 auto color = static_cast<uint32_t>(colorValue);
72 auto hasDimension = static_cast<bool>(colorHasDimension);
73 auto dimension = colorDimension;
74 NG::GradientColor gradientColor;
75 gradientColor.SetColor(Color(color));
76 gradientColor.SetHasValue(hasDimension);
77 if (hasDimension) {
78 gradientColor.SetDimension(CalcDimension(dimension * PERCENT_100, DimensionUnit::PERCENT));
79 }
80 gradient.AddColor(gradientColor);
81 }
82 }
83
SetProgressValue(ArkUINodeHandle node,ArkUI_Float32 value)84 void SetProgressValue(ArkUINodeHandle node, ArkUI_Float32 value)
85 {
86 auto* frameNode = reinterpret_cast<FrameNode*>(node);
87 CHECK_NULL_VOID(frameNode);
88 ProgressModelNG::SetValue(frameNode, value);
89 }
90
ResetProgressValue(ArkUINodeHandle node)91 void ResetProgressValue(ArkUINodeHandle node)
92 {
93 auto* frameNode = reinterpret_cast<FrameNode*>(node);
94 CHECK_NULL_VOID(frameNode);
95 ProgressModelNG::SetValue(frameNode, DEFAULT_PROGRESS_VALUE);
96 }
97
98
SetProgressTotal(ArkUINodeHandle node,ArkUI_Float32 value)99 void SetProgressTotal(ArkUINodeHandle node, ArkUI_Float32 value)
100 {
101 auto* frameNode = reinterpret_cast<FrameNode*>(node);
102 CHECK_NULL_VOID(frameNode);
103 ProgressModelNG::SetTotal(frameNode, value);
104 }
105
SetProgressType(ArkUINodeHandle node,int type)106 void SetProgressType(ArkUINodeHandle node, int type)
107 {
108 auto* frameNode = reinterpret_cast<FrameNode*>(node);
109 CHECK_NULL_VOID(frameNode);
110 ProgressModelNG::SetType(frameNode, static_cast<ProgressType>(type));
111 }
112
ResetProgressType(ArkUINodeHandle node)113 void ResetProgressType(ArkUINodeHandle node)
114 {
115 auto* frameNode = reinterpret_cast<FrameNode*>(node);
116 CHECK_NULL_VOID(frameNode);
117 ProgressModelNG::SetType(frameNode, ProgressType::LINEAR);
118 }
119
SetProgressGradientColor(ArkUINodeHandle node,const struct ArkUIGradientType * gradient,int32_t length)120 void SetProgressGradientColor(ArkUINodeHandle node, const struct ArkUIGradientType* gradient, int32_t length)
121 {
122 auto* frameNode = reinterpret_cast<FrameNode*>(node);
123 CHECK_NULL_VOID(frameNode);
124 OHOS::Ace::NG::Gradient tempGradient;
125 for (int32_t j = 0; j < length; j++) {
126 OHOS::Ace::NG::GradientColor gradientColor;
127 gradientColor.SetLinearColor(LinearColor(Color(gradient->color[j])));
128 gradientColor.SetDimension(
129 Dimension(gradient->offset[j].number, static_cast<DimensionUnit>(gradient->offset[j].unit)));
130 tempGradient.AddColor(gradientColor);
131 }
132
133 ProgressModelNG::SetGradientColor(frameNode, tempGradient);
134 }
135
SetProgressColor(ArkUINodeHandle node,uint32_t color)136 void SetProgressColor(ArkUINodeHandle node, uint32_t color)
137 {
138 auto *frameNode = reinterpret_cast<FrameNode *>(node);
139 CHECK_NULL_VOID(frameNode);
140 NG::Gradient gradient;
141 NG::GradientColor endSideColor;
142 NG::GradientColor beginSideColor;
143 endSideColor.SetLinearColor(LinearColor(Color(color)));
144 endSideColor.SetDimension(Dimension(0.0));
145 beginSideColor.SetLinearColor(LinearColor(Color(color)));
146 beginSideColor.SetDimension(Dimension(1.0));
147 gradient.AddColor(endSideColor);
148 gradient.AddColor(beginSideColor);
149 ProgressModelNG::SetGradientColor(frameNode, gradient);
150 ProgressModelNG::SetColor(frameNode, Color(color));
151 }
152
ResetProgressColor(ArkUINodeHandle node)153 void ResetProgressColor(ArkUINodeHandle node)
154 {
155 auto* frameNode = reinterpret_cast<FrameNode*>(node);
156 CHECK_NULL_VOID(frameNode);
157 Color endColor;
158 Color beginColor;
159 Color colorVal;
160 auto progressLayoutProperty = frameNode->GetLayoutProperty<ProgressLayoutProperty>();
161 CHECK_NULL_VOID(progressLayoutProperty);
162 auto progresstype = progressLayoutProperty->GetType();
163 auto pipeline = PipelineBase::GetCurrentContext();
164 CHECK_NULL_VOID(pipeline);
165 auto progressTheme = pipeline->GetTheme<ProgressTheme>();
166 CHECK_NULL_VOID(progressTheme);
167 if (progresstype == ProgressType::RING) {
168 endColor = progressTheme->GetRingProgressEndSideColor();
169 beginColor = progressTheme->GetRingProgressBeginSideColor();
170 } else if (progresstype == ProgressType::CAPSULE) {
171 colorVal = progressTheme->GetCapsuleSelectColor();
172 } else {
173 colorVal = progressTheme->GetTrackSelectedColor();
174 }
175
176 OHOS::Ace::NG::Gradient gradient;
177 OHOS::Ace::NG::GradientColor endSideColor;
178 OHOS::Ace::NG::GradientColor beginSideColor;
179 endSideColor.SetLinearColor(LinearColor(endColor));
180 endSideColor.SetDimension(Dimension(0.0f));
181 beginSideColor.SetLinearColor(LinearColor(beginColor));
182 beginSideColor.SetDimension(Dimension(1.0f));
183 gradient.AddColor(endSideColor);
184 gradient.AddColor(beginSideColor);
185 ProgressModelNG::SetGradientColor(frameNode, gradient);
186 ProgressModelNG::SetColor(frameNode, colorVal);
187 }
188
SetLinearStyleOptions(FrameNode * node,ArkUIProgressStyle * value)189 void SetLinearStyleOptions(FrameNode* node, ArkUIProgressStyle* value)
190 {
191 if ((value->strokeWidthValue < 0) ||
192 (static_cast<DimensionUnit>(value->strokeWidthUnit) == DimensionUnit::PERCENT)) {
193 ProgressModelNG::SetStrokeWidth(node, Dimension(DEFAULT_STROKE_WIDTH, DimensionUnit::VP));
194 } else {
195 ProgressModelNG::SetStrokeWidth(
196 node, Dimension(value->strokeWidthValue, static_cast<DimensionUnit>(value->strokeWidthUnit)));
197 }
198 ProgressModelNG::SetLinearSweepingEffect(node, value->enableScanEffect);
199 if ((value->strokeRadiusValue < 0) ||
200 (static_cast<DimensionUnit>(value->strokeRadiusUnit) == DimensionUnit::PERCENT)) {
201 ProgressModelNG::ResetStrokeRadius(node);
202 } else {
203 ProgressModelNG::SetStrokeRadius(
204 node, Dimension(value->strokeRadiusValue, static_cast<DimensionUnit>(value->strokeRadiusUnit)));
205 }
206 }
207
SetRingStyleOptions(FrameNode * node,ArkUIProgressStyle * value)208 void SetRingStyleOptions(FrameNode* node, ArkUIProgressStyle* value)
209 {
210 if ((value->strokeWidthValue < 0) ||
211 (static_cast<DimensionUnit>(value->strokeWidthUnit) == DimensionUnit::PERCENT)) {
212 ProgressModelNG::SetStrokeWidth(node, Dimension(DEFAULT_STROKE_WIDTH, DimensionUnit::VP));
213 } else {
214 ProgressModelNG::SetStrokeWidth(
215 node, Dimension(value->strokeWidthValue, static_cast<DimensionUnit>(value->strokeWidthUnit)));
216 }
217 ProgressModelNG::SetPaintShadow(node, value->shadow);
218 ProgressModelNG::SetProgressStatus(node, static_cast<ProgressStatus>(value->status));
219 ProgressModelNG::SetRingSweepingEffect(node, value->enableScanEffect);
220 }
221
SetProgressStyleOptions(FrameNode * node,ArkUIProgressStyle * value)222 void SetProgressStyleOptions(FrameNode* node, ArkUIProgressStyle* value)
223 {
224 if ((value->strokeWidthValue < 0) ||
225 (static_cast<DimensionUnit>(value->strokeWidthUnit) == DimensionUnit::PERCENT)) {
226 ProgressModelNG::SetStrokeWidth(node, Dimension(DEFAULT_STROKE_WIDTH, DimensionUnit::VP));
227 } else {
228 ProgressModelNG::SetStrokeWidth(
229 node, Dimension(value->strokeWidthValue, static_cast<DimensionUnit>(value->strokeWidthUnit)));
230 }
231 ProgressModelNG::SetScaleCount(node, value->scaleCount);
232 if ((static_cast<DimensionUnit>(value->scaleWidthUnit) == DimensionUnit::PERCENT) ||
233 (value->scaleWidthValue > value->strokeWidthValue)) {
234 ProgressModelNG::SetScaleWidth(node, Dimension(DEFAULT_SCALE_WIDTHS, DimensionUnit::VP));
235 } else {
236 ProgressModelNG::SetScaleWidth(
237 node, Dimension(value->scaleWidthValue, static_cast<DimensionUnit>(value->scaleWidthUnit)));
238 }
239 }
240
SetCapsuleStyleOptions(FrameNode * node,ArkUIProgressStyle * value)241 void SetCapsuleStyleOptions(FrameNode* node, ArkUIProgressStyle* value)
242 {
243 double fontSizeNumber = value->fontInfo.fontSizeNumber;
244 int8_t fontSizeUnit = value->fontInfo.fontSizeUnit;
245 uint8_t fontStyle = static_cast<uint8_t>(value->fontInfo.fontStyle);
246 uint8_t fontWeight = static_cast<uint8_t>(value->fontInfo.fontWeight);
247 const char** fontFamilies = value->fontInfo.fontFamilies;
248 uint32_t familyLength = value->fontInfo.familyLength;
249 std::vector<std::string> families;
250 if (fontFamilies && familyLength > 0) {
251 families.resize(familyLength);
252 for (uint32_t i = 0; i < familyLength; i++) {
253 families.at(i) = std::string(*(fontFamilies + i));
254 }
255 }
256 if ((value->borderWidthValue < 0) ||
257 (static_cast<DimensionUnit>(value->borderWidthUnit) == DimensionUnit::PERCENT)) {
258 ProgressModelNG::SetBorderWidth(node, Dimension(DEFAULT_BORDER_WIDTH, DimensionUnit::VP));
259 } else {
260 ProgressModelNG::SetBorderWidth(
261 node, Dimension(value->borderWidthValue, static_cast<DimensionUnit>(value->borderWidthUnit)));
262 }
263 if (value->content == nullptr) {
264 ProgressModelNG::SetText(node, std::nullopt);
265 } else {
266 ProgressModelNG::SetText(node, std::string(value->content));
267 }
268 ProgressModelNG::SetBorderColor(node, Color(value->borderColor));
269 ProgressModelNG::SetSweepingEffect(node, value->enableScanEffect);
270 ProgressModelNG::SetShowText(node, value->showDefaultPercentage);
271 ProgressModelNG::SetFontColor(node, Color(value->fontColor));
272 ProgressModelNG::SetFontSize(node, Dimension(fontSizeNumber, static_cast<DimensionUnit>(fontSizeUnit)));
273 ProgressModelNG::SetFontWeight(node, static_cast<FontWeight>(fontWeight));
274 ProgressModelNG::SetFontFamily(node, families);
275 ProgressModelNG::SetItalicFontStyle(node, static_cast<Ace::FontStyle>(fontStyle));
276 }
277
SetProgressStyle(ArkUINodeHandle node,ArkUIProgressStyle * value)278 void SetProgressStyle(ArkUINodeHandle node, ArkUIProgressStyle* value)
279 {
280 auto* frameNode = reinterpret_cast<FrameNode*>(node);
281 CHECK_NULL_VOID(frameNode);
282 auto progressLayoutProperty = frameNode->GetLayoutProperty<ProgressLayoutProperty>();
283 CHECK_NULL_VOID(progressLayoutProperty);
284 auto progresstype = progressLayoutProperty->GetType();
285
286 ProgressModelNG::SetSmoothEffect(frameNode, value->enableSmoothEffect);
287
288 if (progresstype == ProgressType::LINEAR) {
289 SetLinearStyleOptions(frameNode, value);
290 } else if (progresstype == ProgressType::RING) {
291 SetRingStyleOptions(frameNode, value);
292 } else if (progresstype == ProgressType::CAPSULE) {
293 SetCapsuleStyleOptions(frameNode, value);
294 } else {
295 SetProgressStyleOptions(frameNode, value);
296 }
297 }
298
SetLinearStyleOptions(FrameNode * node)299 void SetLinearStyleOptions(FrameNode* node)
300 {
301 ProgressModelNG::SetStrokeWidth(node, Dimension(DEFAULT_STROKE_WIDTH, DimensionUnit::VP));
302 ProgressModelNG::SetLinearSweepingEffect(node, false);
303 ProgressModelNG::ResetStrokeRadius(node);
304 }
305
SetRingStyleOptions(FrameNode * node)306 void SetRingStyleOptions(FrameNode* node)
307 {
308 ProgressModelNG::SetStrokeWidth(node, Dimension(DEFAULT_STROKE_WIDTH, DimensionUnit::VP));
309 ProgressModelNG::SetPaintShadow(node, false);
310 ProgressModelNG::SetProgressStatus(node, ProgressStatus::PROGRESSING);
311 ProgressModelNG::SetRingSweepingEffect(node, false);
312 }
313
SetProgressStyleOptions(FrameNode * node)314 void SetProgressStyleOptions(FrameNode* node)
315 {
316 ProgressModelNG::SetStrokeWidth(node, Dimension(DEFAULT_STROKE_WIDTH, DimensionUnit::VP));
317 ProgressModelNG::SetScaleCount(node, DEFAULT_SCALE_COUNT);
318 ProgressModelNG::SetScaleWidth(node, Dimension(DEFAULT_SCALE_WIDTHS, DimensionUnit::VP));
319 }
320
SetCapsuleStyleOptions(FrameNode * node)321 void SetCapsuleStyleOptions(FrameNode* node)
322 {
323 auto context = node->GetContext();
324 CHECK_NULL_VOID(context);
325 auto themeManager = context->GetThemeManager();
326 CHECK_NULL_VOID(themeManager);
327
328 auto selectTheme = themeManager->GetTheme<SelectTheme>();
329 CHECK_NULL_VOID(selectTheme);
330 auto textTheme = themeManager->GetTheme<TextTheme>();
331 CHECK_NULL_VOID(textTheme);
332 std::optional<std::string> textOpt = std::nullopt;
333 ProgressModelNG::SetBorderWidth(node, Dimension(DEFAULT_BORDER_WIDTH, DimensionUnit::VP));
334 ProgressModelNG::SetBorderColor(node, Color(0x33006cde));
335 ProgressModelNG::SetSweepingEffect(node, false);
336 ProgressModelNG::SetShowText(node, false);
337 ProgressModelNG::SetText(node, textOpt);
338 ProgressModelNG::SetFontColor(node, Color(0xff182431));
339 ProgressModelNG::SetFontSize(node, Dimension(DEFAULT_FONT_SIZE, DimensionUnit::FP));
340 ProgressModelNG::SetFontWeight(node, textTheme->GetTextStyle().GetFontWeight());
341 ProgressModelNG::SetFontFamily(node, textTheme->GetTextStyle().GetFontFamilies());
342 ProgressModelNG::SetItalicFontStyle(node, textTheme->GetTextStyle().GetFontStyle());
343 }
344
ResetProgressStyle(ArkUINodeHandle node)345 void ResetProgressStyle(ArkUINodeHandle node)
346 {
347 auto* frameNode = reinterpret_cast<FrameNode*>(node);
348 CHECK_NULL_VOID(frameNode);
349 auto progressLayoutProperty = frameNode->GetLayoutProperty<ProgressLayoutProperty>();
350 CHECK_NULL_VOID(progressLayoutProperty);
351 auto progresstype = progressLayoutProperty->GetType();
352 ProgressModelNG::SetSmoothEffect(frameNode, true);
353
354 if (progresstype == ProgressType::LINEAR) {
355 SetLinearStyleOptions(frameNode);
356 } else if (progresstype == ProgressType::RING) {
357 SetRingStyleOptions(frameNode);
358 } else if (progresstype == ProgressType::CAPSULE) {
359 SetCapsuleStyleOptions(frameNode);
360 } else {
361 SetProgressStyleOptions(frameNode);
362 }
363 }
364
SetProgressBackgroundColor(ArkUINodeHandle node,uint32_t color)365 void SetProgressBackgroundColor(ArkUINodeHandle node, uint32_t color)
366 {
367 auto *frameNode = reinterpret_cast<FrameNode *>(node);
368 CHECK_NULL_VOID(frameNode);
369 ProgressModelNG::SetBackgroundColor(frameNode, Color(color));
370 }
371
ResetProgressBackgroundColor(ArkUINodeHandle node)372 void ResetProgressBackgroundColor(ArkUINodeHandle node)
373 {
374 auto *frameNode = reinterpret_cast<FrameNode *>(node);
375 CHECK_NULL_VOID(frameNode);
376 auto progressLayoutProperty = frameNode->GetLayoutProperty<ProgressLayoutProperty>();
377 CHECK_NULL_VOID(progressLayoutProperty);
378 auto progresstype = progressLayoutProperty->GetType();
379 auto pipelineContext = PipelineBase::GetCurrentContext();
380 CHECK_NULL_VOID(pipelineContext);
381 auto theme = pipelineContext->GetTheme<ProgressTheme>();
382 CHECK_NULL_VOID(theme);
383
384 Color backgroundColor;
385 if (progresstype == ProgressType::CAPSULE) {
386 backgroundColor = theme->GetCapsuleBgColor();
387 } else if (progresstype == ProgressType::RING) {
388 backgroundColor = theme->GetRingProgressBgColor();
389 } else {
390 backgroundColor = theme->GetTrackBgColor();
391 }
392
393 ProgressModelNG::SetBackgroundColor(frameNode, backgroundColor);
394 }
395
GetProgressValue(ArkUINodeHandle node)396 ArkUI_Float32 GetProgressValue(ArkUINodeHandle node)
397 {
398 auto *frameNode = reinterpret_cast<FrameNode *>(node);
399 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
400 return ProgressModelNG::GetValue(frameNode);
401 }
402
GetProgressTotal(ArkUINodeHandle node)403 ArkUI_Float32 GetProgressTotal(ArkUINodeHandle node)
404 {
405 auto *frameNode = reinterpret_cast<FrameNode *>(node);
406 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
407 return ProgressModelNG::GetTotal(frameNode);
408 }
409
GetProgressType(ArkUINodeHandle node)410 ArkUI_Int32 GetProgressType(ArkUINodeHandle node)
411 {
412 auto *frameNode = reinterpret_cast<FrameNode *>(node);
413 CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE);
414 return static_cast<ArkUI_Int32>(ProgressModelNG::GetType(frameNode));
415 }
416
GetProgressColor(ArkUINodeHandle node)417 ArkUI_Uint32 GetProgressColor(ArkUINodeHandle node)
418 {
419 auto *frameNode = reinterpret_cast<FrameNode *>(node);
420 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
421 return ProgressModelNG::GetColor(frameNode).GetValue();
422 }
423
GetProgressLinearStyle(ArkUINodeHandle node,ArkUIProgressLinearStyleOption & option)424 void GetProgressLinearStyle(ArkUINodeHandle node, ArkUIProgressLinearStyleOption& option)
425 {
426 auto* frameNode = reinterpret_cast<FrameNode *>(node);
427 CHECK_NULL_VOID(frameNode);
428 auto paintProperty = frameNode->GetPaintProperty<ProgressPaintProperty>();
429 CHECK_NULL_VOID(paintProperty);
430 auto layoutProperty = frameNode->GetLayoutProperty<ProgressLayoutProperty>();
431 CHECK_NULL_VOID(layoutProperty);
432
433 option.scanEffectEnable = paintProperty->GetEnableLinearScanEffect().value_or(false);
434 option.smoothEffectEnable = paintProperty->GetEnableSmoothEffect().value_or(true);
435 auto strokeWidth = layoutProperty->GetStrokeWidth().value_or(
436 Dimension(STROKEWIDTH_DEFAULT_VALUE, DimensionUnit::VP)).Value();
437 option.strokeWidth = strokeWidth;
438 auto strokeRadius = paintProperty->GetStrokeRadiusValue(Dimension(strokeWidth / 2.0f, DimensionUnit::VP)).Value();
439 strokeRadius = std::min(strokeWidth / 2.0f, strokeRadius);
440 option.strokeRadius = strokeRadius;
441 }
442
SetProgressInitialize(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Float32 total,ArkUI_Int32 progressStyle)443 void SetProgressInitialize(
444 ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Float32 total, ArkUI_Int32 progressStyle)
445 {
446 auto* frameNode = reinterpret_cast<FrameNode*>(node);
447 CHECK_NULL_VOID(frameNode);
448 ProgressModelNG::ProgressInitialize(
449 frameNode, 0.0, value, 0.0, total, static_cast<NG::ProgressType>(progressStyle));
450 }
451
ResetProgressInitialize(ArkUINodeHandle node)452 void ResetProgressInitialize(ArkUINodeHandle node)
453 {
454 auto* frameNode = reinterpret_cast<FrameNode*>(node);
455 CHECK_NULL_VOID(frameNode);
456 auto value = 0;
457 auto total = 100;
458 ProgressModelNG::ProgressInitialize(
459 frameNode, 0.0, value, 0.0, total, ProgressType::LINEAR);
460 }
461
462 namespace NodeModifier {
GetProgressModifier()463 const ArkUIProgressModifier* GetProgressModifier()
464 {
465 static const ArkUIProgressModifier modifier = { SetProgressValue, ResetProgressValue, SetProgressGradientColor,
466 SetProgressColor, ResetProgressColor, SetProgressStyle, ResetProgressStyle, SetProgressBackgroundColor,
467 ResetProgressBackgroundColor, SetProgressTotal, SetProgressType, ResetProgressType, GetProgressValue,
468 GetProgressTotal, GetProgressType, GetProgressColor, SetProgressInitialize, ResetProgressInitialize,
469 GetProgressLinearStyle };
470 return &modifier;
471 }
472
GetCJUIProgressModifier()473 const CJUIProgressModifier* GetCJUIProgressModifier()
474 {
475 static const CJUIProgressModifier modifier = { SetProgressValue, ResetProgressValue, SetProgressGradientColor,
476 SetProgressColor, ResetProgressColor, SetProgressStyle, ResetProgressStyle, SetProgressBackgroundColor,
477 ResetProgressBackgroundColor, SetProgressTotal, SetProgressType, ResetProgressType, GetProgressValue,
478 GetProgressTotal, GetProgressType, GetProgressColor, SetProgressInitialize, ResetProgressInitialize };
479 return &modifier;
480 }
481 }
482 } // namespace OHOS::Ace::NG
483