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 
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include "bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_render_node_bridge.h"
17 
18 #include <cstdint>
19 
20 #include "canvas_napi/js_canvas.h"
21 #include "jsnapi_expo.h"
22 
23 #include "base/geometry/dimension.h"
24 #include "base/geometry/ng/rect_t.h"
25 #include "base/geometry/shape.h"
26 #include "bridge/common/utils/engine_helper.h"
27 #include "bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_api_bridge.h"
28 #include "bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_utils_bridge.h"
29 #include "bridge/declarative_frontend/jsview/js_utils.h"
30 #include "core/components/common/layout/constants.h"
31 #include "core/components_ng/pattern/render_node/render_node_properties.h"
32 #include "core/pipeline/pipeline_base.h"
33 #include "core/components_ng/base/frame_node.h"
34 #include "core/components_ng/pattern/render_node/render_node_pattern.h"
35 
36 namespace OHOS::Ace::NG {
37 namespace {
38 const uint32_t DEFAULT_COLOR = 0xFF000000;
39 
SetRectShape(ArkUIRuntimeCallInfo * runtimeCallInfo,bool isClip)40 ArkUINativeModuleValue SetRectShape(ArkUIRuntimeCallInfo* runtimeCallInfo, bool isClip)
41 {
42     EcmaVM* vm = runtimeCallInfo->GetVM();
43     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
44     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
45 
46     auto leftValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 1, 0.0f);
47     auto topValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 2, 0.0f);
48     auto rightValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 3, 0.0f);
49     auto bottomValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 4, 0.0f);
50     if (isClip) {
51         GetArkUINodeModifiers()->getRenderNodeModifier()->setRectClip(
52             nativeNode, leftValue, topValue, rightValue - leftValue, bottomValue - topValue);
53         return panda::JSValueRef::Undefined(vm);
54     }
55     auto fillColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 5, DEFAULT_COLOR);
56     auto strokeColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 6, DEFAULT_COLOR);
57     auto strokeWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 7, 0.0f);
58 
59     GetArkUINodeModifiers()->getRenderNodeModifier()->setRectMask(nativeNode, leftValue, topValue,
60         rightValue - leftValue, bottomValue - topValue, fillColorValue, strokeColorValue, strokeWidthValue);
61     return panda::JSValueRef::Undefined(vm);
62 }
63 
SetCircleShape(ArkUIRuntimeCallInfo * runtimeCallInfo,bool isClip)64 ArkUINativeModuleValue SetCircleShape(ArkUIRuntimeCallInfo* runtimeCallInfo, bool isClip)
65 {
66     EcmaVM* vm = runtimeCallInfo->GetVM();
67     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
68     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
69 
70     auto centerXValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 1, 0.0f);
71     auto centerYValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 2, 0.0f);
72     auto radiusValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 3, 0.0f);
73     if (isClip) {
74         GetArkUINodeModifiers()->getRenderNodeModifier()->setCircleClip(
75             nativeNode, centerXValue, centerYValue, radiusValue);
76         return panda::JSValueRef::Undefined(vm);
77     }
78     auto fillColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 4, DEFAULT_COLOR);
79     auto strokeColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 5, DEFAULT_COLOR);
80     auto strokeWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 6, 0.0f);
81 
82     GetArkUINodeModifiers()->getRenderNodeModifier()->setCircleMask(
83         nativeNode, centerXValue, centerYValue, radiusValue, fillColorValue, strokeColorValue, strokeWidthValue);
84     return panda::JSValueRef::Undefined(vm);
85 }
86 
SetRoundRectShape(ArkUIRuntimeCallInfo * runtimeCallInfo,bool isClip)87 ArkUINativeModuleValue SetRoundRectShape(ArkUIRuntimeCallInfo* runtimeCallInfo, bool isClip)
88 {
89     EcmaVM* vm = runtimeCallInfo->GetVM();
90     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
91     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
92 
93     auto topLeftXValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 1, 0.0f);
94     auto topLeftYValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 2, 0.0f);
95 
96     auto topRightXValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 3, 0.0f);
97     auto topRightYValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 4, 0.0f);
98 
99     auto bottomLeftXValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 5, 0.0f);
100     auto bottomLeftYValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 6, 0.0f);
101 
102     auto bottomRightXValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 7, 0.0f);
103     auto bottomRightYValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 8, 0.0f);
104 
105     auto leftValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 9, 0.0f);
106     auto topValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 10, 0.0f);
107     auto rightValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 11, 0.0f);
108     auto bottomValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 12, 0.0f);
109 
110     ArkUI_Float32 roundRect[] = { topLeftXValue, topLeftYValue, topRightXValue, topRightYValue, bottomLeftXValue,
111         bottomLeftYValue, bottomRightXValue, bottomRightYValue, leftValue, topValue, rightValue - leftValue,
112         bottomValue - topValue };
113 
114     if (isClip) {
115         GetArkUINodeModifiers()->getRenderNodeModifier()->setRoundRectClip(nativeNode, roundRect, sizeof(roundRect));
116         return panda::JSValueRef::Undefined(vm);
117     }
118 
119     auto fillColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 13, DEFAULT_COLOR);
120     auto strokeColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 14, DEFAULT_COLOR);
121     auto strokeWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 15, 0.0f);
122 
123     GetArkUINodeModifiers()->getRenderNodeModifier()->setRoundRectMask(
124         nativeNode, roundRect, sizeof(roundRect), fillColorValue, strokeColorValue, strokeWidthValue);
125     return panda::JSValueRef::Undefined(vm);
126 }
127 
SetOvalShape(ArkUIRuntimeCallInfo * runtimeCallInfo,bool isClip)128 ArkUINativeModuleValue SetOvalShape(ArkUIRuntimeCallInfo* runtimeCallInfo, bool isClip)
129 {
130     EcmaVM* vm = runtimeCallInfo->GetVM();
131     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
132     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
133 
134     auto leftValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 1, 0.0f);
135     auto topValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 2, 0.0f);
136     auto rightValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 3, 0.0f);
137     auto bottomValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 4, 0.0f);
138     if (isClip) {
139         GetArkUINodeModifiers()->getRenderNodeModifier()->setOvalClip(
140             nativeNode, leftValue, topValue, rightValue - leftValue, bottomValue - topValue);
141         return panda::JSValueRef::Undefined(vm);
142     }
143     auto fillColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 5, DEFAULT_COLOR);
144     auto strokeColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 6, DEFAULT_COLOR);
145     auto strokeWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 7, 0.0f);
146 
147     GetArkUINodeModifiers()->getRenderNodeModifier()->setOvalMask(nativeNode, leftValue, topValue,
148         rightValue - leftValue, bottomValue - topValue, fillColorValue, strokeColorValue, strokeWidthValue);
149     return panda::JSValueRef::Undefined(vm);
150 }
151 
SetCommandPathShape(ArkUIRuntimeCallInfo * runtimeCallInfo,bool isClip)152 ArkUINativeModuleValue SetCommandPathShape(ArkUIRuntimeCallInfo* runtimeCallInfo, bool isClip)
153 {
154     EcmaVM* vm = runtimeCallInfo->GetVM();
155     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
156     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
157 
158     Local<JSValueRef> path = runtimeCallInfo->GetCallArgRef(1);
159     std::string pathValue;
160     if (path->IsString(vm)) {
161         pathValue = path->ToString(vm)->ToString(vm);
162     }
163 
164     if (isClip) {
165         GetArkUINodeModifiers()->getRenderNodeModifier()->setCommandPathClip(nativeNode, pathValue.c_str());
166         return panda::JSValueRef::Undefined(vm);
167     }
168     auto fillColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 2, DEFAULT_COLOR);
169     auto strokeColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 3, DEFAULT_COLOR);
170     auto strokeWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 4, 0.0f);
171 
172     GetArkUINodeModifiers()->getRenderNodeModifier()->setCommandPathMask(
173         nativeNode, pathValue.c_str(), fillColorValue, strokeColorValue, strokeWidthValue);
174     return panda::JSValueRef::Undefined(vm);
175 }
176 } // namespace
177 
CreateRenderNode(ArkUIRuntimeCallInfo * runtimeCallInfo)178 ArkUINativeModuleValue RenderNodeBridge::CreateRenderNode(ArkUIRuntimeCallInfo* runtimeCallInfo)
179 {
180     EcmaVM* vm = runtimeCallInfo->GetVM();
181     auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
182     auto frameNode = NG::FrameNode::GetOrCreateFrameNode(
183         V2::RENDER_NODE_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<NG::RenderNodePattern>(); });
184     RenderNodeBridge::SetOnDraw(frameNode, runtimeCallInfo);
185     return NativeUtilsBridge::CreateStrongRef(vm, frameNode);
186 }
187 
FireDrawCallback(EcmaVM * vm,JsWeak<panda::CopyableGlobal<panda::ObjectRef>> object,NG::DrawingContext & context,Local<panda::StringRef> funcName)188 void RenderNodeBridge::FireDrawCallback(EcmaVM* vm, JsWeak<panda::CopyableGlobal<panda::ObjectRef>> object,
189     NG::DrawingContext& context, Local<panda::StringRef> funcName)
190 {
191     auto obj = object.Lock();
192     CHECK_NULL_VOID(!obj.IsEmpty());
193     CHECK_NULL_VOID(obj->IsObject(vm));
194     auto funcObj = obj->Get(vm, funcName);
195     CHECK_NULL_VOID(funcObj->IsFunction(vm));
196     panda::Local<panda::FunctionRef> func = funcObj;
197     auto engine = EngineHelper::GetCurrentEngine();
198     CHECK_NULL_VOID(engine);
199     NativeEngine* nativeEngine = engine->GetNativeEngine();
200     napi_env env = reinterpret_cast<napi_env>(nativeEngine);
201     Framework::ScopeRAII scope(env);
202 
203     const char* keysOfSize[] = { "height", "width" };
204     Local<JSValueRef> valuesOfSize[] = {
205         panda::NumberRef::New(vm, static_cast<double>(PipelineBase::Px2VpWithCurrentDensity(context.height))),
206         panda::NumberRef::New(vm, static_cast<double>(PipelineBase::Px2VpWithCurrentDensity(context.width)))
207     };
208     auto sizeObj = panda::ObjectRef::NewWithNamedProperties(vm, ArraySize(keysOfSize), keysOfSize, valuesOfSize);
209 
210     Local<JSValueRef> valuesOfSizeInPixel[] = {
211         panda::NumberRef::New(vm, static_cast<double>(context.height)),
212         panda::NumberRef::New(vm, static_cast<double>(context.width))
213     };
214     auto sizeInPixelObj =
215         panda::ObjectRef::NewWithNamedProperties(vm, ArraySize(keysOfSize), keysOfSize, valuesOfSizeInPixel);
216 
217     auto jsCanvas = OHOS::Rosen::Drawing::JsCanvas::CreateJsCanvas(env, &context.canvas);
218     OHOS::Rosen::Drawing::JsCanvas* unwrapCanvas = nullptr;
219     napi_unwrap(env, jsCanvas, reinterpret_cast<void**>(&unwrapCanvas));
220     if (unwrapCanvas) {
221         unwrapCanvas->SaveCanvas();
222         unwrapCanvas->ClipCanvas(context.width, context.height);
223     }
224 
225     auto jsCanvasVal = NapiValueToLocalValue(jsCanvas);
226     Local<JSValueRef> values[] = { sizeObj, sizeInPixelObj, jsCanvasVal };
227     const char* keys[] = { "size", "sizeInPixel", "canvas" };
228     auto contextObj = panda::ObjectRef::NewWithNamedProperties(vm, ArraySize(keys), keys, values);
229     contextObj->SetNativePointerFieldCount(vm, 1);
230     JSValueWrapper valueWrapper = contextObj;
231     napi_value nativeValue = nativeEngine->ValueToNapiValue(valueWrapper);
232     napi_wrap(
233         env, nativeValue, &context.canvas, [](napi_env, void*, void*) {}, nullptr, nullptr);
234     panda::Local<panda::JSValueRef> params[1] = { contextObj };
235     func->Call(vm, obj.ToLocal(), params, 1);
236     if (unwrapCanvas) {
237         unwrapCanvas->RestoreCanvas();
238         unwrapCanvas->ResetCanvas();
239     }
240 }
241 
SetOnDraw(const RefPtr<FrameNode> & frameNode,ArkUIRuntimeCallInfo * runtimeCallInfo)242 void RenderNodeBridge::SetOnDraw(const RefPtr<FrameNode>& frameNode, ArkUIRuntimeCallInfo* runtimeCallInfo)
243 {
244     EcmaVM* vm = runtimeCallInfo->GetVM();
245     CHECK_NULL_VOID(vm);
246     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
247     CHECK_NULL_VOID(firstArg->IsObject(vm));
248     auto obj = Local<panda::ObjectRef>(firstArg);
249     auto funcName = panda::StringRef::NewFromUtf8(vm, "draw");
250     auto funcObj = obj->Get(vm, funcName);
251     CHECK_NULL_VOID(funcObj->IsFunction(vm));
252     auto drawCallback = [vm, object = JsWeak(panda::CopyableGlobal(vm, obj))](NG::DrawingContext& context) {
253         panda::LocalScope pandaScope(vm);
254         panda::TryCatch trycatch(vm);
255         auto funcName = panda::StringRef::NewFromUtf8(vm, "draw");
256         RenderNodeBridge::FireDrawCallback(vm, object, context, funcName);
257     };
258     auto pattern = frameNode->GetPattern<NG::RenderNodePattern>();
259     pattern->SetDrawCallback(std::move(drawCallback));
260 }
261 
AppendChild(ArkUIRuntimeCallInfo * runtimeCallInfo)262 ArkUINativeModuleValue RenderNodeBridge::AppendChild(ArkUIRuntimeCallInfo* runtimeCallInfo)
263 {
264     EcmaVM* vm = runtimeCallInfo->GetVM();
265     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
266     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
267     Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(1);
268     auto childNativeNode = nodePtr(secondArg->ToNativePointer(vm)->Value());
269     GetArkUINodeModifiers()->getRenderNodeModifier()->appendChild(nativeNode, childNativeNode);
270     return panda::JSValueRef::Undefined(vm);
271 }
272 
InsertChildAfter(ArkUIRuntimeCallInfo * runtimeCallInfo)273 ArkUINativeModuleValue RenderNodeBridge::InsertChildAfter(ArkUIRuntimeCallInfo* runtimeCallInfo)
274 {
275     EcmaVM* vm = runtimeCallInfo->GetVM();
276     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
277     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
278     Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(1);
279     auto child = nodePtr(secondArg->ToNativePointer(vm)->Value());
280     Local<JSValueRef> thirdArg = runtimeCallInfo->GetCallArgRef(2);
281     if (thirdArg.IsNull()) {
282         GetArkUINodeModifiers()->getRenderNodeModifier()->insertChildAfter(nativeNode, child, nullptr);
283         return panda::JSValueRef::Undefined(vm);
284     }
285     auto sibling = nodePtr(thirdArg->ToNativePointer(vm)->Value());
286     GetArkUINodeModifiers()->getRenderNodeModifier()->insertChildAfter(nativeNode, child, sibling);
287     return panda::JSValueRef::Undefined(vm);
288 }
289 
RemoveChild(ArkUIRuntimeCallInfo * runtimeCallInfo)290 ArkUINativeModuleValue RenderNodeBridge::RemoveChild(ArkUIRuntimeCallInfo* runtimeCallInfo)
291 {
292     EcmaVM* vm = runtimeCallInfo->GetVM();
293     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
294     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
295     Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(1);
296     auto childNativeNode = nodePtr(secondArg->ToNativePointer(vm)->Value());
297     GetArkUINodeModifiers()->getRenderNodeModifier()->removeChild(nativeNode, childNativeNode);
298     return panda::JSValueRef::Undefined(vm);
299 }
300 
ClearChildren(ArkUIRuntimeCallInfo * runtimeCallInfo)301 ArkUINativeModuleValue RenderNodeBridge::ClearChildren(ArkUIRuntimeCallInfo* runtimeCallInfo)
302 {
303     EcmaVM* vm = runtimeCallInfo->GetVM();
304     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
305     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
306     GetArkUINodeModifiers()->getRenderNodeModifier()->clearChildren(nativeNode);
307     return panda::JSValueRef::Undefined(vm);
308 }
309 
SetClipToFrame(ArkUIRuntimeCallInfo * runtimeCallInfo)310 ArkUINativeModuleValue RenderNodeBridge::SetClipToFrame(ArkUIRuntimeCallInfo* runtimeCallInfo)
311 {
312     EcmaVM* vm = runtimeCallInfo->GetVM();
313     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
314     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
315     Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(1);
316     bool useClip = false;
317     if (secondArg->IsBoolean()) {
318         useClip = secondArg->ToBoolean(vm)->Value();
319     }
320     GetArkUINodeModifiers()->getRenderNodeModifier()->setClipToFrame(nativeNode, useClip);
321     return panda::JSValueRef::Undefined(vm);
322 }
323 
SetRotation(ArkUIRuntimeCallInfo * runtimeCallInfo)324 ArkUINativeModuleValue RenderNodeBridge::SetRotation(ArkUIRuntimeCallInfo* runtimeCallInfo)
325 {
326     EcmaVM* vm = runtimeCallInfo->GetVM();
327     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
328     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
329     Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(1);
330     Local<JSValueRef> thirdArg = runtimeCallInfo->GetCallArgRef(2);
331     Local<JSValueRef> fourthArg = runtimeCallInfo->GetCallArgRef(3);
332     Local<JSValueRef> fifthArg = runtimeCallInfo->GetCallArgRef(4);
333     double rotationX = 0.0;
334     double rotationY = 0.0;
335     double rotationZ = 0.0;
336     int32_t unit = 0;
337     if (secondArg->IsNumber()) {
338         rotationX = secondArg->ToNumber(vm)->Value();
339     }
340     if (thirdArg->IsNumber()) {
341         rotationY = thirdArg->ToNumber(vm)->Value();
342     }
343     if (fourthArg->IsNumber()) {
344         rotationZ = fourthArg->ToNumber(vm)->Value();
345     }
346     if (fifthArg->IsNumber()) {
347         unit = fifthArg->Int32Value(vm);
348     }
349     GetArkUINodeModifiers()->getRenderNodeModifier()->setRotation(nativeNode, rotationX, rotationY, rotationZ, unit);
350     return panda::JSValueRef::Undefined(vm);
351 }
352 
SetShadowColor(ArkUIRuntimeCallInfo * runtimeCallInfo)353 ArkUINativeModuleValue RenderNodeBridge::SetShadowColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
354 {
355     EcmaVM* vm = runtimeCallInfo->GetVM();
356     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
357     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
358     Local<JSValueRef> color = runtimeCallInfo->GetCallArgRef(1);
359     uint32_t colorValue = 0;
360     if (color->IsNumber()) {
361         colorValue = color->Uint32Value(vm);
362     }
363     GetArkUINodeModifiers()->getRenderNodeModifier()->setShadowColor(nativeNode, colorValue);
364     return panda::JSValueRef::Undefined(vm);
365 }
366 
SetShadowOffset(ArkUIRuntimeCallInfo * runtimeCallInfo)367 ArkUINativeModuleValue RenderNodeBridge::SetShadowOffset(ArkUIRuntimeCallInfo* runtimeCallInfo)
368 {
369     EcmaVM* vm = runtimeCallInfo->GetVM();
370     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
371     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
372     Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(1);
373     Local<JSValueRef> thirdArg = runtimeCallInfo->GetCallArgRef(2);
374     Local<JSValueRef> fourthArg = runtimeCallInfo->GetCallArgRef(3);
375     double offsetX = 0.0;
376     double offsetY = 0.0;
377     int32_t unit = 0;
378     if (secondArg->IsNumber()) {
379         offsetX = secondArg->ToNumber(vm)->Value();
380     }
381     if (thirdArg->IsNumber()) {
382         offsetY = thirdArg->ToNumber(vm)->Value();
383     }
384     if (fourthArg->IsNumber()) {
385         unit = fourthArg->Int32Value(vm);
386     }
387     GetArkUINodeModifiers()->getRenderNodeModifier()->setShadowOffset(nativeNode, offsetX, offsetY, unit);
388     return panda::JSValueRef::Undefined(vm);
389 }
SetLabel(ArkUIRuntimeCallInfo * runtimeCallInfo)390 ArkUINativeModuleValue RenderNodeBridge::SetLabel(ArkUIRuntimeCallInfo* runtimeCallInfo)
391 {
392     EcmaVM* vm = runtimeCallInfo->GetVM();
393     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
394     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
395     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
396     Local<JSValueRef> label = runtimeCallInfo->GetCallArgRef(1);
397     std::string labelValue;
398     if (label->IsString(vm)) {
399         labelValue = label->ToString(vm)->ToString(vm);
400     } else {
401         labelValue = "";
402         LOGW("The label of the node should be a string!");
403     }
404     GetArkUINodeModifiers()->getRenderNodeModifier()->setLabel(nativeNode, labelValue.c_str());
405     return panda::JSValueRef::Undefined(vm);
406 }
SetShadowAlpha(ArkUIRuntimeCallInfo * runtimeCallInfo)407 ArkUINativeModuleValue RenderNodeBridge::SetShadowAlpha(ArkUIRuntimeCallInfo* runtimeCallInfo)
408 {
409     EcmaVM* vm = runtimeCallInfo->GetVM();
410     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
411     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
412     Local<JSValueRef> alpha = runtimeCallInfo->GetCallArgRef(1);
413     float alphaValue = 1.0;
414     if (alpha->IsNumber()) {
415         alphaValue = alpha->ToNumber(vm)->Value();
416     }
417     GetArkUINodeModifiers()->getRenderNodeModifier()->setShadowAlpha(nativeNode, alphaValue);
418     return panda::JSValueRef::Undefined(vm);
419 }
SetShadowElevation(ArkUIRuntimeCallInfo * runtimeCallInfo)420 ArkUINativeModuleValue RenderNodeBridge::SetShadowElevation(ArkUIRuntimeCallInfo* runtimeCallInfo)
421 {
422     EcmaVM* vm = runtimeCallInfo->GetVM();
423     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
424     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
425     Local<JSValueRef> elevation = runtimeCallInfo->GetCallArgRef(1);
426     float elevationValue = 0;
427     if (elevation->IsNumber()) {
428         elevationValue = elevation->ToNumber(vm)->Value();
429     }
430     GetArkUINodeModifiers()->getRenderNodeModifier()->setShadowElevation(nativeNode, elevationValue);
431     return panda::JSValueRef::Undefined(vm);
432 }
SetShadowRadius(ArkUIRuntimeCallInfo * runtimeCallInfo)433 ArkUINativeModuleValue RenderNodeBridge::SetShadowRadius(ArkUIRuntimeCallInfo* runtimeCallInfo)
434 {
435     EcmaVM* vm = runtimeCallInfo->GetVM();
436     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
437     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
438     Local<JSValueRef> radius = runtimeCallInfo->GetCallArgRef(1);
439     float radiusValue = 0;
440     if (radius->IsNumber()) {
441         radiusValue = radius->ToNumber(vm)->Value();
442     }
443 
444     GetArkUINodeModifiers()->getRenderNodeModifier()->setShadowRadius(nativeNode, radiusValue);
445     return panda::JSValueRef::Undefined(vm);
446 }
447 
SetScale(ArkUIRuntimeCallInfo * runtimeCallInfo)448 ArkUINativeModuleValue RenderNodeBridge::SetScale(ArkUIRuntimeCallInfo* runtimeCallInfo)
449 {
450     EcmaVM* vm = runtimeCallInfo->GetVM();
451     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
452     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
453 
454     Local<JSValueRef> scaleX = runtimeCallInfo->GetCallArgRef(1);
455     float scaleXValue = 0;
456     if (scaleX->IsNumber()) {
457         scaleXValue = scaleX->ToNumber(vm)->Value();
458     }
459 
460     Local<JSValueRef> scaleY = runtimeCallInfo->GetCallArgRef(2);
461     float scaleYValue = 0;
462     if (scaleY->IsNumber()) {
463         scaleYValue = scaleY->ToNumber(vm)->Value();
464     }
465 
466     GetArkUINodeModifiers()->getRenderNodeModifier()->setScale(nativeNode, scaleXValue, scaleYValue);
467     return panda::JSValueRef::Undefined(vm);
468 }
469 
SetBackgroundColor(ArkUIRuntimeCallInfo * runtimeCallInfo)470 ArkUINativeModuleValue RenderNodeBridge::SetBackgroundColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
471 {
472     EcmaVM* vm = runtimeCallInfo->GetVM();
473     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
474     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
475     Local<JSValueRef> color = runtimeCallInfo->GetCallArgRef(1);
476     uint32_t colorValue = 0;
477     if (color->IsNumber()) {
478         colorValue = color->Uint32Value(vm);
479     }
480 
481     GetArkUINodeModifiers()->getRenderNodeModifier()->setRenderNodeBackgroundColor(nativeNode, colorValue);
482     return panda::JSValueRef::Undefined(vm);
483 }
484 
SetPivot(ArkUIRuntimeCallInfo * runtimeCallInfo)485 ArkUINativeModuleValue RenderNodeBridge::SetPivot(ArkUIRuntimeCallInfo* runtimeCallInfo)
486 {
487     EcmaVM* vm = runtimeCallInfo->GetVM();
488     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
489     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
490 
491     Local<JSValueRef> pivotX = runtimeCallInfo->GetCallArgRef(1);
492     float pivotXValue = 0;
493     if (pivotX->IsNumber()) {
494         pivotXValue = pivotX->ToNumber(vm)->Value();
495     }
496 
497     Local<JSValueRef> pivotY = runtimeCallInfo->GetCallArgRef(2);
498     float pivotYValue = 0;
499     if (pivotY->IsNumber()) {
500         pivotYValue = pivotY->ToNumber(vm)->Value();
501     }
502 
503     GetArkUINodeModifiers()->getRenderNodeModifier()->setPivot(nativeNode, pivotXValue, pivotYValue);
504     return panda::JSValueRef::Undefined(vm);
505 }
506 
SetFrame(ArkUIRuntimeCallInfo * runtimeCallInfo)507 ArkUINativeModuleValue RenderNodeBridge::SetFrame(ArkUIRuntimeCallInfo* runtimeCallInfo)
508 {
509     EcmaVM* vm = runtimeCallInfo->GetVM();
510     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
511     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
512 
513     Local<JSValueRef> positionX = runtimeCallInfo->GetCallArgRef(1);
514     float positionXValue = 0;
515     if (positionX->IsNumber()) {
516         positionXValue = positionX->ToNumber(vm)->Value();
517     }
518 
519     Local<JSValueRef> positionY = runtimeCallInfo->GetCallArgRef(2);
520     float positionYValue = 0;
521     if (positionY->IsNumber()) {
522         positionYValue = positionY->ToNumber(vm)->Value();
523     }
524 
525     Local<JSValueRef> width = runtimeCallInfo->GetCallArgRef(3);
526     float widthValue = 0;
527     if (width->IsNumber()) {
528         widthValue = width->ToNumber(vm)->Value();
529     }
530 
531     Local<JSValueRef> height = runtimeCallInfo->GetCallArgRef(4);
532     float heightValue = 0;
533     if (height->IsNumber()) {
534         heightValue = height->ToNumber(vm)->Value();
535     }
536 
537     GetArkUINodeModifiers()->getRenderNodeModifier()->setFrame(
538         nativeNode, positionXValue, positionYValue, widthValue, heightValue);
539     return panda::JSValueRef::Undefined(vm);
540 }
541 
SetSize(ArkUIRuntimeCallInfo * runtimeCallInfo)542 ArkUINativeModuleValue RenderNodeBridge::SetSize(ArkUIRuntimeCallInfo* runtimeCallInfo)
543 {
544     EcmaVM* vm = runtimeCallInfo->GetVM();
545     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
546     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
547 
548     Local<JSValueRef> width = runtimeCallInfo->GetCallArgRef(1);
549     float widthValue = 0;
550     if (width->IsNumber()) {
551         widthValue = width->ToNumber(vm)->Value();
552     }
553 
554     Local<JSValueRef> height = runtimeCallInfo->GetCallArgRef(2);
555     float heightValue = 0;
556     if (height->IsNumber()) {
557         heightValue = height->ToNumber(vm)->Value();
558     }
559 
560     Local<JSValueRef> unit = runtimeCallInfo->GetCallArgRef(3);
561     int32_t unitValue = 0;
562     if (unit->IsNumber()) {
563         unitValue = unit->Int32Value(vm);
564     }
565 
566     GetArkUINodeModifiers()->getRenderNodeModifier()->setSize(nativeNode, widthValue, heightValue, unitValue);
567     return panda::JSValueRef::Undefined(vm);
568 }
569 
SetPosition(ArkUIRuntimeCallInfo * runtimeCallInfo)570 ArkUINativeModuleValue RenderNodeBridge::SetPosition(ArkUIRuntimeCallInfo* runtimeCallInfo)
571 {
572     EcmaVM* vm = runtimeCallInfo->GetVM();
573     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
574     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
575 
576     Local<JSValueRef> xAxis = runtimeCallInfo->GetCallArgRef(1);
577     float xAxisValue = 0;
578     if (xAxis->IsNumber()) {
579         xAxisValue = xAxis->ToNumber(vm)->Value();
580     }
581 
582     Local<JSValueRef> yAxis = runtimeCallInfo->GetCallArgRef(2);
583     float yAxisValue = 0;
584     if (yAxis->IsNumber()) {
585         yAxisValue = yAxis->ToNumber(vm)->Value();
586     }
587 
588     Local<JSValueRef> unit = runtimeCallInfo->GetCallArgRef(3);
589     int32_t unitValue = 0;
590     if (unit->IsNumber()) {
591         unitValue = unit->Int32Value(vm);
592     }
593 
594     GetArkUINodeModifiers()->getRenderNodeModifier()->setPosition(nativeNode, xAxisValue, yAxisValue, unitValue);
595     return panda::JSValueRef::Undefined(vm);
596 }
597 
SetOpacity(ArkUIRuntimeCallInfo * runtimeCallInfo)598 ArkUINativeModuleValue RenderNodeBridge::SetOpacity(ArkUIRuntimeCallInfo* runtimeCallInfo)
599 {
600     EcmaVM* vm = runtimeCallInfo->GetVM();
601     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
602     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
603     Local<JSValueRef> opacity = runtimeCallInfo->GetCallArgRef(1);
604     float opacityValue = 0;
605     if (opacity->IsNumber()) {
606         opacityValue = opacity->ToNumber(vm)->Value();
607     }
608 
609     GetArkUINodeModifiers()->getRenderNodeModifier()->setOpacity(nativeNode, opacityValue);
610     return panda::JSValueRef::Undefined(vm);
611 }
612 
SetTranslate(ArkUIRuntimeCallInfo * runtimeCallInfo)613 ArkUINativeModuleValue RenderNodeBridge::SetTranslate(ArkUIRuntimeCallInfo* runtimeCallInfo)
614 {
615     EcmaVM* vm = runtimeCallInfo->GetVM();
616     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
617     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
618 
619     Local<JSValueRef> translateX = runtimeCallInfo->GetCallArgRef(1);
620     float translateXValue = 0;
621     if (translateX->IsNumber()) {
622         translateXValue = translateX->ToNumber(vm)->Value();
623     }
624 
625     Local<JSValueRef> translateY = runtimeCallInfo->GetCallArgRef(2);
626     float translateYValue = 0;
627     if (translateY->IsNumber()) {
628         translateYValue = translateY->ToNumber(vm)->Value();
629     }
630 
631     GetArkUINodeModifiers()->getRenderNodeModifier()->setTranslate(nativeNode, translateXValue, translateYValue, 0);
632     return panda::JSValueRef::Undefined(vm);
633 }
634 
SetBorderStyle(ArkUIRuntimeCallInfo * runtimeCallInfo)635 ArkUINativeModuleValue RenderNodeBridge::SetBorderStyle(ArkUIRuntimeCallInfo* runtimeCallInfo)
636 {
637     EcmaVM* vm = runtimeCallInfo->GetVM();
638     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
639     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
640 
641     auto leftStyle = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 1, 0);
642     auto leftStyleValue = static_cast<BorderStyle>(leftStyle);
643 
644     auto topStyle = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 2, 0);
645     auto topStyleValue = static_cast<BorderStyle>(topStyle);
646 
647     auto rightStyle = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 3, 0);
648     auto rightStyleValue = static_cast<BorderStyle>(rightStyle);
649 
650     auto bottomStyle = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 4, 0);
651     auto bottomStyleValue = static_cast<BorderStyle>(bottomStyle);
652 
653     GetArkUINodeModifiers()->getRenderNodeModifier()->setBorderStyle(nativeNode,
654         static_cast<ArkUI_Int32>(leftStyleValue), static_cast<ArkUI_Int32>(topStyleValue),
655         static_cast<ArkUI_Int32>(rightStyleValue), static_cast<ArkUI_Int32>(bottomStyleValue));
656     return panda::JSValueRef::Undefined(vm);
657 }
658 
SetBorderWidth(ArkUIRuntimeCallInfo * runtimeCallInfo)659 ArkUINativeModuleValue RenderNodeBridge::SetBorderWidth(ArkUIRuntimeCallInfo* runtimeCallInfo)
660 {
661     EcmaVM* vm = runtimeCallInfo->GetVM();
662     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
663     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
664 
665     auto leftWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 1, 0.0f);
666     auto topWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 2, 0.0f);
667     auto rightWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 3, 0.0f);
668     auto bottomWidthValue = RenderNodeBridge::GetNumber<float>(vm, runtimeCallInfo, 4, 0.0f);
669     auto unitValue = RenderNodeBridge::GetNumber<int32_t>(vm, runtimeCallInfo, 5, 0);
670 
671     GetArkUINodeModifiers()->getRenderNodeModifier()->setBorderWidth(
672         nativeNode, leftWidthValue, topWidthValue, rightWidthValue, bottomWidthValue, unitValue);
673     return panda::JSValueRef::Undefined(vm);
674 }
675 
SetBorderColor(ArkUIRuntimeCallInfo * runtimeCallInfo)676 ArkUINativeModuleValue RenderNodeBridge::SetBorderColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
677 {
678     EcmaVM* vm = runtimeCallInfo->GetVM();
679     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
680     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
681 
682     auto leftColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 1, DEFAULT_COLOR);
683     auto topColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 2, DEFAULT_COLOR);
684     auto rightColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 3, DEFAULT_COLOR);
685     auto bottomColorValue = RenderNodeBridge::GetNumber<uint32_t>(vm, runtimeCallInfo, 4, DEFAULT_COLOR);
686 
687     GetArkUINodeModifiers()->getRenderNodeModifier()->setBorderColor(
688         nativeNode, leftColorValue, topColorValue, rightColorValue, bottomColorValue);
689     return panda::JSValueRef::Undefined(vm);
690 }
691 
SetBorderRadius(ArkUIRuntimeCallInfo * runtimeCallInfo)692 ArkUINativeModuleValue RenderNodeBridge::SetBorderRadius(ArkUIRuntimeCallInfo* runtimeCallInfo)
693 {
694     EcmaVM* vm = runtimeCallInfo->GetVM();
695     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
696     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
697 
698     auto topLeftRadiusValue = RenderNodeBridge::GetNumber<double>(vm, runtimeCallInfo, 1, 0.0);
699     auto topRightRadiusValue = RenderNodeBridge::GetNumber<double>(vm, runtimeCallInfo, 2, 0.0);
700     auto bottomLeftRadiusValue = RenderNodeBridge::GetNumber<double>(vm, runtimeCallInfo, 3, 0.0);
701     auto bottomRightRadiusValue = RenderNodeBridge::GetNumber<double>(vm, runtimeCallInfo, 4, 0.0);
702     auto unitValue = RenderNodeBridge::GetNumber<int32_t>(vm, runtimeCallInfo, 5, 0);
703 
704     GetArkUINodeModifiers()->getRenderNodeModifier()->setBorderRadius(
705         nativeNode, topLeftRadiusValue, topRightRadiusValue, bottomLeftRadiusValue, bottomRightRadiusValue, unitValue);
706     return panda::JSValueRef::Undefined(vm);
707 }
708 
SetRectMask(ArkUIRuntimeCallInfo * runtimeCallInfo)709 ArkUINativeModuleValue RenderNodeBridge::SetRectMask(ArkUIRuntimeCallInfo* runtimeCallInfo)
710 {
711     return SetRectShape(runtimeCallInfo, false);
712 }
713 
SetCircleMask(ArkUIRuntimeCallInfo * runtimeCallInfo)714 ArkUINativeModuleValue RenderNodeBridge::SetCircleMask(ArkUIRuntimeCallInfo* runtimeCallInfo)
715 {
716     return SetCircleShape(runtimeCallInfo, false);
717 }
718 
SetRoundRectMask(ArkUIRuntimeCallInfo * runtimeCallInfo)719 ArkUINativeModuleValue RenderNodeBridge::SetRoundRectMask(ArkUIRuntimeCallInfo* runtimeCallInfo)
720 {
721     return SetRoundRectShape(runtimeCallInfo, false);
722 }
723 
SetOvalMask(ArkUIRuntimeCallInfo * runtimeCallInfo)724 ArkUINativeModuleValue RenderNodeBridge::SetOvalMask(ArkUIRuntimeCallInfo* runtimeCallInfo)
725 {
726     return SetOvalShape(runtimeCallInfo, false);
727 }
728 
SetCommandPathMask(ArkUIRuntimeCallInfo * runtimeCallInfo)729 ArkUINativeModuleValue RenderNodeBridge::SetCommandPathMask(ArkUIRuntimeCallInfo* runtimeCallInfo)
730 {
731     return SetCommandPathShape(runtimeCallInfo, false);
732 }
733 
SetRectClip(ArkUIRuntimeCallInfo * runtimeCallInfo)734 ArkUINativeModuleValue RenderNodeBridge::SetRectClip(ArkUIRuntimeCallInfo* runtimeCallInfo)
735 {
736     return SetRectShape(runtimeCallInfo, true);
737 }
738 
SetCircleClip(ArkUIRuntimeCallInfo * runtimeCallInfo)739 ArkUINativeModuleValue RenderNodeBridge::SetCircleClip(ArkUIRuntimeCallInfo* runtimeCallInfo)
740 {
741     return SetCircleShape(runtimeCallInfo, true);
742 }
743 
SetRoundRectClip(ArkUIRuntimeCallInfo * runtimeCallInfo)744 ArkUINativeModuleValue RenderNodeBridge::SetRoundRectClip(ArkUIRuntimeCallInfo* runtimeCallInfo)
745 {
746     return SetRoundRectShape(runtimeCallInfo, true);
747 }
748 
SetOvalClip(ArkUIRuntimeCallInfo * runtimeCallInfo)749 ArkUINativeModuleValue RenderNodeBridge::SetOvalClip(ArkUIRuntimeCallInfo* runtimeCallInfo)
750 {
751     return SetOvalShape(runtimeCallInfo, true);
752 }
753 
SetCommandPathClip(ArkUIRuntimeCallInfo * runtimeCallInfo)754 ArkUINativeModuleValue RenderNodeBridge::SetCommandPathClip(ArkUIRuntimeCallInfo* runtimeCallInfo)
755 {
756     return SetCommandPathShape(runtimeCallInfo, true);
757 }
758 
Invalidate(ArkUIRuntimeCallInfo * runtimeCallInfo)759 ArkUINativeModuleValue RenderNodeBridge::Invalidate(ArkUIRuntimeCallInfo* runtimeCallInfo)
760 {
761     EcmaVM* vm = runtimeCallInfo->GetVM();
762     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
763     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
764     GetArkUINodeModifiers()->getRenderNodeModifier()->invalidate(nativeNode);
765     return panda::JSValueRef::Undefined(vm);
766 }
767 
SetMarkNodeGroup(ArkUIRuntimeCallInfo * runtimeCallInfo)768 ArkUINativeModuleValue RenderNodeBridge::SetMarkNodeGroup(ArkUIRuntimeCallInfo* runtimeCallInfo)
769 {
770     EcmaVM* vm = runtimeCallInfo->GetVM();
771     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
772     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
773 
774     Local<JSValueRef> isNodeGroup = runtimeCallInfo->GetCallArgRef(1);
775     bool isNodeGroupValue = false;
776     if (isNodeGroup->IsBoolean()) {
777         isNodeGroupValue = isNodeGroup->ToBoolean(vm)->Value();
778     }
779 
780     GetArkUINodeModifiers()->getRenderNodeModifier()->setMarkNodeGroup(nativeNode, isNodeGroupValue);
781     return panda::JSValueRef::Undefined(vm);
782 }
783 } // namespace OHOS::Ace::NG
784