1 /*
2  * Copyright (c) 2023-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 "bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_grid_bridge.h"
16 #include "base/utils/string_utils.h"
17 #include "base/utils/utils.h"
18 #include "bridge/declarative_frontend/engine/functions/js_function.h"
19 #include "bridge/declarative_frontend/jsview/js_grid.h"
20 #include "bridge/declarative_frontend/jsview/js_scroller.h"
21 #include "core/components_ng/pattern/grid/grid_model_ng.h"
22 #include "core/components_ng/pattern/scroll_bar/proxy/scroll_bar_proxy.h"
23 #include "core/components_ng/pattern/scrollable/scrollable_controller.h"
24 #include "frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h"
25 
26 namespace OHOS::Ace::NG {
27 constexpr int32_t CALL_ARG_0 = 0;
28 constexpr int32_t CALL_ARG_1 = 1;
29 constexpr int32_t CALL_ARG_2 = 2;
30 constexpr int32_t DEFAULT_CACHED_COUNT = 1;
31 constexpr size_t GRID_ITEM_SIZE_RESULT_LENGTH = 2;
32 constexpr size_t GRID_ITEM_RECT_RESULT_LENGTH = 4;
33 namespace {
ParseGridItemSize(const Framework::JSRef<Framework::JSVal> & value,GridItemSize & gridItemSize)34 void ParseGridItemSize(const Framework::JSRef<Framework::JSVal>& value, GridItemSize& gridItemSize)
35 {
36     if (value->IsArray()) {
37         auto array = Framework::JSRef<Framework::JSArray>::Cast(value);
38         auto length = array->Length();
39         if (length != GRID_ITEM_SIZE_RESULT_LENGTH) {
40             return;
41         }
42         Framework::JSRef<Framework::JSVal> rows = array->GetValueAt(0);
43         if (rows->IsNumber()) {
44             gridItemSize.rows = rows->ToNumber<int32_t>();
45         }
46         Framework::JSRef<Framework::JSVal> columns = array->GetValueAt(1);
47         if (columns->IsNumber()) {
48             gridItemSize.columns = columns->ToNumber<int32_t>();
49         }
50     }
51 }
52 
ParseGridItemRect(const Framework::JSRef<Framework::JSVal> & value,GridItemRect & gridItemRect)53 void ParseGridItemRect(const Framework::JSRef<Framework::JSVal>& value, GridItemRect& gridItemRect)
54 {
55     if (value->IsArray()) {
56         Framework::JSRef<Framework::JSArray> array = Framework::JSRef<Framework::JSArray>::Cast(value);
57         auto length = array->Length();
58         if (length != GRID_ITEM_RECT_RESULT_LENGTH) {
59             return;
60         }
61         auto rowStart = array->GetValueAt(GridItemRect::ROW_START);
62         if (rowStart->IsNumber()) {
63             gridItemRect.rowStart = rowStart->ToNumber<int32_t>();
64         }
65         auto rowSpan = array->GetValueAt(GridItemRect::ROW_SPAN);
66         if (rowSpan->IsNumber()) {
67             gridItemRect.rowSpan = rowSpan->ToNumber<int32_t>();
68         }
69         auto columnStart = array->GetValueAt(GridItemRect::COLUMN_START);
70         if (columnStart->IsNumber()) {
71             gridItemRect.columnStart = columnStart->ToNumber<int32_t>();
72         }
73         auto columnSpan = array->GetValueAt(GridItemRect::COLUMN_SPAN);
74         if (columnSpan->IsNumber()) {
75             gridItemRect.columnSpan = columnSpan->ToNumber<int32_t>();
76         }
77     }
78 }
79 
ParseGetGridItemSize(const EcmaVM * vm,const Local<JSValueRef> & getSizeByIndex,GridLayoutOptions & option)80 void ParseGetGridItemSize(const EcmaVM* vm, const Local<JSValueRef>& getSizeByIndex, GridLayoutOptions& option)
81 {
82     if (getSizeByIndex->IsFunction(vm)) {
83         Local<panda::FunctionRef> functionRef = getSizeByIndex->ToObject(vm);
84         auto onGetIrregularSizeByIndex =
85             [func = AceType::MakeRefPtr<Framework::JsFunction>(Framework::JSRef<Framework::JSObject>(),
86                  Framework::JSRef<Framework::JSFunc>(Framework::JSFunc(functionRef)))](int32_t index) {
87                 GridItemSize gridItemSize;
88                 auto itemIndex = Framework::JSRef<Framework::JSVal>::Make(Framework::ToJSValue(index));
89                 auto result = func->ExecuteJS(1, &itemIndex);
90                 if (!result->IsArray()) {
91                     return gridItemSize;
92                 }
93                 ParseGridItemSize(result, gridItemSize);
94                 return gridItemSize;
95             };
96         option.getSizeByIndex = std::move(onGetIrregularSizeByIndex);
97     }
98 }
99 
ParseGetGridItemRect(const EcmaVM * vm,const Local<JSValueRef> & getRectByIndex,GridLayoutOptions & option)100 void ParseGetGridItemRect(const EcmaVM* vm, const Local<JSValueRef>& getRectByIndex, GridLayoutOptions& option)
101 {
102     if (getRectByIndex->IsFunction(vm)) {
103         Local<panda::FunctionRef> functionRef = getRectByIndex->ToObject(vm);
104         auto onGetRectByIndex =
105             [func = AceType::MakeRefPtr<Framework::JsFunction>(Framework::JSRef<Framework::JSObject>(),
106                  Framework::JSRef<Framework::JSFunc>(Framework::JSFunc(functionRef)))](int32_t index) {
107                 GridItemRect gridItemRect;
108                 auto itemIndex = Framework::JSRef<Framework::JSVal>::Make(Framework::ToJSValue(index));
109                 auto result = func->ExecuteJS(1, &itemIndex);
110                 if (!result->IsArray()) {
111                     return gridItemRect;
112                 }
113                 ParseGridItemRect(result, gridItemRect);
114                 return gridItemRect;
115             };
116         option.getRectByIndex = std::move(onGetRectByIndex);
117     }
118 }
119 } // namespace
120 
SetColumnsTemplate(ArkUIRuntimeCallInfo * runtimeCallInfo)121 ArkUINativeModuleValue GridBridge::SetColumnsTemplate(ArkUIRuntimeCallInfo* runtimeCallInfo)
122 {
123     EcmaVM* vm = runtimeCallInfo->GetVM();
124     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
125     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
126     Local<JSValueRef> arg_columnsTemplate = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
127     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
128     if (arg_columnsTemplate->IsUndefined() || !arg_columnsTemplate->IsString(vm)) {
129         GetArkUINodeModifiers()->getGridModifier()->resetGridColumnsTemplate(nativeNode);
130     } else {
131         std::string columnsTemplate = arg_columnsTemplate->ToString(vm)->ToString(vm);
132         GetArkUINodeModifiers()->getGridModifier()->setGridColumnsTemplate(nativeNode, columnsTemplate.c_str());
133     }
134     return panda::JSValueRef::Undefined(vm);
135 }
136 
ResetColumnsTemplate(ArkUIRuntimeCallInfo * runtimeCallInfo)137 ArkUINativeModuleValue GridBridge::ResetColumnsTemplate(ArkUIRuntimeCallInfo* runtimeCallInfo)
138 {
139     EcmaVM* vm = runtimeCallInfo->GetVM();
140     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
141     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
142     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
143     GetArkUINodeModifiers()->getGridModifier()->resetGridColumnsTemplate(nativeNode);
144     return panda::JSValueRef::Undefined(vm);
145 }
146 
SetRowsTemplate(ArkUIRuntimeCallInfo * runtimeCallInfo)147 ArkUINativeModuleValue GridBridge::SetRowsTemplate(ArkUIRuntimeCallInfo* runtimeCallInfo)
148 {
149     EcmaVM* vm = runtimeCallInfo->GetVM();
150     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
151     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
152     Local<JSValueRef> arg_rowsTemplate = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
153     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
154     if (arg_rowsTemplate->IsUndefined() || !arg_rowsTemplate->IsString(vm)) {
155         GetArkUINodeModifiers()->getGridModifier()->resetGridRowsTemplate(nativeNode);
156     } else {
157         std::string rowsTemplate = arg_rowsTemplate->ToString(vm)->ToString(vm);
158         GetArkUINodeModifiers()->getGridModifier()->setGridRowsTemplate(nativeNode, rowsTemplate.c_str());
159     }
160     return panda::JSValueRef::Undefined(vm);
161 }
162 
ResetRowsTemplate(ArkUIRuntimeCallInfo * runtimeCallInfo)163 ArkUINativeModuleValue GridBridge::ResetRowsTemplate(ArkUIRuntimeCallInfo* runtimeCallInfo)
164 {
165     EcmaVM* vm = runtimeCallInfo->GetVM();
166     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
167     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
168     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
169     GetArkUINodeModifiers()->getGridModifier()->resetGridRowsTemplate(nativeNode);
170     return panda::JSValueRef::Undefined(vm);
171 }
172 
SetColumnsGap(ArkUIRuntimeCallInfo * runtimeCallInfo)173 ArkUINativeModuleValue GridBridge::SetColumnsGap(ArkUIRuntimeCallInfo* runtimeCallInfo)
174 {
175     EcmaVM* vm = runtimeCallInfo->GetVM();
176     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
177     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
178     Local<JSValueRef> arg_size = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
179     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
180 
181     CalcDimension size;
182     std::string calcStr;
183     struct ArkUIResourceLength columnGap = { 0.0, 0, nullptr };
184     if (arg_size->IsUndefined() || !ArkTSUtils::ParseJsDimensionVpNG(vm, arg_size, size, true)) {
185         GetArkUINodeModifiers()->getGridModifier()->resetGridColumnsGap(nativeNode);
186     } else {
187         if (size.Unit() == DimensionUnit::CALC) {
188             columnGap.unit = static_cast<int32_t>(DimensionUnit::CALC);
189             calcStr = size.CalcValue();
190             columnGap.string = calcStr.c_str();
191             GetArkUINodeModifiers()->getGridModifier()->setGridColumnsGap(nativeNode, &columnGap);
192         } else {
193             columnGap.value = size.Value();
194             columnGap.unit = static_cast<int32_t>(size.Unit());
195             columnGap.string = calcStr.c_str();
196             GetArkUINodeModifiers()->getGridModifier()->setGridColumnsGap(nativeNode, &columnGap);
197         }
198     }
199     return panda::JSValueRef::Undefined(vm);
200 }
201 
ResetColumnsGap(ArkUIRuntimeCallInfo * runtimeCallInfo)202 ArkUINativeModuleValue GridBridge::ResetColumnsGap(ArkUIRuntimeCallInfo* runtimeCallInfo)
203 {
204     EcmaVM* vm = runtimeCallInfo->GetVM();
205     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
206     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
207     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
208     GetArkUINodeModifiers()->getGridModifier()->resetGridColumnsGap(nativeNode);
209     return panda::JSValueRef::Undefined(vm);
210 }
211 
SetRowsGap(ArkUIRuntimeCallInfo * runtimeCallInfo)212 ArkUINativeModuleValue GridBridge::SetRowsGap(ArkUIRuntimeCallInfo* runtimeCallInfo)
213 {
214     EcmaVM* vm = runtimeCallInfo->GetVM();
215     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
216     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
217     Local<JSValueRef> arg_size = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
218     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
219 
220     CalcDimension size;
221     std::string calcStr;
222     struct ArkUIResourceLength rowsGap = { 0.0, 0, nullptr };
223     if (arg_size->IsUndefined() || !ArkTSUtils::ParseJsDimensionVpNG(vm, arg_size, size, true)) {
224         GetArkUINodeModifiers()->getGridModifier()->resetGridRowsGap(nativeNode);
225     } else {
226         if (size.Unit() == DimensionUnit::CALC) {
227             rowsGap.unit = static_cast<int32_t>(DimensionUnit::CALC);
228             calcStr = size.CalcValue();
229             rowsGap.string = calcStr.c_str();
230             GetArkUINodeModifiers()->getGridModifier()->setGridRowsGap(nativeNode, &rowsGap);
231         } else {
232             rowsGap.value = size.Value();
233             rowsGap.unit = static_cast<int32_t>(size.Unit());
234             rowsGap.string = calcStr.c_str();
235             GetArkUINodeModifiers()->getGridModifier()->setGridRowsGap(nativeNode, &rowsGap);
236         }
237     }
238     return panda::JSValueRef::Undefined(vm);
239 }
240 
ResetRowsGap(ArkUIRuntimeCallInfo * runtimeCallInfo)241 ArkUINativeModuleValue GridBridge::ResetRowsGap(ArkUIRuntimeCallInfo* runtimeCallInfo)
242 {
243     EcmaVM* vm = runtimeCallInfo->GetVM();
244     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
245     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
246     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
247     GetArkUINodeModifiers()->getGridModifier()->resetGridRowsGap(nativeNode);
248     return panda::JSValueRef::Undefined(vm);
249 }
250 
SetScrollBar(ArkUIRuntimeCallInfo * runtimeCallInfo)251 ArkUINativeModuleValue GridBridge::SetScrollBar(ArkUIRuntimeCallInfo* runtimeCallInfo)
252 {
253     EcmaVM* vm = runtimeCallInfo->GetVM();
254     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
255     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
256     Local<JSValueRef> arg_scrollBar = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
257     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
258     if (!arg_scrollBar->IsNull() && arg_scrollBar->IsNumber()) {
259         int32_t scrollBar = arg_scrollBar->Int32Value(vm);
260         if (scrollBar < 0) {
261             GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBar(nativeNode);
262         } else {
263             GetArkUINodeModifiers()->getGridModifier()->setGridScrollBar(nativeNode, scrollBar);
264         }
265     } else {
266         GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBar(nativeNode);
267     }
268     return panda::JSValueRef::Undefined(vm);
269 }
270 
ResetScrollBar(ArkUIRuntimeCallInfo * runtimeCallInfo)271 ArkUINativeModuleValue GridBridge::ResetScrollBar(ArkUIRuntimeCallInfo* runtimeCallInfo)
272 {
273     EcmaVM* vm = runtimeCallInfo->GetVM();
274     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
275     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
276     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
277     GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBar(nativeNode);
278     return panda::JSValueRef::Undefined(vm);
279 }
280 
SetScrollBarWidth(ArkUIRuntimeCallInfo * runtimeCallInfo)281 ArkUINativeModuleValue GridBridge::SetScrollBarWidth(ArkUIRuntimeCallInfo* runtimeCallInfo)
282 {
283     EcmaVM* vm = runtimeCallInfo->GetVM();
284     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
285     Local<JSValueRef> nativeNodeArg = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
286     Local<JSValueRef> scrollBarArg = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
287     auto nativeNode = nodePtr(nativeNodeArg->ToNativePointer(vm)->Value());
288 
289     CalcDimension scrollBarWidth;
290     if (!ArkTSUtils::ParseJsDimensionVpNG(vm, scrollBarArg, scrollBarWidth, false)) {
291         GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBarWidth(nativeNode);
292     } else {
293         if (LessNotEqual(scrollBarWidth.Value(), 0.0f)) {
294             GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBarWidth(nativeNode);
295         } else {
296             GetArkUINodeModifiers()->getGridModifier()->setGridScrollBarWidth(
297                 nativeNode, scrollBarWidth.Value(), static_cast<int32_t>(scrollBarWidth.Unit()));
298         }
299     }
300     return panda::JSValueRef::Undefined(vm);
301 }
302 
ResetScrollBarWidth(ArkUIRuntimeCallInfo * runtimeCallInfo)303 ArkUINativeModuleValue GridBridge::ResetScrollBarWidth(ArkUIRuntimeCallInfo* runtimeCallInfo)
304 {
305     EcmaVM* vm = runtimeCallInfo->GetVM();
306     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
307     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
308     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
309     GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBarWidth(nativeNode);
310     return panda::JSValueRef::Undefined(vm);
311 }
312 
SetScrollBarColor(ArkUIRuntimeCallInfo * runtimeCallInfo)313 ArkUINativeModuleValue GridBridge::SetScrollBarColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
314 {
315     EcmaVM* vm = runtimeCallInfo->GetVM();
316     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
317     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
318     Local<JSValueRef> arg_color = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
319     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
320     if (arg_color->IsNull() || arg_color->IsUndefined()) {
321         GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBarColor(nativeNode);
322         return panda::JSValueRef::Undefined(vm);
323     }
324     if (arg_color->IsNumber()) {
325         auto colorNum = arg_color->ToNumber(vm)->Value();
326         if (colorNum <= 0) {
327             GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBarColor(nativeNode);
328             return panda::JSValueRef::Undefined(vm);
329         }
330     }
331     Color color;
332     if (ArkTSUtils::ParseJsColorAlpha(vm, arg_color, color)) {
333         GetArkUINodeModifiers()->getGridModifier()->setGridScrollBarColor(
334             nativeNode, color.GetValue());
335     } else {
336         GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBarColor(nativeNode);
337     }
338     return panda::JSValueRef::Undefined(vm);
339 }
340 
ResetScrollBarColor(ArkUIRuntimeCallInfo * runtimeCallInfo)341 ArkUINativeModuleValue GridBridge::ResetScrollBarColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
342 {
343     EcmaVM* vm = runtimeCallInfo->GetVM();
344     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
345     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
346     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
347     GetArkUINodeModifiers()->getGridModifier()->resetGridScrollBarColor(nativeNode);
348     return panda::JSValueRef::Undefined(vm);
349 }
350 
SetCachedCount(ArkUIRuntimeCallInfo * runtimeCallInfo)351 ArkUINativeModuleValue GridBridge::SetCachedCount(ArkUIRuntimeCallInfo* runtimeCallInfo)
352 {
353     EcmaVM* vm = runtimeCallInfo->GetVM();
354     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
355     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
356     Local<JSValueRef> argCachedCount = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
357     Local<JSValueRef> argShow = runtimeCallInfo->GetCallArgRef(CALL_ARG_2);
358     auto* nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
359     auto value = DEFAULT_CACHED_COUNT;
360     if (!argCachedCount->IsUndefined()) {
361         ArkTSUtils::ParseJsInteger(vm, argCachedCount, value);
362         if (value < 0) {
363             value = DEFAULT_CACHED_COUNT;
364         }
365     }
366     GetArkUINodeModifiers()->getGridModifier()->setGridCachedCount(nativeNode, value);
367 
368     bool show = !argShow.IsNull() && argShow->IsTrue();
369     GetArkUINodeModifiers()->getGridModifier()->setShowCached(nativeNode, show);
370     return panda::JSValueRef::Undefined(vm);
371 }
372 
ResetCachedCount(ArkUIRuntimeCallInfo * runtimeCallInfo)373 ArkUINativeModuleValue GridBridge::ResetCachedCount(ArkUIRuntimeCallInfo* runtimeCallInfo)
374 {
375     EcmaVM* vm = runtimeCallInfo->GetVM();
376     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
377     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
378     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
379     GetArkUINodeModifiers()->getGridModifier()->resetGridCachedCount(nativeNode);
380     GetArkUINodeModifiers()->getGridModifier()->resetShowCached(nativeNode);
381     return panda::JSValueRef::Undefined(vm);
382 }
383 
SetEditMode(ArkUIRuntimeCallInfo * runtimeCallInfo)384 ArkUINativeModuleValue GridBridge::SetEditMode(ArkUIRuntimeCallInfo* runtimeCallInfo)
385 {
386     EcmaVM* vm = runtimeCallInfo->GetVM();
387     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
388     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
389     Local<JSValueRef> arg_editMode = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
390     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
391     bool editMode = arg_editMode->ToBoolean(vm)->Value();
392     GetArkUINodeModifiers()->getGridModifier()->setGridEditMode(nativeNode, editMode);
393     return panda::JSValueRef::Undefined(vm);
394 }
395 
ResetEditMode(ArkUIRuntimeCallInfo * runtimeCallInfo)396 ArkUINativeModuleValue GridBridge::ResetEditMode(ArkUIRuntimeCallInfo* runtimeCallInfo)
397 {
398     EcmaVM* vm = runtimeCallInfo->GetVM();
399     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
400     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
401     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
402     GetArkUINodeModifiers()->getGridModifier()->resetGridEditMode(nativeNode);
403     return panda::JSValueRef::Undefined(vm);
404 }
405 
SetMultiSelectable(ArkUIRuntimeCallInfo * runtimeCallInfo)406 ArkUINativeModuleValue GridBridge::SetMultiSelectable(ArkUIRuntimeCallInfo* runtimeCallInfo)
407 {
408     EcmaVM* vm = runtimeCallInfo->GetVM();
409     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
410     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
411     Local<JSValueRef> arg_multiSelectable = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
412     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
413     bool multiSelectable = arg_multiSelectable->ToBoolean(vm)->Value();
414     GetArkUINodeModifiers()->getGridModifier()->setGridMultiSelectable(nativeNode, multiSelectable);
415     return panda::JSValueRef::Undefined(vm);
416 }
417 
ResetMultiSelectable(ArkUIRuntimeCallInfo * runtimeCallInfo)418 ArkUINativeModuleValue GridBridge::ResetMultiSelectable(ArkUIRuntimeCallInfo* runtimeCallInfo)
419 {
420     EcmaVM* vm = runtimeCallInfo->GetVM();
421     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
422     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
423     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
424     GetArkUINodeModifiers()->getGridModifier()->resetGridMultiSelectable(nativeNode);
425     return panda::JSValueRef::Undefined(vm);
426 }
427 
SetMaxCount(ArkUIRuntimeCallInfo * runtimeCallInfo)428 ArkUINativeModuleValue GridBridge::SetMaxCount(ArkUIRuntimeCallInfo* runtimeCallInfo)
429 {
430     EcmaVM* vm = runtimeCallInfo->GetVM();
431     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
432     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
433     Local<JSValueRef> arg_maxCount = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
434     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
435     if (!arg_maxCount->IsNull() && arg_maxCount->IsNumber()) {
436         int32_t maxCount = arg_maxCount->Int32Value(vm);
437         if (maxCount < 1) {
438             GetArkUINodeModifiers()->getGridModifier()->resetGridMaxCount(nativeNode);
439         } else {
440             GetArkUINodeModifiers()->getGridModifier()->setGridMaxCount(nativeNode, maxCount);
441         }
442     } else {
443         GetArkUINodeModifiers()->getGridModifier()->resetGridMaxCount(nativeNode);
444     }
445     return panda::JSValueRef::Undefined(vm);
446 }
447 
ResetMaxCount(ArkUIRuntimeCallInfo * runtimeCallInfo)448 ArkUINativeModuleValue GridBridge::ResetMaxCount(ArkUIRuntimeCallInfo* runtimeCallInfo)
449 {
450     EcmaVM* vm = runtimeCallInfo->GetVM();
451     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
452     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
453     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
454     GetArkUINodeModifiers()->getGridModifier()->resetGridMaxCount(nativeNode);
455     return panda::JSValueRef::Undefined(vm);
456 }
457 
SetMinCount(ArkUIRuntimeCallInfo * runtimeCallInfo)458 ArkUINativeModuleValue GridBridge::SetMinCount(ArkUIRuntimeCallInfo* runtimeCallInfo)
459 {
460     EcmaVM* vm = runtimeCallInfo->GetVM();
461     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
462     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
463     Local<JSValueRef> arg_minCount = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
464     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
465     if (!arg_minCount->IsNull() && arg_minCount->IsNumber()) {
466         int32_t minCount = arg_minCount->Int32Value(vm);
467         if (minCount < 1) {
468             GetArkUINodeModifiers()->getGridModifier()->resetGridMinCount(nativeNode);
469         } else {
470             GetArkUINodeModifiers()->getGridModifier()->setGridMinCount(nativeNode, minCount);
471         }
472     } else {
473         GetArkUINodeModifiers()->getGridModifier()->resetGridMinCount(nativeNode);
474     }
475     return panda::JSValueRef::Undefined(vm);
476 }
477 
ResetMinCount(ArkUIRuntimeCallInfo * runtimeCallInfo)478 ArkUINativeModuleValue GridBridge::ResetMinCount(ArkUIRuntimeCallInfo* runtimeCallInfo)
479 {
480     EcmaVM* vm = runtimeCallInfo->GetVM();
481     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
482     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
483     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
484     GetArkUINodeModifiers()->getGridModifier()->resetGridMinCount(nativeNode);
485     return panda::JSValueRef::Undefined(vm);
486 }
487 
SetCellLength(ArkUIRuntimeCallInfo * runtimeCallInfo)488 ArkUINativeModuleValue GridBridge::SetCellLength(ArkUIRuntimeCallInfo* runtimeCallInfo)
489 {
490     EcmaVM* vm = runtimeCallInfo->GetVM();
491     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
492     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
493     Local<JSValueRef> arg_cellLength = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
494     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
495     if (!arg_cellLength->IsNull() && arg_cellLength->IsNumber()) {
496         int32_t cellLength = arg_cellLength->Int32Value(vm);
497         GetArkUINodeModifiers()->getGridModifier()->setGridCellLength(nativeNode, cellLength);
498     } else {
499         GetArkUINodeModifiers()->getGridModifier()->resetGridCellLength(nativeNode);
500     }
501     return panda::JSValueRef::Undefined(vm);
502 }
503 
ResetCellLength(ArkUIRuntimeCallInfo * runtimeCallInfo)504 ArkUINativeModuleValue GridBridge::ResetCellLength(ArkUIRuntimeCallInfo* runtimeCallInfo)
505 {
506     EcmaVM* vm = runtimeCallInfo->GetVM();
507     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
508     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
509     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
510     GetArkUINodeModifiers()->getGridModifier()->resetGridCellLength(nativeNode);
511     return panda::JSValueRef::Undefined(vm);
512 }
513 
SetLayoutDirection(ArkUIRuntimeCallInfo * runtimeCallInfo)514 ArkUINativeModuleValue GridBridge::SetLayoutDirection(ArkUIRuntimeCallInfo* runtimeCallInfo)
515 {
516     EcmaVM* vm = runtimeCallInfo->GetVM();
517     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
518     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
519     Local<JSValueRef> arg_layoutDirection = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
520     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
521     if (!arg_layoutDirection->IsNull() && arg_layoutDirection->IsNumber()) {
522         int32_t layoutDirection = arg_layoutDirection->Int32Value(vm);
523         GetArkUINodeModifiers()->getGridModifier()->setGridLayoutDirection(nativeNode, layoutDirection);
524     } else {
525         GetArkUINodeModifiers()->getGridModifier()->resetGridLayoutDirection(nativeNode);
526     }
527     return panda::JSValueRef::Undefined(vm);
528 }
529 
ResetLayoutDirection(ArkUIRuntimeCallInfo * runtimeCallInfo)530 ArkUINativeModuleValue GridBridge::ResetLayoutDirection(ArkUIRuntimeCallInfo* runtimeCallInfo)
531 {
532     EcmaVM* vm = runtimeCallInfo->GetVM();
533     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
534     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
535     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
536     GetArkUINodeModifiers()->getGridModifier()->resetGridLayoutDirection(nativeNode);
537     return panda::JSValueRef::Undefined(vm);
538 }
539 
SetSupportAnimation(ArkUIRuntimeCallInfo * runtimeCallInfo)540 ArkUINativeModuleValue GridBridge::SetSupportAnimation(ArkUIRuntimeCallInfo* runtimeCallInfo)
541 {
542     EcmaVM* vm = runtimeCallInfo->GetVM();
543     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
544     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
545     Local<JSValueRef> arg_supportAnimation = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
546     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
547     bool supportAnimation = arg_supportAnimation->ToBoolean(vm)->Value();
548     GetArkUINodeModifiers()->getGridModifier()->setGridSupportAnimation(nativeNode, supportAnimation);
549     return panda::JSValueRef::Undefined(vm);
550 }
551 
ResetSupportAnimation(ArkUIRuntimeCallInfo * runtimeCallInfo)552 ArkUINativeModuleValue GridBridge::ResetSupportAnimation(ArkUIRuntimeCallInfo* runtimeCallInfo)
553 {
554     EcmaVM* vm = runtimeCallInfo->GetVM();
555     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
556     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
557     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
558     GetArkUINodeModifiers()->getGridModifier()->resetGridSupportAnimation(nativeNode);
559     return panda::JSValueRef::Undefined(vm);
560 }
561 
SetEdgeEffect(ArkUIRuntimeCallInfo * runtimeCallInfo)562 ArkUINativeModuleValue GridBridge::SetEdgeEffect(ArkUIRuntimeCallInfo* runtimeCallInfo)
563 {
564     EcmaVM* vm = runtimeCallInfo->GetVM();
565     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
566     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
567     Local<JSValueRef> arg_effect = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
568     Local<JSValueRef> arg_edgeEffectOptions = runtimeCallInfo->GetCallArgRef(CALL_ARG_2);
569 
570     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
571     int32_t effect = static_cast<int32_t>(EdgeEffect::NONE);
572     if (!arg_effect->IsUndefined() && !arg_effect->IsNull()) {
573         effect = arg_effect->Int32Value(vm);
574     }
575 
576     if (effect != static_cast<int32_t>(EdgeEffect::SPRING) && effect != static_cast<int32_t>(EdgeEffect::NONE) &&
577         effect != static_cast<int32_t>(EdgeEffect::FADE)) {
578         effect = static_cast<int32_t>(EdgeEffect::NONE);
579     }
580 
581     if (arg_edgeEffectOptions->IsNull() || arg_edgeEffectOptions->IsUndefined()) {
582         GetArkUINodeModifiers()->getGridModifier()->setEdgeEffect(nativeNode, effect, false);
583     } else {
584         GetArkUINodeModifiers()->getGridModifier()->setEdgeEffect(
585             nativeNode, effect, arg_edgeEffectOptions->ToBoolean(vm)->Value());
586     }
587     return panda::JSValueRef::Undefined(vm);
588 }
ResetEdgeEffect(ArkUIRuntimeCallInfo * runtimeCallInfo)589 ArkUINativeModuleValue GridBridge::ResetEdgeEffect(ArkUIRuntimeCallInfo* runtimeCallInfo)
590 {
591     EcmaVM* vm = runtimeCallInfo->GetVM();
592     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
593     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
594     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
595     GetArkUINodeModifiers()->getGridModifier()->resetEdgeEffect(nativeNode);
596     return panda::JSValueRef::Undefined(vm);
597 }
598 
SetFadingEdge(ArkUIRuntimeCallInfo * runtimeCallInfo)599 ArkUINativeModuleValue GridBridge::SetFadingEdge(ArkUIRuntimeCallInfo* runtimeCallInfo)
600 {
601     EcmaVM* vm = runtimeCallInfo->GetVM();
602     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
603     Local<JSValueRef> frameNodeArg = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
604     Local<JSValueRef> fadingEdgeArg = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
605     Local<JSValueRef> fadingEdgeLengthArg = runtimeCallInfo->GetCallArgRef(CALL_ARG_2);
606     auto nativeNode = nodePtr(frameNodeArg->ToNativePointer(vm)->Value());
607     CalcDimension fadingEdgeLength = Dimension(32.0f, DimensionUnit::VP); // default value
608     if (fadingEdgeArg->IsUndefined() || fadingEdgeArg->IsNull()) {
609         GetArkUINodeModifiers()->getGridModifier()->resetGridFadingEdge(nativeNode);
610     } else {
611         bool fadingEdge = fadingEdgeArg->ToBoolean(vm)->Value();
612         if (!fadingEdgeLengthArg->IsUndefined() && !fadingEdgeLengthArg->IsNull() &&
613             fadingEdgeLengthArg->IsObject(vm)) {
614             ArkTSUtils::ParseJsLengthMetrics(vm, fadingEdgeLengthArg, fadingEdgeLength);
615         }
616         GetArkUINodeModifiers()->getGridModifier()->setGridFadingEdge(
617             nativeNode, fadingEdge, fadingEdgeLength.Value(), static_cast<int32_t>(fadingEdgeLength.Unit()));
618     }
619     return panda::JSValueRef::Undefined(vm);
620 }
ResetFadingEdge(ArkUIRuntimeCallInfo * runtimeCallInfo)621 ArkUINativeModuleValue GridBridge::ResetFadingEdge(ArkUIRuntimeCallInfo* runtimeCallInfo)
622 {
623     EcmaVM* vm = runtimeCallInfo->GetVM();
624     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
625     Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(0);
626     auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
627     GetArkUINodeModifiers()->getGridModifier()->resetGridFadingEdge(nativeNode);
628     return panda::JSValueRef::Undefined(vm);
629 }
SetNestedScroll(ArkUIRuntimeCallInfo * runtimeCallInfo)630 ArkUINativeModuleValue GridBridge::SetNestedScroll(ArkUIRuntimeCallInfo* runtimeCallInfo)
631 {
632     EcmaVM* vm = runtimeCallInfo->GetVM();
633     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
634     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
635     Local<JSValueRef> arg_forward = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
636     Local<JSValueRef> arg_backward = runtimeCallInfo->GetCallArgRef(CALL_ARG_2);
637 
638     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
639     int32_t forward = static_cast<int32_t>(NestedScrollMode::SELF_ONLY);
640     int32_t backward = static_cast<int32_t>(NestedScrollMode::SELF_ONLY);
641     if (!arg_forward->IsUndefined()) {
642         forward = arg_forward->Int32Value(vm);
643     }
644     if (!arg_backward->IsUndefined()) {
645         backward = arg_backward->Int32Value(vm);
646     }
647 
648     if (forward < static_cast<int32_t>(NestedScrollMode::SELF_ONLY) ||
649         forward > static_cast<int32_t>(NestedScrollMode::PARALLEL)) {
650         forward = static_cast<int32_t>(NestedScrollMode::SELF_ONLY);
651     }
652 
653     if (backward < static_cast<int32_t>(NestedScrollMode::SELF_ONLY) ||
654         backward > static_cast<int32_t>(NestedScrollMode::PARALLEL)) {
655         backward = static_cast<int32_t>(NestedScrollMode::SELF_ONLY);
656     }
657 
658     GetArkUINodeModifiers()->getGridModifier()->setNestedScroll(nativeNode, forward, backward);
659 
660     return panda::JSValueRef::Undefined(vm);
661 }
ResetNestedScroll(ArkUIRuntimeCallInfo * runtimeCallInfo)662 ArkUINativeModuleValue GridBridge::ResetNestedScroll(ArkUIRuntimeCallInfo* runtimeCallInfo)
663 {
664     EcmaVM* vm = runtimeCallInfo->GetVM();
665     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
666     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
667     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
668     GetArkUINodeModifiers()->getGridModifier()->resetNestedScroll(nativeNode);
669     return panda::JSValueRef::Undefined(vm);
670 }
SetEnableScroll(ArkUIRuntimeCallInfo * runtimeCallInfo)671 ArkUINativeModuleValue GridBridge::SetEnableScroll(ArkUIRuntimeCallInfo* runtimeCallInfo)
672 {
673     EcmaVM* vm = runtimeCallInfo->GetVM();
674     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
675     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
676     Local<JSValueRef> arg_enableScroll = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
677 
678     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
679 
680     GetArkUINodeModifiers()->getGridModifier()->setEnableScroll(
681         nativeNode, arg_enableScroll->IsBoolean() ? arg_enableScroll->ToBoolean(vm)->Value() : true);
682 
683     return panda::JSValueRef::Undefined(vm);
684 }
ResetEnableScroll(ArkUIRuntimeCallInfo * runtimeCallInfo)685 ArkUINativeModuleValue GridBridge::ResetEnableScroll(ArkUIRuntimeCallInfo* runtimeCallInfo)
686 {
687     EcmaVM* vm = runtimeCallInfo->GetVM();
688     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
689     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
690     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
691     GetArkUINodeModifiers()->getGridModifier()->resetEnableScroll(nativeNode);
692     return panda::JSValueRef::Undefined(vm);
693 }
SetFriction(ArkUIRuntimeCallInfo * runtimeCallInfo)694 ArkUINativeModuleValue GridBridge::SetFriction(ArkUIRuntimeCallInfo* runtimeCallInfo)
695 {
696     EcmaVM* vm = runtimeCallInfo->GetVM();
697     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
698     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
699     Local<JSValueRef> arg_friction = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
700 
701     double friction = -1.0;
702     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
703     if (!ArkTSUtils::ParseJsDouble(vm, arg_friction, friction)) {
704         friction = -1.0;
705     }
706     GetArkUINodeModifiers()->getGridModifier()->setFriction(nativeNode, static_cast<ArkUI_Float32>(friction));
707 
708     return panda::JSValueRef::Undefined(vm);
709 }
ResetFriction(ArkUIRuntimeCallInfo * runtimeCallInfo)710 ArkUINativeModuleValue GridBridge::ResetFriction(ArkUIRuntimeCallInfo* runtimeCallInfo)
711 {
712     EcmaVM* vm = runtimeCallInfo->GetVM();
713     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
714     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
715     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
716     GetArkUINodeModifiers()->getGridModifier()->resetFriction(nativeNode);
717     return panda::JSValueRef::Undefined(vm);
718 }
SetFlingSpeedLimit(ArkUIRuntimeCallInfo * runtimeCallInfo)719 ArkUINativeModuleValue GridBridge::SetFlingSpeedLimit(ArkUIRuntimeCallInfo* runtimeCallInfo)
720 {
721     EcmaVM* vm = runtimeCallInfo->GetVM();
722     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
723     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
724     Local<JSValueRef> arg_flingSpeedLimit = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
725 
726     double flingSpeedLimit = -1.0f;
727     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
728     if (!ArkTSUtils::ParseJsDouble(vm, arg_flingSpeedLimit, flingSpeedLimit)) {
729         flingSpeedLimit = -1.0f;
730     }
731     GetArkUINodeModifiers()->getGridModifier()->setFlingSpeedLimit(nativeNode, flingSpeedLimit);
732     return panda::JSValueRef::Undefined(vm);
733 }
ResetFlingSpeedLimit(ArkUIRuntimeCallInfo * runtimeCallInfo)734 ArkUINativeModuleValue GridBridge::ResetFlingSpeedLimit(ArkUIRuntimeCallInfo* runtimeCallInfo)
735 {
736     EcmaVM* vm = runtimeCallInfo->GetVM();
737     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
738     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
739     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
740     GetArkUINodeModifiers()->getGridModifier()->resetFlingSpeedLimit(nativeNode);
741     return panda::JSValueRef::Undefined(vm);
742 }
SetAlignItems(ArkUIRuntimeCallInfo * runtimeCallInfo)743 ArkUINativeModuleValue GridBridge::SetAlignItems(ArkUIRuntimeCallInfo* runtimeCallInfo)
744 {
745     EcmaVM* vm = runtimeCallInfo->GetVM();
746     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
747     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
748     Local<JSValueRef> arg_alignItems = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
749 
750     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
751     int32_t itemAlignment = static_cast<int32_t>(GridItemAlignment::DEFAULT);
752     if (!arg_alignItems->IsUndefined() && !arg_alignItems->IsNull()) {
753         itemAlignment = arg_alignItems->Int32Value(vm);
754     }
755 
756     if (itemAlignment != static_cast<int32_t>(GridItemAlignment::DEFAULT) &&
757         itemAlignment != static_cast<int32_t>(GridItemAlignment::STRETCH)) {
758         itemAlignment = static_cast<int32_t>(GridItemAlignment::DEFAULT);
759     }
760 
761     GetArkUINodeModifiers()->getGridModifier()->setGridAlignItems(nativeNode, itemAlignment);
762     return panda::JSValueRef::Undefined(vm);
763 }
ResetAlignItems(ArkUIRuntimeCallInfo * runtimeCallInfo)764 ArkUINativeModuleValue GridBridge::ResetAlignItems(ArkUIRuntimeCallInfo* runtimeCallInfo)
765 {
766     EcmaVM* vm = runtimeCallInfo->GetVM();
767     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
768     Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
769     auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
770     GetArkUINodeModifiers()->getGridModifier()->resetGridAlignItems(nativeNode);
771     return panda::JSValueRef::Undefined(vm);
772 }
773 
SetGridScroller(ArkUIRuntimeCallInfo * runtimeCallInfo)774 ArkUINativeModuleValue GridBridge::SetGridScroller(ArkUIRuntimeCallInfo* runtimeCallInfo)
775 {
776     EcmaVM* vm = runtimeCallInfo->GetVM();
777     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
778     Local<JSValueRef> nodeVal = runtimeCallInfo->GetCallArgRef(CALL_ARG_0);
779     Local<JSValueRef> scrollerVal = runtimeCallInfo->GetCallArgRef(CALL_ARG_1);
780     RefPtr<ScrollControllerBase> positionController;
781     RefPtr<ScrollProxy> scrollBarProxy;
782     auto nativeNode = nodePtr(nodeVal->ToNativePointer(vm)->Value());
783     if (scrollerVal->IsObject(vm)) {
784         auto* jsScroller = Framework::JSRef<Framework::JSObject>(Framework::JSObject(scrollerVal->ToObject(vm)))
785                                ->Unwrap<Framework::JSScroller>();
786         if (jsScroller) {
787             jsScroller->SetInstanceId(Container::CurrentIdSafely());
788             positionController = AceType::MakeRefPtr<ScrollableController>();
789             jsScroller->SetController(positionController);
790             scrollBarProxy = jsScroller->GetScrollBarProxy();
791             if (!scrollBarProxy) {
792                 scrollBarProxy = AceType::MakeRefPtr<NG::ScrollBarProxy>();
793                 jsScroller->SetScrollBarProxy(scrollBarProxy);
794             }
795         }
796     }
797     GridModelNG::InitScroller(reinterpret_cast<FrameNode*>(nativeNode), positionController, scrollBarProxy);
798     return panda::JSValueRef::Undefined(vm);
799 }
800 
SetGridLayoutOptions(ArkUIRuntimeCallInfo * runtimeCallInfo)801 ArkUINativeModuleValue GridBridge::SetGridLayoutOptions(ArkUIRuntimeCallInfo* runtimeCallInfo)
802 {
803     EcmaVM* vm = runtimeCallInfo->GetVM();
804     CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
805     Local<JSValueRef> nodeVal = runtimeCallInfo->GetCallArgRef(0);
806     Local<JSValueRef> irregularIndexesVal = runtimeCallInfo->GetCallArgRef(2);
807     Local<JSValueRef> indexesLengthVal = runtimeCallInfo->GetCallArgRef(3);
808     auto nativeNode = nodePtr(nodeVal->ToNativePointer(vm)->Value());
809     int32_t length = 0;
810     if (indexesLengthVal->IsNumber()) {
811         length = indexesLengthVal->Int32Value(vm);
812     }
813     auto irregularIndexes = std::make_unique<int32_t[]>(length);
814     bool irregularResult = ArkTSUtils::ParseArray<int32_t>(vm, irregularIndexesVal, irregularIndexes.get(), length,
815         [](const EcmaVM* vm, const Local<JSValueRef>& jsValue) {
816             bool isNumber = false;
817             return jsValue->GetValueInt32(isNumber);
818         });
819 
820     GridLayoutOptions options;
821     // only support regularSize(1, 1)
822     options.regularSize.rows = 1;
823     options.regularSize.columns = 1;
824     if (irregularResult) {
825         for (int32_t i = 0; i < length; i++) {
826             options.irregularIndexes.emplace(irregularIndexes[i]);
827         }
828     }
829     irregularIndexes.reset();
830     ParseGetGridItemSize(vm, runtimeCallInfo->GetCallArgRef(4), options);
831     ParseGetGridItemRect(vm, runtimeCallInfo->GetCallArgRef(5), options);
832     GridModelNG::SetLayoutOptions(reinterpret_cast<FrameNode*>(nativeNode), options);
833     return panda::JSValueRef::Undefined(vm);
834 }
835 } // namespace OHOS::Ace::NG
836