1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_checkbox_bridge.h"
16 #include "bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h"
17 #include "core/components_ng/base/frame_node.h"
18 #include "core/components_ng/pattern/checkbox/checkbox_model_ng.h"
19 
20 namespace OHOS::Ace::NG {
21 constexpr float CHECK_BOX_MARK_SIZE_INVALID_VALUE = -1.0f;
22 const bool DEFAULT_SELECTED = false;
23 const char* CHECKBOX_NODEPTR_OF_UINODE = "nodePtr_";
JsCheckboxChangeCallback(panda::JsiRuntimeCallInfo * runtimeCallInfo)24 panda::Local<panda::JSValueRef> JsCheckboxChangeCallback(panda::JsiRuntimeCallInfo* runtimeCallInfo)
25 {
26     auto vm = runtimeCallInfo->GetVM();
27     int32_t argc = static_cast<int32_t>(runtimeCallInfo->GetArgsNumber());
28     if (argc != 1) {
29         return panda::JSValueRef::Undefined(vm);
30     }
31     auto firstArg = runtimeCallInfo->GetCallArgRef(0);
32     if (!firstArg->IsBoolean()) {
33         return panda::JSValueRef::Undefined(vm);
34     }
35     bool value = firstArg->ToBoolean(vm)->Value();
36     auto ref = runtimeCallInfo->GetThisRef();
37     auto obj = ref->ToObject(vm);
38     if (obj->GetNativePointerFieldCount(vm) < 1) {
39         return panda::JSValueRef::Undefined(vm);
40     }
41     auto frameNode = static_cast<FrameNode*>(obj->GetNativePointerField(vm, 0));
42     CHECK_NULL_RETURN(frameNode, panda::JSValueRef::Undefined(vm));
43     CheckBoxModelNG::SetChangeValue(frameNode, value);
44     return panda::JSValueRef::Undefined(vm);
45 }
46 
SetMark(ArkUIRuntimeCallInfo * runtimeCallInfo)47 ArkUINativeModuleValue CheckboxBridge::SetMark(ArkUIRuntimeCallInfo* runtimeCallInfo)
48 {
49     EcmaVM* vm = runtimeCallInfo->GetVM();
50     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
51     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
52     Local<JSValueRef> colorArg = runtimeCallInfo->GetCallArgRef(1); // mark color
53     Local<JSValueRef> sizeArg = runtimeCallInfo->GetCallArgRef(2);  // mark stroke size
54     Local<JSValueRef> widthArg = runtimeCallInfo->GetCallArgRef(3); // mark stroke width
55     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
56 
57     auto theme = ArkTSUtils::GetTheme<CheckboxTheme>();
58     Color strokeColor;
59     if (!ArkTSUtils::ParseJsColorAlpha(vm, colorArg, strokeColor)) {
60         strokeColor = theme->GetPointColor();
61     }
62 
63     CalcDimension size;
64     if (!(ArkTSUtils::ParseJsDimensionVp(vm, sizeArg, size, false)) || (size.Unit() == DimensionUnit::PERCENT) ||
65         (size.ConvertToVp() < 0)) {
66         size = Dimension(CHECK_BOX_MARK_SIZE_INVALID_VALUE);
67     }
68 
69     CalcDimension strokeWidth;
70     if (!(ArkTSUtils::ParseJsDimensionVp(vm, widthArg, strokeWidth, false)) ||
71         (strokeWidth.Unit() == DimensionUnit::PERCENT) || (strokeWidth.ConvertToVp() < 0)) {
72         strokeWidth = theme->GetCheckStroke();
73     }
74 
75     GetArkUINodeModifiers()->getCheckboxModifier()->setMark(nativeNode, strokeColor.GetValue(), size.Value(),
76         static_cast<int>(size.Unit()), strokeWidth.Value(), static_cast<int>(strokeWidth.Unit()));
77     return panda::JSValueRef::Undefined(vm);
78 }
79 
SetSelect(ArkUIRuntimeCallInfo * runtimeCallInfo)80 ArkUINativeModuleValue CheckboxBridge::SetSelect(ArkUIRuntimeCallInfo* runtimeCallInfo)
81 {
82     EcmaVM* vm = runtimeCallInfo->GetVM();
83     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
84     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
85     Local<JSValueRef> selectedArg = runtimeCallInfo->GetCallArgRef(1);
86     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
87     bool select = DEFAULT_SELECTED;
88     if (selectedArg->IsBoolean()) {
89         select = selectedArg->ToBoolean(vm)->Value();
90     }
91     GetArkUINodeModifiers()->getCheckboxModifier()->setSelect(nativeNode, select);
92     return panda::JSValueRef::Undefined(vm);
93 }
94 
SetSelectedColor(ArkUIRuntimeCallInfo * runtimeCallInfo)95 ArkUINativeModuleValue CheckboxBridge::SetSelectedColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
96 {
97     EcmaVM* vm = runtimeCallInfo->GetVM();
98     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
99     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
100     Local<JSValueRef> colorArg = runtimeCallInfo->GetCallArgRef(1);
101     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
102 
103     Color selectedColor;
104     if (!ArkTSUtils::ParseJsColorAlpha(vm, colorArg, selectedColor)) {
105         GetArkUINodeModifiers()->getCheckboxModifier()->resetSelectedColor(nativeNode);
106         return panda::JSValueRef::Undefined(vm);
107     }
108 
109     GetArkUINodeModifiers()->getCheckboxModifier()->setSelectedColor(nativeNode, selectedColor.GetValue());
110     return panda::JSValueRef::Undefined(vm);
111 }
112 
SetUnSelectedColor(ArkUIRuntimeCallInfo * runtimeCallInfo)113 ArkUINativeModuleValue CheckboxBridge::SetUnSelectedColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
114 {
115     EcmaVM* vm = runtimeCallInfo->GetVM();
116     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
117     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
118     Local<JSValueRef> colorArg = runtimeCallInfo->GetCallArgRef(1);
119     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
120 
121     Color unSelectedColor;
122     if (!ArkTSUtils::ParseJsColorAlpha(vm, colorArg, unSelectedColor)) {
123         GetArkUINodeModifiers()->getCheckboxModifier()->resetUnSelectedColor(nativeNode);
124         return panda::JSValueRef::Undefined(vm);
125     }
126 
127     GetArkUINodeModifiers()->getCheckboxModifier()->setUnSelectedColor(nativeNode, unSelectedColor.GetValue());
128     return panda::JSValueRef::Undefined(vm);
129 }
130 
SetCheckboxWidth(ArkUIRuntimeCallInfo * runtimeCallInfo)131 ArkUINativeModuleValue CheckboxBridge::SetCheckboxWidth(ArkUIRuntimeCallInfo* runtimeCallInfo)
132 {
133     EcmaVM* vm = runtimeCallInfo->GetVM();
134     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
135     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
136     Local<JSValueRef> jsValue = runtimeCallInfo->GetCallArgRef(1);
137     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
138 
139     CalcDimension width;
140     if (!ArkTSUtils::ParseJsDimensionVp(vm, jsValue, width)) {
141         GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxWidth(nativeNode);
142         return panda::JSValueRef::Undefined(vm);
143     }
144 
145     GetArkUINodeModifiers()->getCheckboxModifier()->setCheckboxWidth(
146         nativeNode, width.Value(), static_cast<int>(width.Unit()));
147     return panda::JSValueRef::Undefined(vm);
148 }
149 
SetCheckboxHeight(ArkUIRuntimeCallInfo * runtimeCallInfo)150 ArkUINativeModuleValue CheckboxBridge::SetCheckboxHeight(ArkUIRuntimeCallInfo* runtimeCallInfo)
151 {
152     EcmaVM* vm = runtimeCallInfo->GetVM();
153     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
154     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
155     Local<JSValueRef> jsValue = runtimeCallInfo->GetCallArgRef(1);
156     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
157 
158     CalcDimension height;
159     if (!ArkTSUtils::ParseJsDimensionVp(vm, jsValue, height)) {
160         GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxHeight(nativeNode);
161         return panda::JSValueRef::Undefined(vm);
162     }
163     GetArkUINodeModifiers()->getCheckboxModifier()->setCheckboxHeight(
164         nativeNode, height.Value(), static_cast<int>(height.Unit()));
165     return panda::JSValueRef::Undefined(vm);
166 }
167 
ResetMark(ArkUIRuntimeCallInfo * runtimeCallInfo)168 ArkUINativeModuleValue CheckboxBridge::ResetMark(ArkUIRuntimeCallInfo* runtimeCallInfo)
169 {
170     EcmaVM* vm = runtimeCallInfo->GetVM();
171     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
172     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
173     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
174     GetArkUINodeModifiers()->getCheckboxModifier()->resetMark(nativeNode);
175     return panda::JSValueRef::Undefined(vm);
176 }
177 
ResetSelect(ArkUIRuntimeCallInfo * runtimeCallInfo)178 ArkUINativeModuleValue CheckboxBridge::ResetSelect(ArkUIRuntimeCallInfo* runtimeCallInfo)
179 {
180     EcmaVM* vm = runtimeCallInfo->GetVM();
181     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
182     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
183     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
184     GetArkUINodeModifiers()->getCheckboxModifier()->setSelect(nativeNode, DEFAULT_SELECTED);
185     return panda::JSValueRef::Undefined(vm);
186 }
187 
ResetSelectedColor(ArkUIRuntimeCallInfo * runtimeCallInfo)188 ArkUINativeModuleValue CheckboxBridge::ResetSelectedColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
189 {
190     EcmaVM* vm = runtimeCallInfo->GetVM();
191     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
192     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
193     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
194     GetArkUINodeModifiers()->getCheckboxModifier()->resetSelectedColor(nativeNode);
195     return panda::JSValueRef::Undefined(vm);
196 }
197 
ResetUnSelectedColor(ArkUIRuntimeCallInfo * runtimeCallInfo)198 ArkUINativeModuleValue CheckboxBridge::ResetUnSelectedColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
199 {
200     EcmaVM* vm = runtimeCallInfo->GetVM();
201     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
202     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
203     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
204     GetArkUINodeModifiers()->getCheckboxModifier()->resetUnSelectedColor(nativeNode);
205     return panda::JSValueRef::Undefined(vm);
206 }
207 
ResetCheckboxWidth(ArkUIRuntimeCallInfo * runtimeCallInfo)208 ArkUINativeModuleValue CheckboxBridge::ResetCheckboxWidth(ArkUIRuntimeCallInfo* runtimeCallInfo)
209 {
210     EcmaVM* vm = runtimeCallInfo->GetVM();
211     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
212     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
213     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
214     GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxWidth(nativeNode);
215     return panda::JSValueRef::Undefined(vm);
216 }
217 
ResetCheckboxHeight(ArkUIRuntimeCallInfo * runtimeCallInfo)218 ArkUINativeModuleValue CheckboxBridge::ResetCheckboxHeight(ArkUIRuntimeCallInfo* runtimeCallInfo)
219 {
220     EcmaVM* vm = runtimeCallInfo->GetVM();
221     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
222     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
223     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
224     GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxHeight(nativeNode);
225     return panda::JSValueRef::Undefined(vm);
226 }
227 
SetCheckboxPadding(ArkUIRuntimeCallInfo * runtimeCallInfo)228 ArkUINativeModuleValue CheckboxBridge::SetCheckboxPadding(ArkUIRuntimeCallInfo* runtimeCallInfo)
229 {
230     EcmaVM* vm = runtimeCallInfo->GetVM();
231     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
232     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
233     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
234     Local<JSValueRef> top = runtimeCallInfo->GetCallArgRef(1);    // 1: top data
235     Local<JSValueRef> right = runtimeCallInfo->GetCallArgRef(2);  // 2: right data
236     Local<JSValueRef> bottom = runtimeCallInfo->GetCallArgRef(3); // 3: bottom data
237     Local<JSValueRef> left = runtimeCallInfo->GetCallArgRef(4);   // 4: left data
238     CalcDimension topDim(0, DimensionUnit::VP);
239     CalcDimension rightDim(0, DimensionUnit::VP);
240     CalcDimension bottomDim(0, DimensionUnit::VP);
241     CalcDimension leftDim(0, DimensionUnit::VP);
242     ArkTSUtils::ParseJsDimensionVp(vm, top, topDim);
243     ArkTSUtils::ParseJsDimensionVp(vm, right, rightDim);
244     ArkTSUtils::ParseJsDimensionVp(vm, bottom, bottomDim);
245     ArkTSUtils::ParseJsDimensionVp(vm, left, leftDim);
246     const uint32_t arraySize = 4; // 4 : data length
247     ArkUI_Float32 values[arraySize];
248     int units[arraySize];
249     values[0] = topDim.IsNonNegative() ? topDim.Value() : 0;
250     units[0] = static_cast<int>(topDim.Unit());
251     values[1] = rightDim.IsNonNegative() ? rightDim.Value() : 0;
252     units[1] = static_cast<int>(rightDim.Unit());
253     values[2] = bottomDim.IsNonNegative() ? bottomDim.Value() : 0; // 2: bottom data
254     units[2] = static_cast<int>(bottomDim.Unit());                 // 2: bottom Unit
255     values[3] = leftDim.IsNonNegative() ? leftDim.Value() : 0;     // 3: left data
256     units[3] = static_cast<int>(leftDim.Unit());                   // 3: left Unit
257     GetArkUINodeModifiers()->getCheckboxModifier()->setCheckboxPadding(nativeNode, values, units, arraySize);
258     return panda::JSValueRef::Undefined(vm);
259 }
260 
ResetCheckboxPadding(ArkUIRuntimeCallInfo * runtimeCallInfo)261 ArkUINativeModuleValue CheckboxBridge::ResetCheckboxPadding(ArkUIRuntimeCallInfo* runtimeCallInfo)
262 {
263     EcmaVM* vm = runtimeCallInfo->GetVM();
264     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
265     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
266     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
267     GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxPadding(nativeNode);
268     return panda::JSValueRef::Undefined(vm);
269 }
270 
SetCheckboxResponseRegion(ArkUIRuntimeCallInfo * runtimeCallInfo)271 ArkUINativeModuleValue CheckboxBridge::SetCheckboxResponseRegion(ArkUIRuntimeCallInfo* runtimeCallInfo)
272 {
273     EcmaVM* vm = runtimeCallInfo->GetVM();
274     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
275     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
276     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
277     Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(1);
278     Local<JSValueRef> lengthArg = runtimeCallInfo->GetCallArgRef(2); // 2: array length
279     uint32_t length = lengthArg->Uint32Value(vm);
280     ArkUI_Float32 regionArray[length];
281     int32_t regionUnits[length];
282     if (!ArkTSUtils::ParseResponseRegion(vm, secondArg, regionArray, regionUnits, length)) {
283         GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxResponseRegion(nativeNode);
284         return panda::JSValueRef::Undefined(vm);
285     }
286     GetArkUINodeModifiers()->getCheckboxModifier()->setCheckboxResponseRegion(
287         nativeNode, regionArray, regionUnits, length);
288     return panda::JSValueRef::Undefined(vm);
289 }
290 
ResetCheckboxResponseRegion(ArkUIRuntimeCallInfo * runtimeCallInfo)291 ArkUINativeModuleValue CheckboxBridge::ResetCheckboxResponseRegion(ArkUIRuntimeCallInfo* runtimeCallInfo)
292 {
293     EcmaVM* vm = runtimeCallInfo->GetVM();
294     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
295     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
296     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
297     GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxResponseRegion(nativeNode);
298     return panda::JSValueRef::Undefined(vm);
299 }
300 
SetCheckboxSize(ArkUIRuntimeCallInfo * runtimeCallInfo)301 ArkUINativeModuleValue CheckboxBridge::SetCheckboxSize(ArkUIRuntimeCallInfo* runtimeCallInfo)
302 {
303     EcmaVM* vm = runtimeCallInfo->GetVM();
304     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
305     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
306     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
307     Local<JSValueRef> widthArg = runtimeCallInfo->GetCallArgRef(1); // 1: width value
308     Local<JSValueRef> heightAry = runtimeCallInfo->GetCallArgRef(2); // 2: height value
309     CalcDimension width;
310     ArkTSUtils::ParseJsDimensionVp(vm, widthArg, width, false);
311     if (widthArg->IsUndefined() || width.IsNegative()) {
312         GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxWidth(nativeNode);
313     } else {
314         GetArkUINodeModifiers()->getCheckboxModifier()->setCheckboxWidth(
315             nativeNode, width.Value(), static_cast<int>(width.Unit()));
316     }
317     CalcDimension height;
318     ArkTSUtils::ParseJsDimensionVp(vm, heightAry, height, false);
319     if (heightAry->IsUndefined() || height.IsNegative()) {
320         GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxHeight(nativeNode);
321     } else {
322         GetArkUINodeModifiers()->getCheckboxModifier()->setCheckboxHeight(
323             nativeNode, height.Value(), static_cast<int>(height.Unit()));
324     }
325     return panda::JSValueRef::Undefined(vm);
326 }
327 
SetContentModifierBuilder(ArkUIRuntimeCallInfo * runtimeCallInfo)328 ArkUINativeModuleValue CheckboxBridge::SetContentModifierBuilder(ArkUIRuntimeCallInfo* runtimeCallInfo)
329 {
330     EcmaVM* vm = runtimeCallInfo->GetVM();
331     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
332     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
333     Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(1);
334     auto* frameNode = reinterpret_cast<FrameNode*>(firstArg->ToNativePointer(vm)->Value());
335     if (!secondArg->IsObject(vm)) {
336         CheckBoxModelNG::SetBuilderFunc(frameNode, nullptr);
337         return panda::JSValueRef::Undefined(vm);
338     }
339     panda::CopyableGlobal<panda::ObjectRef> obj(vm, secondArg);
340     CheckBoxModelNG::SetBuilderFunc(frameNode,
341         [vm, frameNode, obj = std::move(obj), containerId = Container::CurrentId()](
342             CheckBoxConfiguration config) -> RefPtr<FrameNode> {
343             ContainerScope scope(containerId);
344             auto context = ArkTSUtils::GetContext(vm);
345             CHECK_EQUAL_RETURN(context->IsUndefined(), true, nullptr);
346             const char* keysOfCheckbox[] = { "name", "selected", "enabled", "triggerChange"};
347             Local<JSValueRef> valuesOfCheckbox[] = { panda::StringRef::NewFromUtf8(vm, config.name_.c_str()),
348                 panda::BooleanRef::New(vm, config.selected_), panda::BooleanRef::New(vm, config.enabled_),
349                 panda::FunctionRef::New(vm, JsCheckboxChangeCallback)};
350             auto checkbox = panda::ObjectRef::NewWithNamedProperties(vm,
351                 ArraySize(keysOfCheckbox), keysOfCheckbox, valuesOfCheckbox);
352             checkbox->SetNativePointerFieldCount(vm, 1);
353             checkbox->SetNativePointerField(vm, 0, static_cast<void*>(frameNode));
354             panda::Local<panda::JSValueRef> params[2] = { context, checkbox };
355             LocalScope pandaScope(vm);
356             panda::TryCatch trycatch(vm);
357             auto jsObject = obj.ToLocal();
358             auto makeFunc = jsObject->Get(vm, panda::StringRef::NewFromUtf8(vm, "makeContentModifierNode"));
359             CHECK_EQUAL_RETURN(makeFunc->IsFunction(vm), false, nullptr);
360             panda::Local<panda::FunctionRef> func = makeFunc;
361             auto result = func->Call(vm, jsObject, params, 2);
362             JSNApi::ExecutePendingJob(vm);
363             CHECK_EQUAL_RETURN(result.IsEmpty() || trycatch.HasCaught() || !result->IsObject(vm), true, nullptr);
364             auto resultObj = result->ToObject(vm);
365             panda::Local<panda::JSValueRef> nodeptr =
366                 resultObj->Get(vm, panda::StringRef::NewFromUtf8(vm, CHECKBOX_NODEPTR_OF_UINODE));
367             CHECK_EQUAL_RETURN(nodeptr.IsEmpty() || nodeptr->IsUndefined() || nodeptr->IsNull(), true, nullptr);
368             auto* frameNode = reinterpret_cast<FrameNode*>(nodeptr->ToNativePointer(vm)->Value());
369             CHECK_NULL_RETURN(frameNode, nullptr);
370             return AceType::Claim(frameNode);
371         });
372     return panda::JSValueRef::Undefined(vm);
373 }
374 
ResetCheckboxSize(ArkUIRuntimeCallInfo * runtimeCallInfo)375 ArkUINativeModuleValue CheckboxBridge::ResetCheckboxSize(ArkUIRuntimeCallInfo* runtimeCallInfo)
376 {
377     EcmaVM* vm = runtimeCallInfo->GetVM();
378     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
379     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
380     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
381     CHECK_NULL_RETURN(nativeNode, panda::NativePointerRef::New(vm, nullptr));
382     return panda::JSValueRef::Undefined(vm);
383 }
384 
SetCheckboxShape(ArkUIRuntimeCallInfo * runtimeCallInfo)385 ArkUINativeModuleValue CheckboxBridge::SetCheckboxShape(ArkUIRuntimeCallInfo* runtimeCallInfo)
386 {
387     EcmaVM* vm = runtimeCallInfo->GetVM();
388     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
389     Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
390     Local<JSValueRef> styleArg = runtimeCallInfo->GetCallArgRef(1);
391     auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
392     if (styleArg->IsNull() || styleArg->IsUndefined()) {
393         GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxShape(nativeNode);
394     } else {
395         int32_t style = styleArg->Int32Value(vm);
396         GetArkUINodeModifiers()->getCheckboxModifier()->setCheckboxShape(nativeNode, style);
397     }
398 
399     return panda::JSValueRef::Undefined(vm);
400 }
401 
ResetCheckboxShape(ArkUIRuntimeCallInfo * runtimeCallInfo)402 ArkUINativeModuleValue CheckboxBridge::ResetCheckboxShape(ArkUIRuntimeCallInfo* runtimeCallInfo)
403 {
404     EcmaVM* vm = runtimeCallInfo->GetVM();
405     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
406     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
407     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
408 
409     GetArkUINodeModifiers()->getCheckboxModifier()->resetCheckboxShape(nativeNode);
410     return panda::JSValueRef::Undefined(vm);
411 }
412 } // namespace OHOS::Ace::NG
413