1 /*
2 * Copyright (c) 2024 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 "node_toggle_modifier.h"
16
17 #include "core/components/checkable/checkable_theme.h"
18 #include "core/components_ng/base/view_abstract.h"
19 #include "core/components_ng/pattern/toggle/toggle_model_ng.h"
20 #include "core/pipeline_ng/pipeline_context.h"
21
22 namespace OHOS::Ace::NG {
23 const int32_t ERROR_UINT_CODE = -1;
24 namespace {
25 constexpr uint32_t RESPONSE_REGION_STEP = 4;
26 constexpr uint32_t OFFSET_0 = 0;
27 constexpr uint32_t OFFSET_1 = 1;
28 constexpr uint32_t OFFSET_2 = 2;
29 constexpr uint32_t OFFSET_3 = 3;
30 constexpr uint32_t INDEX_DIMENSION_TOP_0 = 0;
31 constexpr uint32_t INDEX_DIMENSION_RIGHT_1 = 1;
32 constexpr uint32_t INDEX_DIMENSION_BOTTOM_2 = 2;
33 constexpr uint32_t INDEX_DIMENSION_LEFT_3 = 3;
34 constexpr uint32_t DIMENSION_STEP = 3;
35
SetToggleDimension(const ArkUI_Float32 * dimensionArray,ArkUI_Uint32 offset,const size_t dataCount,std::optional<CalcDimension> & optDimension)36 bool SetToggleDimension(
37 const ArkUI_Float32* dimensionArray, ArkUI_Uint32 offset, const size_t dataCount,
38 std::optional<CalcDimension>& optDimension)
39 {
40 CHECK_NULL_RETURN(dimensionArray, false);
41 auto hasValue = dimensionArray[offset];
42 if (!static_cast<bool>(hasValue)) {
43 return false;
44 }
45 uint32_t valueIndex = offset + 1;
46 uint32_t unitIndex = offset + 2;
47 if (unitIndex >= dataCount) {
48 return false;
49 }
50 auto value = dimensionArray[valueIndex];
51 auto unit = dimensionArray[unitIndex];
52 DimensionUnit unitValue = static_cast<DimensionUnit>(unit);
53 CalcDimension dimensionValue = CalcDimension(value, unitValue);
54 optDimension = dimensionValue;
55 return true;
56 }
57
SetToggleSelectedColor(ArkUINodeHandle node,ArkUI_Uint32 selectedColor)58 void SetToggleSelectedColor(ArkUINodeHandle node, ArkUI_Uint32 selectedColor)
59 {
60 auto* frameNode = reinterpret_cast<FrameNode*>(node);
61 CHECK_NULL_VOID(frameNode);
62 ToggleModelNG::SetSelectedColor(frameNode, Color(selectedColor));
63 }
64
SetToggleSelectedColorPtr(ArkUINodeHandle node,ArkUI_Uint32 selectedColor,void * colorRawPtr)65 void SetToggleSelectedColorPtr(ArkUINodeHandle node, ArkUI_Uint32 selectedColor, void* colorRawPtr)
66 {
67 CHECK_NULL_VOID(node);
68 SetToggleSelectedColor(node, selectedColor);
69 if (SystemProperties::ConfigChangePerform()) {
70 auto* frameNode = reinterpret_cast<FrameNode*>(node);
71 CHECK_NULL_VOID(frameNode);
72 auto* color = reinterpret_cast<ResourceObject*>(colorRawPtr);
73 auto colorResObj = AceType::Claim(color);
74 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleColorType::SELECTED_COLOR, colorResObj);
75 }
76 }
77
ResetToggleSelectedColor(ArkUINodeHandle node)78 void ResetToggleSelectedColor(ArkUINodeHandle node)
79 {
80 auto* frameNode = reinterpret_cast<FrameNode*>(node);
81 CHECK_NULL_VOID(frameNode);
82 std::optional<Color> selectedColor;
83 ToggleModelNG::SetSelectedColor(frameNode, selectedColor);
84 if (SystemProperties::ConfigChangePerform()) {
85 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleColorType::SELECTED_COLOR, nullptr);
86 }
87 }
88
SetToggleSwitchPointColor(ArkUINodeHandle node,ArkUI_Uint32 switchPointColor)89 void SetToggleSwitchPointColor(ArkUINodeHandle node, ArkUI_Uint32 switchPointColor)
90 {
91 auto* frameNode = reinterpret_cast<FrameNode*>(node);
92 CHECK_NULL_VOID(frameNode);
93 ToggleModelNG::SetSwitchPointColor(frameNode, Color(switchPointColor));
94 ToggleModelNG::SetSwitchPointColorSetByUser(frameNode, true);
95 }
96
SetToggleSwitchPointColorPtr(ArkUINodeHandle node,ArkUI_Uint32 switchPointColor,void * colorRawPtr)97 void SetToggleSwitchPointColorPtr(ArkUINodeHandle node, ArkUI_Uint32 switchPointColor, void* colorRawPtr)
98 {
99 CHECK_NULL_VOID(node);
100 SetToggleSwitchPointColor(node, switchPointColor);
101 if (SystemProperties::ConfigChangePerform()) {
102 auto* frameNode = reinterpret_cast<FrameNode*>(node);
103 CHECK_NULL_VOID(frameNode);
104 auto* color = reinterpret_cast<ResourceObject*>(colorRawPtr);
105 auto colorResObj = AceType::Claim(color);
106 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleColorType::SWITCH_POINT_COLOR, colorResObj);
107 }
108 }
109
ResetToggleSwitchPointColor(ArkUINodeHandle node)110 void ResetToggleSwitchPointColor(ArkUINodeHandle node)
111 {
112 auto* frameNode = reinterpret_cast<FrameNode*>(node);
113 CHECK_NULL_VOID(frameNode);
114 auto context = frameNode->GetContext();
115 CHECK_NULL_VOID(context);
116 auto themeManager = context->GetThemeManager();
117 CHECK_NULL_VOID(themeManager);
118 auto theme = themeManager->GetTheme<SwitchTheme>();
119 Color color;
120 if (theme) {
121 color = theme->GetPointColor();
122 }
123 ToggleModelNG::SetSwitchPointColor(frameNode, Color(color));
124 ToggleModelNG::SetSwitchPointColorSetByUser(frameNode, false);
125 if (SystemProperties::ConfigChangePerform()) {
126 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleColorType::SWITCH_POINT_COLOR, nullptr);
127 }
128 }
129
GetToggleSelectedColor(ArkUINodeHandle node)130 ArkUI_Uint32 GetToggleSelectedColor(ArkUINodeHandle node)
131 {
132 auto* frameNode = reinterpret_cast<FrameNode*>(node);
133 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
134 return ToggleModelNG::GetSelectedColor(frameNode).GetValue();
135 }
136
GetToggleSwitchPointColor(ArkUINodeHandle node)137 ArkUI_Uint32 GetToggleSwitchPointColor(ArkUINodeHandle node)
138 {
139 auto* frameNode = reinterpret_cast<FrameNode*>(node);
140 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
141 return ToggleModelNG::GetSwitchPointColor(frameNode).GetValue();
142 }
143
SetToggleHeight(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)144 void SetToggleHeight(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
145 {
146 auto* frameNode = reinterpret_cast<FrameNode*>(node);
147 CHECK_NULL_VOID(frameNode);
148 DimensionUnit unitValue = static_cast<DimensionUnit>(unit);
149 CalcDimension dimensionValue = CalcDimension(value, unitValue);
150 ToggleModelNG::SetHeight(frameNode, dimensionValue);
151 }
152
ResetToggleHeight(ArkUINodeHandle node)153 void ResetToggleHeight(ArkUINodeHandle node)
154 {
155 auto* frameNode = reinterpret_cast<FrameNode*>(node);
156 CHECK_NULL_VOID(frameNode);
157 auto switchTheme = GetTheme<SwitchTheme>();
158 CHECK_NULL_VOID(switchTheme);
159 auto defaultHeight = switchTheme->GetHeight();
160 auto verticalPadding = switchTheme->GetHotZoneVerticalPadding();
161 auto height = defaultHeight - verticalPadding * 2;
162 CalcDimension value(height);
163 ToggleModelNG::SetHeight(frameNode, value);
164 }
165
SetToggleResponseRegion(ArkUINodeHandle node,const ArkUI_Float32 * values,const ArkUI_Int32 * units,ArkUI_Uint32 length)166 void SetToggleResponseRegion(ArkUINodeHandle node, const ArkUI_Float32* values,
167 const ArkUI_Int32* units, ArkUI_Uint32 length)
168 {
169 CHECK_NULL_VOID(values);
170 CHECK_NULL_VOID(units);
171 auto* frameNode = reinterpret_cast<FrameNode*>(node);
172 CHECK_NULL_VOID(frameNode);
173 std::vector<DimensionRect> region;
174 for (uint32_t i = 0; i + OFFSET_3 < length; i = i + RESPONSE_REGION_STEP) {
175 CalcDimension xDimen = CalcDimension(values[i + OFFSET_0], static_cast<DimensionUnit>(units[i + OFFSET_0]));
176 CalcDimension yDimen = CalcDimension(values[i + OFFSET_1], static_cast<DimensionUnit>(units[i + OFFSET_1]));
177 CalcDimension widthDimen = CalcDimension(values[i + OFFSET_2], static_cast<DimensionUnit>(units[i + OFFSET_2]));
178 CalcDimension heightDimen =
179 CalcDimension(values[i + OFFSET_3], static_cast<DimensionUnit>(units[i + OFFSET_3]));
180 DimensionOffset offsetDimen(xDimen, yDimen);
181 DimensionRect dimenRect(widthDimen, heightDimen, offsetDimen);
182 region.emplace_back(dimenRect);
183 }
184 ToggleModelNG::SetResponseRegion(frameNode, region);
185 }
186
ResetToggleResponseRegion(ArkUINodeHandle node)187 void ResetToggleResponseRegion(ArkUINodeHandle node)
188 {
189 auto* frameNode = reinterpret_cast<FrameNode*>(node);
190 CHECK_NULL_VOID(frameNode);
191 std::vector<DimensionRect> region;
192 CalcDimension xDimen = CalcDimension(0.0, DimensionUnit::VP);
193 CalcDimension yDimen = CalcDimension(0.0, DimensionUnit::VP);
194 CalcDimension widthDimen = CalcDimension(1, DimensionUnit::PERCENT);
195 CalcDimension heightDimen = CalcDimension(1, DimensionUnit::PERCENT);
196 DimensionOffset offsetDimen(xDimen, yDimen);
197 DimensionRect dimenRect(widthDimen, heightDimen, offsetDimen);
198 region.emplace_back(dimenRect);
199 ToggleModelNG::SetResponseRegion(frameNode, region);
200 }
201
SetTogglePadding(ArkUINodeHandle node,const ArkUI_Float32 * values,const ArkUI_Uint32 length)202 void SetTogglePadding(ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Uint32 length)
203 {
204 auto* frameNode = reinterpret_cast<FrameNode*>(node);
205 CHECK_NULL_VOID(frameNode);
206 CHECK_NULL_VOID(values);
207 CalcLength topDimen;
208 CalcLength rightDimen;
209 CalcLength bottomDimen;
210 CalcLength leftDimen;
211 uint32_t step = DIMENSION_STEP;
212 uint32_t topIndex = INDEX_DIMENSION_TOP_0;
213 std::optional<CalcDimension> topOptional = std::nullopt;
214 if (SetToggleDimension(values, topIndex, length, topOptional)) {
215 topDimen = CalcLength(
216 CalcDimension(topOptional.value().Value(), static_cast<DimensionUnit>(topOptional.value().Unit())));
217 }
218 uint32_t rightIndex = INDEX_DIMENSION_RIGHT_1 * step;
219 std::optional<CalcDimension> rightOptional = std::nullopt;
220 if (SetToggleDimension(values, rightIndex, length, rightOptional)) {
221 rightDimen = CalcLength(
222 CalcDimension(rightOptional.value().Value(), static_cast<DimensionUnit>(rightOptional.value().Unit())));
223 }
224 uint32_t bottomIndex = INDEX_DIMENSION_BOTTOM_2 * step;
225 std::optional<CalcDimension> bottomOptional = std::nullopt;
226 if (SetToggleDimension(values, bottomIndex, length, bottomOptional)) {
227 bottomDimen = CalcLength(
228 CalcDimension(bottomOptional.value().Value(), static_cast<DimensionUnit>(bottomOptional.value().Unit())));
229 }
230 uint32_t leftIndex = INDEX_DIMENSION_LEFT_3 * step;
231 std::optional<CalcDimension> leftOptional = std::nullopt;
232 if (SetToggleDimension(values, leftIndex, length, leftOptional)) {
233 leftDimen = CalcLength(
234 CalcDimension(leftOptional.value().Value(), static_cast<DimensionUnit>(leftOptional.value().Unit())));
235 }
236 NG::PaddingPropertyF oldPaddings;
237 NG::PaddingProperty paddings;
238 paddings.top = std::optional<CalcLength>(topDimen);
239 paddings.bottom = std::optional<CalcLength>(bottomDimen);
240 paddings.left = std::optional<CalcLength>(leftDimen);
241 paddings.right = std::optional<CalcLength>(rightDimen);
242 ToggleModelNG::SetPadding(frameNode, oldPaddings, paddings);
243 }
244
ResetTogglePadding(ArkUINodeHandle node)245 void ResetTogglePadding(ArkUINodeHandle node)
246 {
247 auto* frameNode = reinterpret_cast<FrameNode*>(node);
248 CHECK_NULL_VOID(frameNode);
249 NG::PaddingPropertyF oldPaddings;
250 NG::PaddingProperty paddings;
251 paddings.top = std::optional<CalcLength>(CalcLength(0.0, DimensionUnit::VP));
252 paddings.bottom = std::optional<CalcLength>(CalcLength(0.0, DimensionUnit::VP));
253 paddings.left = std::optional<CalcLength>(CalcLength(0.0, DimensionUnit::VP));
254 paddings.right = std::optional<CalcLength>(CalcLength(0.0, DimensionUnit::VP));
255 ToggleModelNG::SetPadding(frameNode, oldPaddings, paddings);
256 }
257
SetToggleBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)258 void SetToggleBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
259 {
260 auto* frameNode = reinterpret_cast<FrameNode*>(node);
261 CHECK_NULL_VOID(frameNode);
262 ToggleModelNG::SetBackgroundColor(frameNode, Color(color));
263 }
264
SetToggleBackgroundColorWithColorSpace(ArkUINodeHandle node,ArkUI_Uint32 color,ArkUI_Int32 colorSpace)265 void SetToggleBackgroundColorWithColorSpace(ArkUINodeHandle node, ArkUI_Uint32 color, ArkUI_Int32 colorSpace)
266 {
267 auto* frameNode = reinterpret_cast<FrameNode*>(node);
268 CHECK_NULL_VOID(frameNode);
269 Color backgroundColor { color };
270 if (ColorSpace::DISPLAY_P3 == colorSpace) {
271 backgroundColor.SetColorSpace(ColorSpace::DISPLAY_P3);
272 } else {
273 backgroundColor.SetColorSpace(ColorSpace::SRGB);
274 }
275 ToggleModelNG::SetBackgroundColor(frameNode, backgroundColor);
276 }
277
ResetToggleBackgroundColor(ArkUINodeHandle node)278 void ResetToggleBackgroundColor(ArkUINodeHandle node)
279 {
280 auto* frameNode = reinterpret_cast<FrameNode*>(node);
281 CHECK_NULL_VOID(frameNode);
282 ToggleModelNG::SetBackgroundColor(frameNode, Color(Color::TRANSPARENT));
283 }
284
SetToggleHoverEffect(ArkUINodeHandle node,ArkUI_Int32 hoverEffectValue)285 void SetToggleHoverEffect(ArkUINodeHandle node, ArkUI_Int32 hoverEffectValue)
286 {
287 auto* frameNode = reinterpret_cast<FrameNode*>(node);
288 CHECK_NULL_VOID(frameNode);
289 OHOS::Ace::HoverEffectType hoverEffect = OHOS::Ace::HoverEffectType::AUTO;
290 hoverEffect = static_cast<OHOS::Ace::HoverEffectType>(hoverEffectValue);
291 ToggleModelNG::SetHoverEffect(frameNode, hoverEffect);
292 }
293
ResetToggleHoverEffect(ArkUINodeHandle node)294 void ResetToggleHoverEffect(ArkUINodeHandle node)
295 {
296 auto* frameNode = reinterpret_cast<FrameNode*>(node);
297 CHECK_NULL_VOID(frameNode);
298 ToggleModelNG::SetHoverEffect(frameNode, OHOS::Ace::HoverEffectType::AUTO);
299 }
300
SetTogglePointRadius(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)301 void SetTogglePointRadius(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
302 {
303 auto* frameNode = reinterpret_cast<FrameNode*>(node);
304 CHECK_NULL_VOID(frameNode);
305 DimensionUnit unitValue = static_cast<DimensionUnit>(unit);
306 CalcDimension switchPointRadius = CalcDimension(value, unitValue);
307 ToggleModelNG::SetPointRadius(frameNode, switchPointRadius);
308 }
309
SetTogglePointRadiusPtr(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit,void * radiusRawPtr)310 void SetTogglePointRadiusPtr(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit, void* radiusRawPtr)
311 {
312 CHECK_NULL_VOID(node);
313 SetTogglePointRadius(node, value, unit);
314 if (SystemProperties::ConfigChangePerform()) {
315 auto* frameNode = reinterpret_cast<FrameNode*>(node);
316 CHECK_NULL_VOID(frameNode);
317 auto* pointRadius = reinterpret_cast<ResourceObject*>(radiusRawPtr);
318 auto resObj = AceType::Claim(pointRadius);
319 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleDimensionType::POINT_RADIUS, resObj);
320 }
321 }
322
ResetTogglePointRadius(ArkUINodeHandle node)323 void ResetTogglePointRadius(ArkUINodeHandle node)
324 {
325 auto* frameNode = reinterpret_cast<FrameNode*>(node);
326 CHECK_NULL_VOID(frameNode);
327 ToggleModelNG::ResetPointRadius(frameNode);
328 if (SystemProperties::ConfigChangePerform()) {
329 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleDimensionType::POINT_RADIUS, nullptr);
330 }
331 }
332
SetToggleUnselectedColor(ArkUINodeHandle node,ArkUI_Uint32 unselectedColor)333 void SetToggleUnselectedColor(ArkUINodeHandle node, ArkUI_Uint32 unselectedColor)
334 {
335 auto* frameNode = reinterpret_cast<FrameNode*>(node);
336 CHECK_NULL_VOID(frameNode);
337 ToggleModelNG::SetUnselectedColor(frameNode, Color(unselectedColor));
338 ToggleModelNG::SetUnselectedColorSetByUser(frameNode, true);
339 }
340
SetToggleUnselectedColorPtr(ArkUINodeHandle node,ArkUI_Uint32 unselectedColor,void * colorRawPtr)341 void SetToggleUnselectedColorPtr(ArkUINodeHandle node, ArkUI_Uint32 unselectedColor, void* colorRawPtr)
342 {
343 CHECK_NULL_VOID(node);
344 SetToggleUnselectedColor(node, unselectedColor);
345 if (SystemProperties::ConfigChangePerform()) {
346 auto* frameNode = reinterpret_cast<FrameNode*>(node);
347 CHECK_NULL_VOID(frameNode);
348 auto* color = reinterpret_cast<ResourceObject*>(colorRawPtr);
349 auto colorResObj = AceType::Claim(color);
350 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleColorType::UN_SELECTED_COLOR, colorResObj);
351 }
352 }
353
ResetToggleUnselectedColor(ArkUINodeHandle node)354 void ResetToggleUnselectedColor(ArkUINodeHandle node)
355 {
356 auto* frameNode = reinterpret_cast<FrameNode*>(node);
357 CHECK_NULL_VOID(frameNode);
358 auto context = frameNode->GetContext();
359 CHECK_NULL_VOID(context);
360 auto themeManager = context->GetThemeManager();
361 CHECK_NULL_VOID(themeManager);
362 auto switchTheme = themeManager->GetTheme<SwitchTheme>();
363 CHECK_NULL_VOID(switchTheme);
364 Color unselectedColor;
365 if (switchTheme) {
366 unselectedColor = switchTheme->GetInactiveColor();
367 }
368 ToggleModelNG::SetUnselectedColor(frameNode, unselectedColor);
369 ToggleModelNG::SetUnselectedColorSetByUser(frameNode, false);
370 if (SystemProperties::ConfigChangePerform()) {
371 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleColorType::UN_SELECTED_COLOR, nullptr);
372 }
373 }
374
SetToggleTrackBorderRadius(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)375 void SetToggleTrackBorderRadius(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
376 {
377 auto* frameNode = reinterpret_cast<FrameNode*>(node);
378 CHECK_NULL_VOID(frameNode);
379 DimensionUnit unitValue = static_cast<DimensionUnit>(unit);
380 CalcDimension borderRadius = CalcDimension(value, unitValue);
381 ToggleModelNG::SetTrackBorderRadius(frameNode, borderRadius);
382 }
383
SetToggleTrackBorderRadiusPtr(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit,void * radiusRawPtr)384 void SetToggleTrackBorderRadiusPtr(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit, void* radiusRawPtr)
385 {
386 CHECK_NULL_VOID(node);
387 SetToggleTrackBorderRadius(node, value, unit);
388 if (SystemProperties::ConfigChangePerform()) {
389 auto* frameNode = reinterpret_cast<FrameNode*>(node);
390 CHECK_NULL_VOID(frameNode);
391 auto* trackBorderRadius = reinterpret_cast<ResourceObject*>(radiusRawPtr);
392 auto resObj = AceType::Claim(trackBorderRadius);
393 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleDimensionType::TRACK_BORDER_RADIUS, resObj);
394 }
395 }
396
ResetToggleTrackBorderRadius(ArkUINodeHandle node)397 void ResetToggleTrackBorderRadius(ArkUINodeHandle node)
398 {
399 auto* frameNode = reinterpret_cast<FrameNode*>(node);
400 CHECK_NULL_VOID(frameNode);
401 ToggleModelNG::ResetTrackBorderRadius(frameNode);
402 if (SystemProperties::ConfigChangePerform()) {
403 ToggleModelNG::CreateWithResourceObj(frameNode, ToggleDimensionType::TRACK_BORDER_RADIUS, nullptr);
404 }
405 }
406
SetToggleIsOn(ArkUINodeHandle node,ArkUI_Bool switchPointColor)407 void SetToggleIsOn(ArkUINodeHandle node, ArkUI_Bool switchPointColor)
408 {
409 auto* frameNode = reinterpret_cast<FrameNode*>(node);
410 CHECK_NULL_VOID(frameNode);
411 ToggleModelNG::SetSwitchIsOn(frameNode, static_cast<bool>(switchPointColor));
412 }
413
ResetToggleIsOn(ArkUINodeHandle node)414 void ResetToggleIsOn(ArkUINodeHandle node)
415 {
416 auto* frameNode = reinterpret_cast<FrameNode*>(node);
417 CHECK_NULL_VOID(frameNode);
418 ToggleModelNG::SetSwitchIsOn(frameNode, false);
419 }
420
GetToggleIsOn(ArkUINodeHandle node)421 ArkUI_Bool GetToggleIsOn(ArkUINodeHandle node)
422 {
423 auto* frameNode = reinterpret_cast<FrameNode*>(node);
424 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
425 return static_cast<ArkUI_Bool>(ToggleModelNG::GetSwitchIsOn(frameNode));
426 }
427
GetToggleUnselectedColor(ArkUINodeHandle node)428 ArkUI_Uint32 GetToggleUnselectedColor(ArkUINodeHandle node)
429 {
430 auto* frameNode = reinterpret_cast<FrameNode*>(node);
431 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
432 return ToggleModelNG::GetUnselectedColor(frameNode).GetValue();
433 }
434
SetToggleState(ArkUINodeHandle node,ArkUI_Bool isOn)435 void SetToggleState(ArkUINodeHandle node, ArkUI_Bool isOn)
436 {
437 auto* frameNode = reinterpret_cast<FrameNode*>(node);
438 CHECK_NULL_VOID(frameNode);
439 ToggleModelNG::SetToggleState(frameNode, static_cast<bool>(isOn));
440 }
441
SetToggleOnChange(ArkUINodeHandle node,void * callback)442 void SetToggleOnChange(ArkUINodeHandle node, void* callback)
443 {
444 auto* frameNode = reinterpret_cast<FrameNode*>(node);
445 CHECK_NULL_VOID(frameNode);
446 if (callback) {
447 auto onChange = reinterpret_cast<std::function<void(bool)>*>(callback);
448 ToggleModelNG::OnChange(frameNode, std::move(*onChange));
449 } else {
450 ToggleModelNG::OnChange(frameNode, nullptr);
451 }
452 }
453
ResetToggleOnChange(ArkUINodeHandle node)454 void ResetToggleOnChange(ArkUINodeHandle node)
455 {
456 auto *frameNode = reinterpret_cast<FrameNode *>(node);
457 CHECK_NULL_VOID(frameNode);
458 ToggleModelNG::OnChange(frameNode, nullptr);
459 }
460
SetIsUserSetMargin(ArkUINodeHandle node)461 void SetIsUserSetMargin(ArkUINodeHandle node)
462 {
463 auto* frameNode = reinterpret_cast<FrameNode*>(node);
464 CHECK_NULL_VOID(frameNode);
465 ToggleModelNG::SetIsUserSetMargin(frameNode, true);
466 }
467 } // namespace
468 namespace NodeModifier {
GetToggleModifier()469 const ArkUIToggleModifier* GetToggleModifier()
470 {
471 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
472 static const ArkUIToggleModifier modifier = {
473 .setToggleSelectedColor = SetToggleSelectedColor,
474 .resetToggleSelectedColor = ResetToggleSelectedColor,
475 .setToggleSwitchPointColor = SetToggleSwitchPointColor,
476 .resetToggleSwitchPointColor = ResetToggleSwitchPointColor,
477 .setToggleHeight = SetToggleHeight,
478 .resetToggleHeight = ResetToggleHeight,
479 .setToggleResponseRegion = SetToggleResponseRegion,
480 .resetToggleResponseRegion = ResetToggleResponseRegion,
481 .setTogglePadding = SetTogglePadding,
482 .resetTogglePadding = ResetTogglePadding,
483 .setToggleBackgroundColor = SetToggleBackgroundColor,
484 .setToggleBackgroundColorWithColorSpace = SetToggleBackgroundColorWithColorSpace,
485 .resetToggleBackgroundColor = ResetToggleBackgroundColor,
486 .setToggleHoverEffect = SetToggleHoverEffect,
487 .resetToggleHoverEffect = ResetToggleHoverEffect,
488 .getToggleSelectedColor = GetToggleSelectedColor,
489 .getToggleSwitchPointColor = GetToggleSwitchPointColor,
490 .setToggleIsOn = SetToggleIsOn,
491 .resetToggleIsOn = ResetToggleIsOn,
492 .getToggleIsOn = GetToggleIsOn,
493 .setTogglePointRadius = SetTogglePointRadius,
494 .resetTogglePointRadius = ResetTogglePointRadius,
495 .setToggleUnselectedColor = SetToggleUnselectedColor,
496 .resetToggleUnselectedColor = ResetToggleUnselectedColor,
497 .setToggleTrackBorderRadius = SetToggleTrackBorderRadius,
498 .resetToggleTrackBorderRadius = ResetToggleTrackBorderRadius,
499 .getToggleUnselectedColor = GetToggleUnselectedColor,
500 .setToggleState = SetToggleState,
501 .setToggleOnChange = SetToggleOnChange,
502 .resetToggleOnChange = ResetToggleOnChange,
503 .setToggleSelectedColorPtr = SetToggleSelectedColorPtr,
504 .setToggleSwitchPointColorPtr = SetToggleSwitchPointColorPtr,
505 .setTogglePointRadiusPtr = SetTogglePointRadiusPtr,
506 .setToggleUnselectedColorPtr = SetToggleUnselectedColorPtr,
507 .setToggleTrackBorderRadiusPtr = SetToggleTrackBorderRadiusPtr,
508 .setIsUserSetMargin = SetIsUserSetMargin,
509 };
510 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
511
512 return &modifier;
513 }
514
GetCJUIToggleModifier()515 const CJUIToggleModifier* GetCJUIToggleModifier()
516 {
517 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
518 static const CJUIToggleModifier modifier = {
519 .setToggleSelectedColor = SetToggleSelectedColor,
520 .resetToggleSelectedColor = ResetToggleSelectedColor,
521 .setToggleSwitchPointColor = SetToggleSwitchPointColor,
522 .resetToggleSwitchPointColor = ResetToggleSwitchPointColor,
523 .setToggleHeight = SetToggleHeight,
524 .resetToggleHeight = ResetToggleHeight,
525 .setToggleResponseRegion = SetToggleResponseRegion,
526 .resetToggleResponseRegion = ResetToggleResponseRegion,
527 .setTogglePadding = SetTogglePadding,
528 .resetTogglePadding = ResetTogglePadding,
529 .setToggleBackgroundColor = SetToggleBackgroundColor,
530 .setToggleBackgroundColorWithColorSpace = SetToggleBackgroundColorWithColorSpace,
531 .resetToggleBackgroundColor = ResetToggleBackgroundColor,
532 .setToggleHoverEffect = SetToggleHoverEffect,
533 .resetToggleHoverEffect = ResetToggleHoverEffect,
534 .getToggleSelectedColor = GetToggleSelectedColor,
535 .getToggleSwitchPointColor = GetToggleSwitchPointColor,
536 .setToggleIsOn = SetToggleIsOn,
537 .resetToggleIsOn = ResetToggleIsOn,
538 .getToggleIsOn = GetToggleIsOn,
539 .setTogglePointRadius = SetTogglePointRadius,
540 .resetTogglePointRadius = ResetTogglePointRadius,
541 .setToggleUnselectedColor = SetToggleUnselectedColor,
542 .resetToggleUnselectedColor = ResetToggleUnselectedColor,
543 .setToggleTrackBorderRadius = SetToggleTrackBorderRadius,
544 .resetToggleTrackBorderRadius = ResetToggleTrackBorderRadius,
545 .getToggleUnselectedColor = GetToggleUnselectedColor,
546 };
547 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
548
549 return &modifier;
550 }
551
SetOnToggleChange(ArkUINodeHandle node,void * extraParam)552 void SetOnToggleChange(ArkUINodeHandle node, void* extraParam)
553 {
554 auto* frameNode = reinterpret_cast<FrameNode*>(node);
555 CHECK_NULL_VOID(frameNode);
556 auto onChange = [node, extraParam](const bool isOn) {
557 ArkUINodeEvent event;
558 event.kind = COMPONENT_ASYNC_EVENT;
559 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
560 event.componentAsyncEvent.subKind = ON_TOGGLE_CHANGE;
561 event.componentAsyncEvent.data[0].u32 = isOn;
562 SendArkUISyncEvent(&event);
563 };
564 ToggleModelNG::OnChange(frameNode, std::move(onChange));
565 }
566
ResetOnToggleChange(ArkUINodeHandle node)567 void ResetOnToggleChange(ArkUINodeHandle node)
568 {
569 auto* frameNode = reinterpret_cast<FrameNode*>(node);
570 CHECK_NULL_VOID(frameNode);
571 ToggleModelNG::OnChange(frameNode, nullptr);
572 }
573 } // namespace NodeModifier
574 } // namespace OHOS::Ace::NG
575