1 /*
2 * Copyright (c) 2021 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 "frameworks/bridge/declarative_frontend/jsview/js_toggle.h"
17
18 #include <cstddef>
19 #include <string>
20 #include "interfaces/inner_api/ui_session/ui_session_manager.h"
21
22 #include "base/log/ace_scoring_log.h"
23 #include "bridge/declarative_frontend/jsview/js_view_abstract.h"
24 #include "bridge/declarative_frontend/jsview/js_button.h"
25 #include "bridge/declarative_frontend/jsview/models/toggle_model_impl.h"
26 #include "core/common/container.h"
27 #include "core/components/common/properties/color.h"
28 #include "core/components/toggle/toggle_theme.h"
29 #include "core/components_ng/base/view_stack_model.h"
30 #include "core/components_ng/base/view_stack_processor.h"
31 #include "core/components_ng/pattern/button/toggle_button_model_ng.h"
32 #include "core/components_ng/pattern/toggle/toggle_model_ng.h"
33
34 namespace OHOS::Ace {
35
36 std::unique_ptr<ToggleModel> ToggleModel::instance_ = nullptr;
37 std::mutex ToggleModel::mutex_;
38
GetInstance()39 ToggleModel* ToggleModel::GetInstance()
40 {
41 if (!instance_) {
42 std::lock_guard<std::mutex> lock(mutex_);
43 if (!instance_) {
44 #ifdef NG_BUILD
45 instance_.reset(new NG::ToggleModelNG());
46 #else
47 if (Container::IsCurrentUseNewPipeline()) {
48 instance_.reset(new NG::ToggleModelNG());
49 } else {
50 instance_.reset(new Framework::ToggleModelImpl());
51 }
52 #endif
53 }
54 }
55 return instance_.get();
56 }
57
58 } // namespace OHOS::Ace
59
60 namespace OHOS::Ace::Framework {
61 int32_t JSToggle::toggleType_ = 1;
JSBind(BindingTarget globalObj)62 void JSToggle::JSBind(BindingTarget globalObj)
63 {
64 JSClass<JSToggle>::Declare("Toggle");
65 JSClass<JSToggle>::StaticMethod("create", &JSToggle::Create);
66 JSClass<JSToggle>::StaticMethod("onChange", &JSToggle::OnChange);
67 JSClass<JSToggle>::StaticMethod("selectedColor", &JSToggle::SelectedColor);
68 JSClass<JSToggle>::StaticMethod("width", &JSToggle::JsWidth);
69 JSClass<JSToggle>::StaticMethod("height", &JSToggle::JsHeight);
70 JSClass<JSToggle>::StaticMethod("responseRegion", &JSToggle::JsResponseRegion);
71 JSClass<JSToggle>::StaticMethod("size", &JSToggle::JsSize);
72 JSClass<JSToggle>::StaticMethod("padding", &JSToggle::JsPadding);
73 JSClass<JSToggle>::StaticMethod("margin", &JSToggle::JsMargin);
74 JSClass<JSToggle>::StaticMethod("pop", &JSToggle::Pop);
75 JSClass<JSToggle>::StaticMethod("switchPointColor", &JSToggle::SwitchPointColor);
76 JSClass<JSToggle>::StaticMethod("backgroundColor", &JSToggle::SetBackgroundColor);
77 JSClass<JSToggle>::StaticMethod("hoverEffect", &JSToggle::JsHoverEffect);
78 JSClass<JSToggle>::StaticMethod("switchStyle", &JSToggle::SwitchStyle);
79 JSClass<JSToggle>::StaticMethod("onTouch", &JSInteractableView::JsOnTouch);
80 JSClass<JSToggle>::StaticMethod("onClick", &JSInteractableView::JsOnClick);
81 JSClass<JSToggle>::StaticMethod("onHover", &JSInteractableView::JsOnHover);
82 JSClass<JSToggle>::StaticMethod("onKeyEvent", &JSInteractableView::JsOnKey);
83 JSClass<JSToggle>::StaticMethod("onDeleteEvent", &JSInteractableView::JsOnDelete);
84 JSClass<JSToggle>::StaticMethod("onAttach", &JSInteractableView::JsOnAttach);
85 JSClass<JSToggle>::StaticMethod("onAppear", &JSInteractableView::JsOnAppear);
86 JSClass<JSToggle>::StaticMethod("onDetach", &JSInteractableView::JsOnDetach);
87 JSClass<JSToggle>::StaticMethod("onDisAppear", &JSInteractableView::JsOnDisAppear);
88 JSClass<JSToggle>::StaticMethod("borderRadius", &JSToggle::JsRadius);
89 JSClass<JSToggle>::StaticMethod("border", &JSToggle::JsBorder);
90 JSClass<JSToggle>::InheritAndBind<JSViewAbstract>(globalObj);
91 }
92
ParseToggleIsOnObject(const JSCallbackInfo & info,const JSRef<JSVal> & changeEventVal)93 void ParseToggleIsOnObject(const JSCallbackInfo& info, const JSRef<JSVal>& changeEventVal)
94 {
95 CHECK_NULL_VOID(changeEventVal->IsFunction());
96
97 auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(changeEventVal));
98 WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
99 auto onChangeEvent = [execCtx = info.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](
100 bool isOn) {
101 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
102 ACE_SCORING_EVENT("Toggle.onChangeEvent");
103 PipelineContext::SetCallBackNode(node);
104 auto newJSVal = JSRef<JSVal>::Make(ToJSValue(isOn));
105 func->ExecuteJS(1, &newJSVal);
106 };
107 ToggleModel::GetInstance()->OnChangeEvent(std::move(onChangeEvent));
108 }
109
Create(const JSCallbackInfo & info)110 void JSToggle::Create(const JSCallbackInfo& info)
111 {
112 if (!info[0]->IsObject()) {
113 return;
114 }
115
116 auto paramObject = JSRef<JSObject>::Cast(info[0]);
117 auto type = paramObject->GetProperty("type");
118 int32_t toggleTypeInt = 1;
119 if (type->IsNumber()) {
120 toggleTypeInt = type->ToNumber<int32_t>();
121 }
122 if (toggleTypeInt < 0 || toggleTypeInt > 2) {
123 toggleTypeInt = 1;
124 }
125 toggleType_ = toggleTypeInt;
126 auto tempIsOn = paramObject->GetProperty("isOn");
127 bool isOn = false;
128 JSRef<JSVal> changeEventVal;
129 if (tempIsOn->IsObject()) {
130 JSRef<JSObject> isOnObj = JSRef<JSObject>::Cast(tempIsOn);
131 changeEventVal = isOnObj->GetProperty("changeEvent");
132 auto isOnProperty = isOnObj->GetProperty("value");
133 isOn = isOnProperty->IsBoolean() ? isOnProperty->ToBoolean() : false;
134 } else if (paramObject->HasProperty("$isOn")) {
135 changeEventVal = paramObject->GetProperty("$isOn");
136 isOn = tempIsOn->IsBoolean() ? tempIsOn->ToBoolean() : false;
137 } else {
138 isOn = tempIsOn->IsBoolean() ? tempIsOn->ToBoolean() : false;
139 }
140 TAG_LOGD(AceLogTag::ACE_SELECT_COMPONENT, "toggle create type %{public}d isOn %{public}d", toggleTypeInt, isOn);
141 ToggleModel::GetInstance()->Create(NG::ToggleType(toggleTypeInt), isOn);
142 if (!changeEventVal->IsUndefined() && changeEventVal->IsFunction()) {
143 ParseToggleIsOnObject(info, changeEventVal);
144 }
145 }
146
JsWidth(const JSCallbackInfo & info)147 void JSToggle::JsWidth(const JSCallbackInfo& info)
148 {
149 if (info.Length() < 1) {
150 return;
151 }
152 if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
153 JSViewAbstract::JsWidth(info[0]);
154 return;
155 }
156 JsWidth(info[0]);
157 }
158
JsWidth(const JSRef<JSVal> & jsValue)159 void JSToggle::JsWidth(const JSRef<JSVal>& jsValue)
160 {
161 auto switchTheme = GetTheme<SwitchTheme>();
162 CHECK_NULL_VOID(switchTheme);
163 auto defaultWidth = switchTheme->GetWidth();
164 auto horizontalPadding = switchTheme->GetHotZoneHorizontalPadding();
165 auto width = defaultWidth - horizontalPadding * 2;
166 if (toggleType_ == 0) {
167 auto checkboxTheme = GetTheme<CheckboxTheme>();
168 CHECK_NULL_VOID(checkboxTheme);
169 defaultWidth = checkboxTheme->GetDefaultWidth();
170 horizontalPadding = checkboxTheme->GetHotZoneHorizontalPadding();
171 width = defaultWidth - horizontalPadding * 2;
172 }
173 CalcDimension value(width);
174 ParseJsDimensionVp(jsValue, value);
175 if (value.IsNegative()) {
176 value = width;
177 }
178 ToggleModel::GetInstance()->SetWidth(value);
179 }
180
JsHeight(const JSCallbackInfo & info)181 void JSToggle::JsHeight(const JSCallbackInfo& info)
182 {
183 if (info.Length() < 1) {
184 return;
185 }
186 if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
187 JSViewAbstract::JsHeight(info[0]);
188 return;
189 }
190 JsHeight(info[0]);
191 }
192
JsHeight(const JSRef<JSVal> & jsValue)193 void JSToggle::JsHeight(const JSRef<JSVal>& jsValue)
194 {
195 auto switchTheme = GetTheme<SwitchTheme>();
196 CHECK_NULL_VOID(switchTheme);
197 auto defaultHeight = switchTheme->GetHeight();
198 auto verticalPadding = switchTheme->GetHotZoneVerticalPadding();
199 auto height = defaultHeight - verticalPadding * 2;
200 CalcDimension value(height);
201 if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_TEN)) {
202 if (!ParseJsDimensionVpNG(jsValue, value) || value.IsNegative()) {
203 value = height;
204 }
205 } else {
206 ParseJsDimensionVp(jsValue, value);
207 if (value.IsNegative()) {
208 value = height;
209 }
210 }
211 ToggleModel::GetInstance()->SetHeight(value);
212 }
213
JsResponseRegion(const JSCallbackInfo & info)214 void JSToggle::JsResponseRegion(const JSCallbackInfo& info)
215 {
216 if (!Container::IsCurrentUseNewPipeline()) {
217 JSViewAbstract::JsResponseRegion(info);
218 return;
219 }
220 std::vector<DimensionRect> result;
221 if (!JSViewAbstract::ParseJsResponseRegionArray(info[0], result)) {
222 return;
223 }
224 ToggleModel::GetInstance()->SetResponseRegion(result);
225 }
226
JsSize(const JSCallbackInfo & info)227 void JSToggle::JsSize(const JSCallbackInfo& info)
228 {
229 if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
230 JSViewAbstract::JsSize(info);
231 return;
232 }
233 if (!info[0]->IsObject()) {
234 return;
235 }
236
237 JSRef<JSObject> sizeObj = JSRef<JSObject>::Cast(info[0]);
238 JsWidth(sizeObj->GetProperty("width"));
239 JsHeight(sizeObj->GetProperty("height"));
240 }
241
OnChange(const JSCallbackInfo & args)242 void JSToggle::OnChange(const JSCallbackInfo& args)
243 {
244 auto jsVal = args[0];
245 if (!jsVal->IsFunction()) {
246 return;
247 }
248 auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(jsVal));
249 WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
250 auto onChange = [execCtx = args.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](bool isOn) {
251 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
252 ACE_SCORING_EVENT("Toggle.onChange");
253 PipelineContext::SetCallBackNode(node);
254 auto newJSVal = JSRef<JSVal>::Make(ToJSValue(isOn));
255 func->ExecuteJS(1, &newJSVal);
256 UiSessionManager::GetInstance()->ReportComponentChangeEvent("event", "Toggle.onChange");
257 };
258 ToggleModel::GetInstance()->OnChange(std::move(onChange));
259 args.ReturnSelf();
260 }
261
SelectedColor(const JSCallbackInfo & info)262 void JSToggle::SelectedColor(const JSCallbackInfo& info)
263 {
264 if (info.Length() < 1) {
265 return;
266 }
267 Color color;
268 std::optional<Color> selectedColor;
269 RefPtr<ResourceObject> resObj;
270 if (ParseJsColor(info[0], color, resObj)) {
271 selectedColor = color;
272 }
273 CreateWithColorResourceObj(resObj, static_cast<int32_t>(ToggleColorType::SELECTED_COLOR));
274 ToggleModel::GetInstance()->SetSelectedColor(selectedColor);
275 }
276
SwitchPointColor(const JSCallbackInfo & info)277 void JSToggle::SwitchPointColor(const JSCallbackInfo& info)
278 {
279 if (info.Length() < 1) {
280 return;
281 }
282 Color color;
283 RefPtr<ResourceObject> resObj;
284 std::optional<Color> switchPointColor;
285 if (ParseJsColor(info[0], color, resObj)) {
286 switchPointColor = color;
287 ToggleModel::GetInstance()->SetSwitchPointColorSetByUser(true);
288 }
289 CreateWithColorResourceObj(resObj, static_cast<int32_t>(ToggleColorType::SWITCH_POINT_COLOR));
290 ToggleModel::GetInstance()->SetSwitchPointColor(switchPointColor);
291 }
292
JsPadding(const JSCallbackInfo & info)293 void JSToggle::JsPadding(const JSCallbackInfo& info)
294 {
295 if (info.Length() < 1) {
296 return;
297 }
298 NG::PaddingPropertyF oldPadding = GetOldPadding(info);
299 NG::PaddingProperty newPadding = GetNewPadding(info);
300 ToggleModel::GetInstance()->SetPadding(oldPadding, newPadding);
301 }
302
JsMargin(const JSCallbackInfo & info)303 void JSToggle::JsMargin(const JSCallbackInfo& info)
304 {
305 ToggleModel::GetInstance()->SetIsUserSetMargin(true);
306 JSViewAbstract::JsMargin(info);
307 }
308
GetOldPadding(const JSCallbackInfo & info)309 NG::PaddingPropertyF JSToggle::GetOldPadding(const JSCallbackInfo& info)
310 {
311 NG::PaddingPropertyF padding({ 0.0f, 0.0f, 0.0f, 0.0f });
312 if (info[0]->IsObject()) {
313 JSRef<JSObject> jsObj = JSRef<JSObject>::Cast(info[0]);
314 if (jsObj->HasProperty("top") || jsObj->HasProperty("bottom")
315 || jsObj->HasProperty("left") || jsObj->HasProperty("right")) {
316 CalcDimension topDimen = CalcDimension(0.0, DimensionUnit::VP);
317 CalcDimension leftDimen = CalcDimension(0.0, DimensionUnit::VP);
318 CalcDimension rightDimen = CalcDimension(0.0, DimensionUnit::VP);
319 CalcDimension bottomDimen = CalcDimension(0.0, DimensionUnit::VP);
320 ParseJsDimensionVp(jsObj->GetProperty("top"), topDimen);
321 ParseJsDimensionVp(jsObj->GetProperty("left"), leftDimen);
322 ParseJsDimensionVp(jsObj->GetProperty("right"), rightDimen);
323 ParseJsDimensionVp(jsObj->GetProperty("bottom"), bottomDimen);
324 if (leftDimen == 0.0_vp) {
325 leftDimen = rightDimen;
326 }
327 if (topDimen == 0.0_vp) {
328 topDimen = bottomDimen;
329 }
330 if (leftDimen == 0.0_vp) {
331 leftDimen = topDimen;
332 }
333
334 padding.left = leftDimen.ConvertToPx();
335 padding.right = rightDimen.ConvertToPx();
336 padding.top = topDimen.ConvertToPx();
337 padding.bottom = bottomDimen.ConvertToPx();
338 return padding;
339 }
340 }
341
342 CalcDimension length;
343 if (!ParseJsDimensionVp(info[0], length)) {
344 return padding;
345 }
346
347 padding.left = length.ConvertToPx();
348 padding.right = length.ConvertToPx();
349 padding.top = length.ConvertToPx();
350 padding.bottom = length.ConvertToPx();
351 return padding;
352 }
353
GetNewPadding(const JSCallbackInfo & info)354 NG::PaddingProperty JSToggle::GetNewPadding(const JSCallbackInfo& info)
355 {
356 NG::PaddingProperty padding({ NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp),
357 NG::CalcLength(0.0_vp), std::nullopt, std::nullopt });
358 if (info[0]->IsObject()) {
359 JSRef<JSObject> paddingObj = JSRef<JSObject>::Cast(info[0]);
360 CommonCalcDimension commonCalcDimension;
361 ParseCommonMarginOrPaddingCorner(paddingObj, commonCalcDimension);
362 if (commonCalcDimension.left.has_value() || commonCalcDimension.right.has_value() ||
363 commonCalcDimension.top.has_value() || commonCalcDimension.bottom.has_value()) {
364 padding = GetPadding(commonCalcDimension.top, commonCalcDimension.bottom, commonCalcDimension.left,
365 commonCalcDimension.right);
366 return padding;
367 }
368 }
369 CalcDimension length;
370 if (!ParseJsDimensionVp(info[0], length)) {
371 length.Reset();
372 }
373
374 padding.SetEdges(NG::CalcLength(length.IsNonNegative() ? length : CalcDimension()));
375 return padding;
376 }
377
GetPadding(const std::optional<CalcDimension> & top,const std::optional<CalcDimension> & bottom,const std::optional<CalcDimension> & left,const std::optional<CalcDimension> & right)378 NG::PaddingProperty JSToggle::GetPadding(const std::optional<CalcDimension>& top,
379 const std::optional<CalcDimension>& bottom, const std::optional<CalcDimension>& left,
380 const std::optional<CalcDimension>& right)
381 {
382 NG::PaddingProperty padding({ NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp), NG::CalcLength(0.0_vp),
383 NG::CalcLength(0.0_vp), std::nullopt, std::nullopt });
384 if (left.has_value() && left.value().IsNonNegative()) {
385 padding.left = NG::CalcLength(left.value());
386 }
387 if (right.has_value() && right.value().IsNonNegative()) {
388 padding.right = NG::CalcLength(right.value());
389 }
390 if (top.has_value() && top.value().IsNonNegative()) {
391 padding.top = NG::CalcLength(top.value());
392 }
393 if (bottom.has_value() && bottom.value().IsNonNegative()) {
394 padding.bottom = NG::CalcLength(bottom.value());
395 }
396 return padding;
397 }
398
SetBackgroundColor(const JSCallbackInfo & info)399 void JSToggle::SetBackgroundColor(const JSCallbackInfo& info)
400 {
401 Color backgroundColor = Color::TRANSPARENT;
402 RefPtr<ResourceObject> resObj;
403 bool flag = ParseJsColor(info[0], backgroundColor, resObj);
404 if (!Container::IsCurrentUseNewPipeline()) {
405 JSViewAbstract::JsBackgroundColor(info);
406 return;
407 }
408 ToggleModel::GetInstance()->SetBackgroundColor(backgroundColor, flag);
409 CreateWithColorResourceObj(resObj, static_cast<int32_t>(ToggleColorType::BACKGROUND_COLOR));
410 }
411
JsHoverEffect(const JSCallbackInfo & info)412 void JSToggle::JsHoverEffect(const JSCallbackInfo& info)
413 {
414 if (info.Length() > 0 && info[0]->IsNumber()) {
415 ToggleModel::GetInstance()->SetHoverEffect(static_cast<HoverEffectType>(info[0]->ToNumber<int32_t>()));
416 }
417 }
418
Pop()419 void JSToggle::Pop()
420 {
421 if (ViewStackModel::GetInstance()->IsPrebuilding()) {
422 return ViewStackModel::GetInstance()->PushPrebuildCompCmd("[JSToggle][pop]", &JSToggle::Pop);
423 }
424 ToggleModel::GetInstance()->Pop();
425 }
426
SwitchStyle(const JSCallbackInfo & info)427 void JSToggle::SwitchStyle(const JSCallbackInfo& info)
428 {
429 if ((info.Length() < 1) || !info[0]->IsObject()) {
430 return;
431 }
432 JSRef<JSObject> jsObj = JSRef<JSObject>::Cast(info[0]);
433 SetPointRadius(jsObj);
434 SetUnselectedColor(jsObj);
435 SetPointColor(jsObj);
436 SetTrackBorderRadius(jsObj);
437 }
438
SetPointRadius(const JSRef<JSObject> & jsObj)439 void JSToggle::SetPointRadius(const JSRef<JSObject>& jsObj)
440 {
441 CalcDimension pointRadius;
442 RefPtr<ResourceObject> pointRadiusResObj;
443 if (jsObj->HasProperty("pointRadius") &&
444 ParseJsDimensionVpNG(jsObj->GetProperty("pointRadius"), pointRadius, pointRadiusResObj, false) &&
445 !pointRadius.IsNegative()) {
446 ToggleModel::GetInstance()->SetPointRadius(pointRadius);
447 } else {
448 ToggleModel::GetInstance()->ResetPointRadius();
449 }
450 CreateWithDimensionResourceObj(pointRadiusResObj, static_cast<int32_t>(ToggleDimensionType::POINT_RADIUS));
451 }
452
SetUnselectedColor(const JSRef<JSObject> & jsObj)453 void JSToggle::SetUnselectedColor(const JSRef<JSObject>& jsObj)
454 {
455 Color unselectedColor;
456 RefPtr<ResourceObject> unselectedColorResObj;
457 if (jsObj->HasProperty("unselectedColor") &&
458 ParseJsColor(jsObj->GetProperty("unselectedColor"), unselectedColor, unselectedColorResObj)) {
459 ToggleModel::GetInstance()->SetUnselectedColor(unselectedColor);
460 ToggleModel::GetInstance()->SetUnselectedColorSetByUser(true);
461 } else {
462 auto theme = GetTheme<SwitchTheme>();
463 if (theme) {
464 unselectedColor = theme->GetInactiveColor();
465 }
466 ToggleModel::GetInstance()->SetUnselectedColor(unselectedColor);
467 ToggleModel::GetInstance()->SetUnselectedColorSetByUser(false);
468 }
469 CreateWithColorResourceObj(unselectedColorResObj, static_cast<int32_t>(ToggleColorType::UN_SELECTED_COLOR));
470 }
471
SetPointColor(const JSRef<JSObject> & jsObj)472 void JSToggle::SetPointColor(const JSRef<JSObject>& jsObj)
473 {
474 Color pointColor;
475 RefPtr<ResourceObject> pointColorResObj;
476 if (jsObj->HasProperty("pointColor") && ParseJsColor(jsObj->GetProperty("pointColor"),
477 pointColor, pointColorResObj)) {
478 ToggleModel::GetInstance()->SetSwitchPointColor(pointColor);
479 ToggleModel::GetInstance()->SetSwitchPointColorSetByUser(true);
480 } else {
481 auto theme = GetTheme<SwitchTheme>();
482 if (theme) {
483 pointColor = theme->GetPointColor();
484 }
485 ToggleModel::GetInstance()->SetSwitchPointColor(pointColor);
486 ToggleModel::GetInstance()->SetSwitchPointColorSetByUser(false);
487 }
488 CreateWithColorResourceObj(pointColorResObj, static_cast<int32_t>(ToggleColorType::SWITCH_POINT_COLOR));
489 }
490
SetTrackBorderRadius(const JSRef<JSObject> & jsObj)491 void JSToggle::SetTrackBorderRadius(const JSRef<JSObject>& jsObj)
492 {
493 CalcDimension trackRadius;
494 RefPtr<ResourceObject> trackBorderRadiusResObj;
495 if (jsObj->HasProperty("trackBorderRadius") &&
496 ParseJsDimensionVpNG(jsObj->GetProperty("trackBorderRadius"), trackRadius, trackBorderRadiusResObj, false) &&
497 !trackRadius.IsNegative()) {
498 ToggleModel::GetInstance()->SetTrackBorderRadius(trackRadius);
499 } else {
500 ToggleModel::GetInstance()->ResetTrackBorderRadius();
501 }
502 CreateWithDimensionResourceObj(trackBorderRadiusResObj,
503 static_cast<int32_t>(ToggleDimensionType::TRACK_BORDER_RADIUS));
504 }
505
CreateWithDimensionResourceObj(RefPtr<ResourceObject> & resObj,const int32_t resType)506 void JSToggle::CreateWithDimensionResourceObj(RefPtr<ResourceObject>& resObj, const int32_t resType)
507 {
508 if (SystemProperties::ConfigChangePerform()) {
509 ToggleModel::GetInstance()->CreateWithDimensionVpResourceObj(resObj, static_cast<ToggleDimensionType>(resType));
510 }
511 }
512
CreateWithColorResourceObj(RefPtr<ResourceObject> & resObj,const int32_t resType)513 void JSToggle::CreateWithColorResourceObj(RefPtr<ResourceObject>& resObj, const int32_t resType)
514 {
515 if (SystemProperties::ConfigChangePerform()) {
516 ToggleModel::GetInstance()->CreateWithColorResourceObj(resObj, static_cast<ToggleColorType>(resType));
517 }
518 }
519
JsRadius(const JSCallbackInfo & info)520 void JSToggle::JsRadius(const JSCallbackInfo& info)
521 {
522 CalcDimension radius;
523 // when toggle equels button should follow button model.
524 if (static_cast<NG::ToggleType>(toggleType_) == NG::ToggleType::BUTTON) {
525 JSButton::JsRadius(info);
526 } else {
527 JSViewAbstract::JsBorderRadius(info);
528 }
529 }
530
JsBorder(const JSCallbackInfo & info)531 void JSToggle::JsBorder(const JSCallbackInfo& info)
532 {
533 JSViewAbstract::JsBorder(info);
534 if (!info[0]->IsObject()) {
535 return;
536 }
537 if (static_cast<NG::ToggleType>(toggleType_) == NG::ToggleType::BUTTON) {
538 JSRef<JSObject> object = JSRef<JSObject>::Cast(info[0]);
539 auto valueRadius = object->GetProperty("radius");
540 JSButton::JsRadius(valueRadius);
541 }
542 }
543 } // namespace OHOS::Ace::Framework
544