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