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_water_flow_bridge.h"
16
17 #include "base/utils/string_utils.h"
18 #include "base/utils/utils.h"
19 #include "bridge/declarative_frontend/jsview/js_scroller.h"
20 #include "bridge/declarative_frontend/jsview/js_water_flow.h"
21 #include "bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h"
22 #include "core/components_ng/pattern/scrollable/scrollable_controller.h"
23 #include "core/components_ng/pattern/waterflow/water_flow_model_ng.h"
24
25 namespace OHOS::Ace::NG {
26 namespace {
27 constexpr double FRICTION_DEFAULT = -1.0;
28 constexpr double DIMENSION_DEFAULT = 0.0;
29 constexpr int32_t DISPLAY_MODE_SIZE = 3;
30 constexpr int32_t NUM_0 = 0;
31 constexpr int32_t NUM_1 = 1;
32 constexpr int32_t NUM_2 = 2;
33 constexpr int32_t NUM_3 = 3;
34 constexpr int32_t NUM_4 = 4;
35 const std::vector<FlexDirection> LAYOUT_DIRECTION = { FlexDirection::ROW, FlexDirection::COLUMN,
36 FlexDirection::ROW_REVERSE, FlexDirection::COLUMN_REVERSE };
37
SetItemConstraintSizeSendParams(CalcDimension & doubleValue,std::string & calcStrValue)38 void SetItemConstraintSizeSendParams(CalcDimension& doubleValue, std::string& calcStrValue)
39 {
40 if (doubleValue.Unit() == DimensionUnit::CALC) {
41 calcStrValue = doubleValue.CalcValue();
42 doubleValue.SetValue(DIMENSION_DEFAULT);
43 }
44 }
45 } // namespace
46
ResetColumnsTemplate(ArkUIRuntimeCallInfo * runtimeCallInfo)47 ArkUINativeModuleValue WaterFlowBridge::ResetColumnsTemplate(ArkUIRuntimeCallInfo* runtimeCallInfo)
48 {
49 EcmaVM* vm = runtimeCallInfo->GetVM();
50 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
51 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
52 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
53 GetArkUINodeModifiers()->getWaterFlowModifier()->resetColumnsTemplate(nativeNode);
54 return panda::JSValueRef::Undefined(vm);
55 }
56
SetColumnsTemplate(ArkUIRuntimeCallInfo * runtimeCallInfo)57 ArkUINativeModuleValue WaterFlowBridge::SetColumnsTemplate(ArkUIRuntimeCallInfo* runtimeCallInfo)
58 {
59 EcmaVM* vm = runtimeCallInfo->GetVM();
60 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
61 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
62 Local<JSValueRef> columnsTemplateArg = runtimeCallInfo->GetCallArgRef(NUM_1);
63 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
64 std::string columnsTemplateValue = columnsTemplateArg->ToString(vm)->ToString(vm);
65 GetArkUINodeModifiers()->getWaterFlowModifier()->setColumnsTemplate(nativeNode, columnsTemplateValue.c_str());
66 return panda::JSValueRef::Undefined(vm);
67 }
68
ResetRowsTemplate(ArkUIRuntimeCallInfo * runtimeCallInfo)69 ArkUINativeModuleValue WaterFlowBridge::ResetRowsTemplate(ArkUIRuntimeCallInfo* runtimeCallInfo)
70 {
71 EcmaVM* vm = runtimeCallInfo->GetVM();
72 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
73 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
74 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
75 GetArkUINodeModifiers()->getWaterFlowModifier()->resetRowsTemplate(nativeNode);
76 return panda::JSValueRef::Undefined(vm);
77 }
78
SetRowsTemplate(ArkUIRuntimeCallInfo * runtimeCallInfo)79 ArkUINativeModuleValue WaterFlowBridge::SetRowsTemplate(ArkUIRuntimeCallInfo* runtimeCallInfo)
80 {
81 EcmaVM* vm = runtimeCallInfo->GetVM();
82 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
83 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
84 Local<JSValueRef> rowsTemplateArg = runtimeCallInfo->GetCallArgRef(NUM_1);
85 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
86 std::string rowsTemplateValue = rowsTemplateArg->ToString(vm)->ToString(vm);
87 GetArkUINodeModifiers()->getWaterFlowModifier()->setRowsTemplate(nativeNode, rowsTemplateValue.c_str());
88 return panda::JSValueRef::Undefined(vm);
89 }
90
SetEnableScrollInteraction(ArkUIRuntimeCallInfo * runtimeCallInfo)91 ArkUINativeModuleValue WaterFlowBridge::SetEnableScrollInteraction(ArkUIRuntimeCallInfo* runtimeCallInfo)
92 {
93 EcmaVM* vm = runtimeCallInfo->GetVM();
94 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
95 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
96 Local<JSValueRef> enableScrollInteractionArg = runtimeCallInfo->GetCallArgRef(NUM_1);
97 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
98 if (enableScrollInteractionArg->IsUndefined() || !enableScrollInteractionArg->IsBoolean()) {
99 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowEnableScrollInteraction(nativeNode, true);
100 return panda::JSValueRef::Undefined(vm);
101 }
102 bool flag = enableScrollInteractionArg->ToBoolean(vm)->Value();
103 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowEnableScrollInteraction(nativeNode, flag);
104 return panda::JSValueRef::Undefined(vm);
105 }
106
ResetEnableScrollInteraction(ArkUIRuntimeCallInfo * runtimeCallInfo)107 ArkUINativeModuleValue WaterFlowBridge::ResetEnableScrollInteraction(ArkUIRuntimeCallInfo* runtimeCallInfo)
108 {
109 EcmaVM* vm = runtimeCallInfo->GetVM();
110 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
111 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
112 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
113 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowEnableScrollInteraction(nativeNode);
114 return panda::JSValueRef::Undefined(vm);
115 }
116
ResetColumnsGap(ArkUIRuntimeCallInfo * runtimeCallInfo)117 ArkUINativeModuleValue WaterFlowBridge::ResetColumnsGap(ArkUIRuntimeCallInfo* runtimeCallInfo)
118 {
119 EcmaVM* vm = runtimeCallInfo->GetVM();
120 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
121 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
122 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
123 GetArkUINodeModifiers()->getWaterFlowModifier()->resetColumnsGap(nativeNode);
124 return panda::JSValueRef::Undefined(vm);
125 }
126
SetColumnsGap(ArkUIRuntimeCallInfo * runtimeCallInfo)127 ArkUINativeModuleValue WaterFlowBridge::SetColumnsGap(ArkUIRuntimeCallInfo* runtimeCallInfo)
128 {
129 EcmaVM* vm = runtimeCallInfo->GetVM();
130 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
131 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
132 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
133 Local<JSValueRef> columnsGapArg = runtimeCallInfo->GetCallArgRef(NUM_1);
134
135 CalcDimension columnsGap;
136 std::string calcStr;
137 if (columnsGapArg->IsUndefined() || !ArkTSUtils::ParseJsDimensionVpNG(vm, columnsGapArg, columnsGap)) {
138 GetArkUINodeModifiers()->getWaterFlowModifier()->resetColumnsGap(nativeNode);
139 } else {
140 if (LessNotEqual(columnsGap.Value(), DIMENSION_DEFAULT)) {
141 columnsGap.SetValue(DIMENSION_DEFAULT);
142 }
143
144 if (columnsGap.Unit() == DimensionUnit::CALC) {
145 GetArkUINodeModifiers()->getWaterFlowModifier()->setColumnsGap(
146 nativeNode, NUM_0, static_cast<int32_t>(columnsGap.Unit()), columnsGap.CalcValue().c_str());
147 } else {
148 GetArkUINodeModifiers()->getWaterFlowModifier()->setColumnsGap(
149 nativeNode, columnsGap.Value(), static_cast<int32_t>(columnsGap.Unit()), calcStr.c_str());
150 }
151 }
152 return panda::JSValueRef::Undefined(vm);
153 }
154
ResetRowsGap(ArkUIRuntimeCallInfo * runtimeCallInfo)155 ArkUINativeModuleValue WaterFlowBridge::ResetRowsGap(ArkUIRuntimeCallInfo* runtimeCallInfo)
156 {
157 EcmaVM* vm = runtimeCallInfo->GetVM();
158 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
159 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
160 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
161 GetArkUINodeModifiers()->getWaterFlowModifier()->resetRowsGap(nativeNode);
162 return panda::JSValueRef::Undefined(vm);
163 }
164
SetRowsGap(ArkUIRuntimeCallInfo * runtimeCallInfo)165 ArkUINativeModuleValue WaterFlowBridge::SetRowsGap(ArkUIRuntimeCallInfo* runtimeCallInfo)
166 {
167 EcmaVM* vm = runtimeCallInfo->GetVM();
168 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
169 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
170 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
171 Local<JSValueRef> rowsGapArg = runtimeCallInfo->GetCallArgRef(NUM_1);
172
173 CalcDimension rowGap;
174 std::string calcStr;
175 if (rowsGapArg->IsUndefined() || !ArkTSUtils::ParseJsDimensionVpNG(vm, rowsGapArg, rowGap)) {
176 GetArkUINodeModifiers()->getWaterFlowModifier()->resetRowsGap(nativeNode);
177 } else {
178 if (LessNotEqual(rowGap.Value(), DIMENSION_DEFAULT)) {
179 rowGap.SetValue(DIMENSION_DEFAULT);
180 }
181 if (rowGap.Unit() == DimensionUnit::CALC) {
182 GetArkUINodeModifiers()->getWaterFlowModifier()->setRowsGap(
183 nativeNode, 0, static_cast<int32_t>(rowGap.Unit()), rowGap.CalcValue().c_str());
184 } else {
185 GetArkUINodeModifiers()->getWaterFlowModifier()->setRowsGap(
186 nativeNode, rowGap.Value(), static_cast<int32_t>(rowGap.Unit()), calcStr.c_str());
187 }
188 }
189 return panda::JSValueRef::Undefined(vm);
190 }
191
SetItemConstraintSize(ArkUIRuntimeCallInfo * runtimeCallInfo)192 ArkUINativeModuleValue WaterFlowBridge::SetItemConstraintSize(ArkUIRuntimeCallInfo* runtimeCallInfo)
193 {
194 EcmaVM* vm = runtimeCallInfo->GetVM();
195 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
196 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
197 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
198 Local<JSValueRef> minWidthValue = runtimeCallInfo->GetCallArgRef(NUM_1);
199 Local<JSValueRef> maxWidthValue = runtimeCallInfo->GetCallArgRef(NUM_2);
200 Local<JSValueRef> minHeightValue = runtimeCallInfo->GetCallArgRef(NUM_3);
201 Local<JSValueRef> maxHeightValue = runtimeCallInfo->GetCallArgRef(NUM_4);
202 CalcDimension minWidth;
203 CalcDimension maxWidth;
204 CalcDimension minHeight;
205 CalcDimension maxHeight;
206 std::string calcMinWidthStr;
207 std::string calcMaxWidthStr;
208 std::string calcMinHeightStr;
209 std::string calcMaxHeightStr;
210 if (minWidthValue->IsUndefined() || !ArkTSUtils::ParseJsDimensionVp(vm, minWidthValue, minWidth, false)) {
211 GetArkUINodeModifiers()->getWaterFlowModifier()->resetItemMinWidth(nativeNode);
212 } else {
213 SetItemConstraintSizeSendParams(minWidth, calcMinWidthStr);
214 GetArkUINodeModifiers()->getWaterFlowModifier()->setItemMinWidth(
215 nativeNode, minWidth.Value(), static_cast<int32_t>(minWidth.Unit()), calcMinWidthStr.c_str());
216 }
217 if (maxWidthValue->IsUndefined() || !ArkTSUtils::ParseJsDimensionVp(vm, maxWidthValue, maxWidth, false)) {
218 GetArkUINodeModifiers()->getWaterFlowModifier()->resetItemMaxWidth(nativeNode);
219 } else {
220 SetItemConstraintSizeSendParams(maxWidth, calcMaxWidthStr);
221 GetArkUINodeModifiers()->getWaterFlowModifier()->setItemMaxWidth(
222 nativeNode, maxWidth.Value(), static_cast<int32_t>(maxWidth.Unit()), calcMaxWidthStr.c_str());
223 }
224 if (minHeightValue->IsUndefined() || !ArkTSUtils::ParseJsDimensionVp(vm, minHeightValue, minHeight, false)) {
225 GetArkUINodeModifiers()->getWaterFlowModifier()->resetItemMinHeight(nativeNode);
226 } else {
227 SetItemConstraintSizeSendParams(minHeight, calcMinHeightStr);
228 GetArkUINodeModifiers()->getWaterFlowModifier()->setItemMinHeight(
229 nativeNode, minHeight.Value(), static_cast<int32_t>(minHeight.Unit()), calcMinHeightStr.c_str());
230 }
231 if (maxHeightValue->IsUndefined() || !ArkTSUtils::ParseJsDimensionVp(vm, maxHeightValue, maxHeight, false)) {
232 GetArkUINodeModifiers()->getWaterFlowModifier()->resetItemMaxHeight(nativeNode);
233 } else {
234 SetItemConstraintSizeSendParams(maxHeight, calcMaxHeightStr);
235 GetArkUINodeModifiers()->getWaterFlowModifier()->setItemMaxHeight(
236 nativeNode, maxHeight.Value(), static_cast<int32_t>(maxHeight.Unit()), calcMaxHeightStr.c_str());
237 }
238 return panda::JSValueRef::Undefined(vm);
239 }
240
ResetItemConstraintSize(ArkUIRuntimeCallInfo * runtimeCallInfo)241 ArkUINativeModuleValue WaterFlowBridge::ResetItemConstraintSize(ArkUIRuntimeCallInfo* runtimeCallInfo)
242 {
243 EcmaVM* vm = runtimeCallInfo->GetVM();
244 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
245 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
246 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
247 GetArkUINodeModifiers()->getWaterFlowModifier()->resetItemMaxHeight(nativeNode);
248 GetArkUINodeModifiers()->getWaterFlowModifier()->resetItemMaxWidth(nativeNode);
249 GetArkUINodeModifiers()->getWaterFlowModifier()->resetItemMinHeight(nativeNode);
250 GetArkUINodeModifiers()->getWaterFlowModifier()->resetItemMinWidth(nativeNode);
251 return panda::JSValueRef::Undefined(vm);
252 }
253
SetLayoutDirection(ArkUIRuntimeCallInfo * runtimeCallInfo)254 ArkUINativeModuleValue WaterFlowBridge::SetLayoutDirection(ArkUIRuntimeCallInfo* runtimeCallInfo)
255 {
256 EcmaVM* vm = runtimeCallInfo->GetVM();
257 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
258 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
259 Local<JSValueRef> layoutDirectionArg = runtimeCallInfo->GetCallArgRef(NUM_1);
260 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
261 auto value = static_cast<int32_t>(FlexDirection::COLUMN);
262 if (!layoutDirectionArg->IsUndefined()) {
263 ArkTSUtils::ParseJsInteger(vm, layoutDirectionArg, value);
264 }
265 if (value >= NUM_0 && value < static_cast<int32_t>(LAYOUT_DIRECTION.size())) {
266 GetArkUINodeModifiers()->getWaterFlowModifier()->setLayoutDirection(nativeNode, value);
267 } else {
268 GetArkUINodeModifiers()->getWaterFlowModifier()->resetLayoutDirection(nativeNode);
269 }
270 return panda::JSValueRef::Undefined(vm);
271 }
272
ResetLayoutDirection(ArkUIRuntimeCallInfo * runtimeCallInfo)273 ArkUINativeModuleValue WaterFlowBridge::ResetLayoutDirection(ArkUIRuntimeCallInfo* runtimeCallInfo)
274 {
275 EcmaVM* vm = runtimeCallInfo->GetVM();
276 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
277 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
278 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
279 GetArkUINodeModifiers()->getWaterFlowModifier()->resetLayoutDirection(nativeNode);
280 return panda::JSValueRef::Undefined(vm);
281 }
282
SetNestedScroll(ArkUIRuntimeCallInfo * runtimeCallInfo)283 ArkUINativeModuleValue WaterFlowBridge::SetNestedScroll(ArkUIRuntimeCallInfo* runtimeCallInfo)
284 {
285 EcmaVM* vm = runtimeCallInfo->GetVM();
286 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
287 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
288 Local<JSValueRef> scrollForwardValue = runtimeCallInfo->GetCallArgRef(NUM_1);
289 Local<JSValueRef> scrollBackwardValue = runtimeCallInfo->GetCallArgRef(NUM_2);
290 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
291 int32_t froward = NUM_0;
292 int32_t backward = NUM_0;
293 ArkTSUtils::ParseJsInteger(vm, scrollForwardValue, froward);
294 if (froward < static_cast<int32_t>(NestedScrollMode::SELF_ONLY) ||
295 froward > static_cast<int32_t>(NestedScrollMode::PARALLEL)) {
296 froward = NUM_0;
297 }
298 ArkTSUtils::ParseJsInteger(vm, scrollBackwardValue, backward);
299 if (backward < static_cast<int32_t>(NestedScrollMode::SELF_ONLY) ||
300 backward > static_cast<int32_t>(NestedScrollMode::PARALLEL)) {
301 backward = NUM_0;
302 }
303 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowNestedScroll(nativeNode, froward, backward);
304 return panda::JSValueRef::Undefined(vm);
305 }
306
ResetNestedScroll(ArkUIRuntimeCallInfo * runtimeCallInfo)307 ArkUINativeModuleValue WaterFlowBridge::ResetNestedScroll(ArkUIRuntimeCallInfo* runtimeCallInfo)
308 {
309 EcmaVM* vm = runtimeCallInfo->GetVM();
310 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
311 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
312 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
313 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowNestedScroll(nativeNode);
314 return panda::JSValueRef::Undefined(vm);
315 }
316
SetFriction(ArkUIRuntimeCallInfo * runtimeCallInfo)317 ArkUINativeModuleValue WaterFlowBridge::SetFriction(ArkUIRuntimeCallInfo *runtimeCallInfo)
318 {
319 EcmaVM *vm = runtimeCallInfo->GetVM();
320 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
321 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
322 Local<JSValueRef> frictionArg = runtimeCallInfo->GetCallArgRef(NUM_1);
323 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
324 double friction = FRICTION_DEFAULT;
325 if (!ArkTSUtils::ParseJsDouble(vm, frictionArg, friction)) {
326 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowFriction(nativeNode);
327 } else {
328 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowFriction(nativeNode,
329 static_cast<ArkUI_Float32>(friction));
330 }
331 return panda::JSValueRef::Undefined(vm);
332 }
333
ResetFriction(ArkUIRuntimeCallInfo * runtimeCallInfo)334 ArkUINativeModuleValue WaterFlowBridge::ResetFriction(ArkUIRuntimeCallInfo *runtimeCallInfo)
335 {
336 EcmaVM *vm = runtimeCallInfo->GetVM();
337 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
338 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
339 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
340 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowFriction(nativeNode);
341 return panda::JSValueRef::Undefined(vm);
342 }
343
SetEdgeEffect(ArkUIRuntimeCallInfo * runtimeCallInfo)344 ArkUINativeModuleValue WaterFlowBridge::SetEdgeEffect(ArkUIRuntimeCallInfo* runtimeCallInfo)
345 {
346 EcmaVM* vm = runtimeCallInfo->GetVM();
347 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
348 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
349 Local<JSValueRef> argEdgeEffect = runtimeCallInfo->GetCallArgRef(NUM_1);
350 Local<JSValueRef> argEdgeEffectOptions = runtimeCallInfo->GetCallArgRef(NUM_2);
351
352 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
353 int32_t effect = static_cast<int32_t>(EdgeEffect::NONE);
354 if (!argEdgeEffect->IsUndefined() && !argEdgeEffect->IsNull()) {
355 effect = argEdgeEffect->Int32Value(vm);
356 }
357
358 if (effect != static_cast<int32_t>(EdgeEffect::SPRING) && effect != static_cast<int32_t>(EdgeEffect::NONE) &&
359 effect != static_cast<int32_t>(EdgeEffect::FADE)) {
360 effect = static_cast<int32_t>(EdgeEffect::NONE);
361 }
362
363 if (argEdgeEffectOptions->IsNull() || argEdgeEffectOptions->IsUndefined()) {
364 GetArkUINodeModifiers()->getWaterFlowModifier()->setEdgeEffect(nativeNode, effect, false);
365 } else {
366 GetArkUINodeModifiers()->getWaterFlowModifier()->setEdgeEffect(
367 nativeNode, effect, argEdgeEffectOptions->ToBoolean(vm)->Value());
368 }
369 return panda::JSValueRef::Undefined(vm);
370 }
371
ResetEdgeEffect(ArkUIRuntimeCallInfo * runtimeCallInfo)372 ArkUINativeModuleValue WaterFlowBridge::ResetEdgeEffect(ArkUIRuntimeCallInfo* runtimeCallInfo)
373 {
374 EcmaVM* vm = runtimeCallInfo->GetVM();
375 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
376 Local<JSValueRef> node = runtimeCallInfo->GetCallArgRef(NUM_0);
377 auto nativeNode = nodePtr(node->ToNativePointer(vm)->Value());
378 GetArkUINodeModifiers()->getWaterFlowModifier()->resetEdgeEffect(nativeNode);
379 return panda::JSValueRef::Undefined(vm);
380 }
381
SetScrollBar(ArkUIRuntimeCallInfo * runtimeCallInfo)382 ArkUINativeModuleValue WaterFlowBridge::SetScrollBar(ArkUIRuntimeCallInfo* runtimeCallInfo)
383 {
384 EcmaVM* vm = runtimeCallInfo->GetVM();
385 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
386 Local<JSValueRef> firstArg = runtimeCallInfo->GetCallArgRef(NUM_0);
387 Local<JSValueRef> secondArg = runtimeCallInfo->GetCallArgRef(NUM_1);
388 auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value());
389 int32_t barState = 0;
390 if (!ArkTSUtils::ParseJsInteger(vm, secondArg, barState) || barState < 0 || barState >= DISPLAY_MODE_SIZE) {
391 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBar(nativeNode);
392 } else {
393 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowScrollBar(nativeNode, barState);
394 }
395 return panda::JSValueRef::Undefined(vm);
396 }
397
ResetScrollBar(ArkUIRuntimeCallInfo * runtimeCallInfo)398 ArkUINativeModuleValue WaterFlowBridge::ResetScrollBar(ArkUIRuntimeCallInfo* runtimeCallInfo)
399 {
400 EcmaVM* vm = runtimeCallInfo->GetVM();
401 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
402 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
403 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
404 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBar(nativeNode);
405 return panda::JSValueRef::Undefined(vm);
406 }
407
SetScrollBarWidth(ArkUIRuntimeCallInfo * runtimeCallInfo)408 ArkUINativeModuleValue WaterFlowBridge::SetScrollBarWidth(ArkUIRuntimeCallInfo* runtimeCallInfo)
409 {
410 EcmaVM* vm = runtimeCallInfo->GetVM();
411 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
412 Local<JSValueRef> nativeNodeArg = runtimeCallInfo->GetCallArgRef(NUM_0);
413 Local<JSValueRef> scrollBarArg = runtimeCallInfo->GetCallArgRef(NUM_1);
414 auto nativeNode = nodePtr(nativeNodeArg->ToNativePointer(vm)->Value());
415
416 CalcDimension scrollBarWidth;
417 if (!ArkTSUtils::ParseJsDimension(vm, scrollBarArg, scrollBarWidth, DimensionUnit::VP) || scrollBarArg->IsNull() ||
418 scrollBarArg->IsUndefined() || (scrollBarArg->IsString(vm) && scrollBarWidth.ToString().empty()) ||
419 LessNotEqual(scrollBarWidth.Value(), 0.0) || scrollBarWidth.Unit() == DimensionUnit::PERCENT) {
420 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBarWidth(nativeNode);
421 } else {
422 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowScrollBarWidth(
423 nativeNode, scrollBarWidth.ToString().c_str());
424 }
425 return panda::JSValueRef::Undefined(vm);
426 }
427
ResetScrollBarWidth(ArkUIRuntimeCallInfo * runtimeCallInfo)428 ArkUINativeModuleValue WaterFlowBridge::ResetScrollBarWidth(ArkUIRuntimeCallInfo* runtimeCallInfo)
429 {
430 EcmaVM* vm = runtimeCallInfo->GetVM();
431 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
432 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
433 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
434 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBarWidth(nativeNode);
435 return panda::JSValueRef::Undefined(vm);
436 }
437
SetScrollBarColor(ArkUIRuntimeCallInfo * runtimeCallInfo)438 ArkUINativeModuleValue WaterFlowBridge::SetScrollBarColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
439 {
440 EcmaVM* vm = runtimeCallInfo->GetVM();
441 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
442 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
443 Local<JSValueRef> argColor = runtimeCallInfo->GetCallArgRef(NUM_1);
444 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
445 std::string color = "";
446 if (!ArkTSUtils::ParseJsString(vm, argColor, color) || argColor->IsUndefined() || color.empty()) {
447 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBarColor(nativeNode);
448 } else {
449 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowScrollBarColor(nativeNode, color.c_str());
450 }
451 return panda::JSValueRef::Undefined(vm);
452 }
453
ResetScrollBarColor(ArkUIRuntimeCallInfo * runtimeCallInfo)454 ArkUINativeModuleValue WaterFlowBridge::ResetScrollBarColor(ArkUIRuntimeCallInfo* runtimeCallInfo)
455 {
456 EcmaVM* vm = runtimeCallInfo->GetVM();
457 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
458 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
459 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
460 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBarColor(nativeNode);
461 return panda::JSValueRef::Undefined(vm);
462 }
463
SetCachedCount(ArkUIRuntimeCallInfo * runtimeCallInfo)464 ArkUINativeModuleValue WaterFlowBridge::SetCachedCount(ArkUIRuntimeCallInfo* runtimeCallInfo)
465 {
466 EcmaVM* vm = runtimeCallInfo->GetVM();
467 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
468 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
469 Local<JSValueRef> argCachedCount = runtimeCallInfo->GetCallArgRef(NUM_1);
470 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
471 int32_t cachedCount = 0;
472 if (!ArkTSUtils::ParseJsInteger(vm, argCachedCount, cachedCount) || cachedCount < 0) {
473 GetArkUINodeModifiers()->getWaterFlowModifier()->resetCachedCount(nativeNode);
474 } else {
475 GetArkUINodeModifiers()->getWaterFlowModifier()->setCachedCount(nativeNode, cachedCount);
476 }
477 return panda::JSValueRef::Undefined(vm);
478 }
479
ResetCachedCount(ArkUIRuntimeCallInfo * runtimeCallInfo)480 ArkUINativeModuleValue WaterFlowBridge::ResetCachedCount(ArkUIRuntimeCallInfo* runtimeCallInfo)
481 {
482 EcmaVM* vm = runtimeCallInfo->GetVM();
483 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
484 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
485 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
486 GetArkUINodeModifiers()->getWaterFlowModifier()->resetCachedCount(nativeNode);
487 return panda::JSValueRef::Undefined(vm);
488 }
489
SetFlingSpeedLimit(ArkUIRuntimeCallInfo * runtimeCallInfo)490 ArkUINativeModuleValue WaterFlowBridge::SetFlingSpeedLimit(ArkUIRuntimeCallInfo* runtimeCallInfo)
491 {
492 EcmaVM* vm = runtimeCallInfo->GetVM();
493 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
494 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
495 Local<JSValueRef> argSpeed = runtimeCallInfo->GetCallArgRef(NUM_1);
496 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
497 double limitSpeed = -1.0;
498 if (!ArkTSUtils::ParseJsDouble(vm, argSpeed, limitSpeed)) {
499 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowFlingSpeedLimit(nativeNode);
500 } else {
501 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowFlingSpeedLimit(
502 nativeNode, static_cast<ArkUI_Float32>(limitSpeed));
503 }
504 return panda::JSValueRef::Undefined(vm);
505 }
506
ResetFlingSpeedLimit(ArkUIRuntimeCallInfo * runtimeCallInfo)507 ArkUINativeModuleValue WaterFlowBridge::ResetFlingSpeedLimit(ArkUIRuntimeCallInfo* runtimeCallInfo)
508 {
509 EcmaVM* vm = runtimeCallInfo->GetVM();
510 CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr));
511 Local<JSValueRef> argNode = runtimeCallInfo->GetCallArgRef(NUM_0);
512 auto nativeNode = nodePtr(argNode->ToNativePointer(vm)->Value());
513 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowFlingSpeedLimit(nativeNode);
514 return panda::JSValueRef::Undefined(vm);
515 }
516
SetWaterFlowScroller(ArkUIRuntimeCallInfo * runtimeCallInfo)517 void SetWaterFlowScroller(ArkUIRuntimeCallInfo* runtimeCallInfo)
518 {
519 EcmaVM* vm = runtimeCallInfo->GetVM();
520 CHECK_NULL_VOID(vm);
521 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
522 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
523
524 Framework::JsiCallbackInfo info = Framework::JsiCallbackInfo(runtimeCallInfo);
525 if (!info[1]->IsNull() && info[1]->IsObject()) {
526 Framework::JSScroller* jsScroller =
527 Framework::JSRef<Framework::JSObject>::Cast(info[1])->Unwrap<Framework::JSScroller>();
528 if (jsScroller) {
529 jsScroller->SetInstanceId(Container::CurrentId());
530 auto positionController = GetArkUINodeModifiers()->getWaterFlowModifier()->getScrollController(nativeNode);
531 auto nodePositionController =
532 AceType::Claim(reinterpret_cast<OHOS::Ace::ScrollControllerBase*>(positionController));
533 jsScroller->SetController(nodePositionController);
534 // Init scroll bar proxy.
535 auto proxy = jsScroller->GetScrollBarProxy();
536 if (!proxy) {
537 proxy = WaterFlowModel::GetInstance()->CreateScrollBarProxy();
538 jsScroller->SetScrollBarProxy(proxy);
539 }
540 auto proxyPtr = reinterpret_cast<ArkUINodeHandle>(AceType::RawPtr(proxy));
541 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowScroller(
542 nativeNode, positionController, proxyPtr);
543 }
544 } else {
545 auto positionController = AceType::MakeRefPtr<ScrollableController>();
546 auto controller = reinterpret_cast<ArkUINodeHandle>(AceType::RawPtr(positionController));
547 auto proxy = WaterFlowModel::GetInstance()->CreateScrollBarProxy();
548 auto proxyPtr = reinterpret_cast<ArkUINodeHandle>(AceType::RawPtr(proxy));
549 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowScroller(
550 nativeNode, controller, proxyPtr);
551 }
552 }
553
SetWaterFlowSections(ArkUIRuntimeCallInfo * runtimeCallInfo)554 void SetWaterFlowSections(ArkUIRuntimeCallInfo* runtimeCallInfo)
555 {
556 EcmaVM* vm = runtimeCallInfo->GetVM();
557 CHECK_NULL_VOID(vm);
558 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
559 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
560 Framework::JsiCallbackInfo info = Framework::JsiCallbackInfo(runtimeCallInfo);
561 Framework::JSRef<Framework::JSVal> sectionsArgs = info[2]; //2 is the index of sections
562 if (!sectionsArgs->IsNull() && sectionsArgs->IsObject()) {
563 auto* frameNode = reinterpret_cast<FrameNode*>(nativeNode);
564 Framework::JSWaterFlow::UpdateWaterFlowSectionsByFrameNode(frameNode, info, sectionsArgs);
565 } else {
566 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowSections(nativeNode);
567 }
568 }
569
SetWaterFlowInitialize(ArkUIRuntimeCallInfo * runtimeCallInfo)570 ArkUINativeModuleValue WaterFlowBridge::SetWaterFlowInitialize(ArkUIRuntimeCallInfo* runtimeCallInfo)
571 {
572 EcmaVM* vm = runtimeCallInfo->GetVM();
573 CHECK_NULL_RETURN(vm, panda::JSValueRef::Undefined(vm));
574 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
575 Local<JSValueRef> layoutModeArgs = runtimeCallInfo->GetCallArgRef(3); //3 is the index of layoutMode
576 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
577
578 SetWaterFlowScroller(runtimeCallInfo);
579
580 if (layoutModeArgs->IsUndefined() || layoutModeArgs->IsNull() || !layoutModeArgs->IsNumber()) {
581 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowLayoutMode(nativeNode);
582 SetWaterFlowSections(runtimeCallInfo);
583 } else {
584 uint32_t layoutMode = layoutModeArgs->Uint32Value(vm);
585 if (layoutMode < static_cast<uint32_t>(NG::WaterFlowLayoutMode::TOP_DOWN) ||
586 layoutMode > static_cast<uint32_t>(NG::WaterFlowLayoutMode::SLIDING_WINDOW)) {
587 layoutMode = static_cast<uint32_t>(NG::WaterFlowLayoutMode::TOP_DOWN);
588 }
589 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowLayoutMode(nativeNode, layoutMode);
590 if (layoutMode != static_cast<uint32_t>(NG::WaterFlowLayoutMode::SLIDING_WINDOW)) {
591 SetWaterFlowSections(runtimeCallInfo);
592 }
593 }
594
595 return panda::JSValueRef::Undefined(vm);
596 }
597
ResetWaterFlowInitialize(ArkUIRuntimeCallInfo * runtimeCallInfo)598 ArkUINativeModuleValue WaterFlowBridge::ResetWaterFlowInitialize(ArkUIRuntimeCallInfo* runtimeCallInfo)
599 {
600 EcmaVM* vm = runtimeCallInfo->GetVM();
601 CHECK_NULL_RETURN(vm, panda::JSValueRef::Undefined(vm));
602 Local<JSValueRef> nodeArg = runtimeCallInfo->GetCallArgRef(0);
603 auto nativeNode = nodePtr(nodeArg->ToNativePointer(vm)->Value());
604
605 auto positionController = AceType::MakeRefPtr<ScrollableController>();
606 auto controller = reinterpret_cast<ArkUINodeHandle>(AceType::RawPtr(positionController));
607 auto proxy = WaterFlowModel::GetInstance()->CreateScrollBarProxy();
608 auto proxyPtr = reinterpret_cast<ArkUINodeHandle>(OHOS::Ace::AceType::RawPtr(proxy));
609 GetArkUINodeModifiers()->getWaterFlowModifier()->setWaterFlowScroller(
610 nativeNode, controller, proxyPtr);
611 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowSections(nativeNode);
612 GetArkUINodeModifiers()->getWaterFlowModifier()->resetWaterFlowLayoutMode(nativeNode);
613 return panda::JSValueRef::Undefined(vm);
614 }
615 } // namespace OHOS::Ace::NG