1 /*
2 * Copyright (c) 2021-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
16 #include "bridge/declarative_frontend/jsview/js_grid.h"
17
18 #include "interfaces/inner_api/ui_session/ui_session_manager.h"
19
20 #include "base/log/ace_scoring_log.h"
21 #include "base/utils/utils.h"
22 #include "bridge/declarative_frontend/engine/functions/js_drag_function.h"
23 #include "bridge/declarative_frontend/jsview/js_interactable_view.h"
24 #include "bridge/declarative_frontend/jsview/js_scrollable.h"
25 #include "bridge/declarative_frontend/jsview/js_scroller.h"
26 #include "bridge/declarative_frontend/jsview/js_view_common_def.h"
27 #include "bridge/declarative_frontend/jsview/models/grid_model_impl.h"
28 #include "core/common/ace_application_info.h"
29 #include "core/common/container.h"
30 #include "core/components_ng/base/view_stack_model.h"
31 #include "core/components_ng/base/view_stack_processor.h"
32 #include "core/components_ng/pattern/grid/grid_model_ng.h"
33
34 namespace OHOS::Ace {
35
36 std::unique_ptr<GridModel> GridModel::instance_ = nullptr;
37 std::mutex GridModel::mutex_;
38
GetInstance()39 GridModel* GridModel::GetInstance()
40 {
41 if (!instance_) {
42 std::lock_guard<std::mutex> lock(mutex_);
43 if (!instance_) {
44 #ifdef NG_BUILD
45 instance_.reset(new NG::GridModelNG());
46 #else
47 if (Container::IsCurrentUseNewPipeline()) {
48 instance_.reset(new NG::GridModelNG());
49 } else {
50 instance_.reset(new Framework::GridModelImpl());
51 }
52 #endif
53 }
54 }
55 return instance_.get();
56 }
57
58 } // namespace OHOS::Ace
59
60 namespace OHOS::Ace::Framework {
61 namespace {
62 const std::vector<DisplayMode> DISPLAY_MODE = { DisplayMode::OFF, DisplayMode::AUTO, DisplayMode::ON };
63 const std::vector<EdgeEffect> EDGE_EFFECT = { EdgeEffect::SPRING, EdgeEffect::FADE, EdgeEffect::NONE };
64 const std::vector<FlexDirection> LAYOUT_DIRECTION = { FlexDirection::ROW, FlexDirection::COLUMN,
65 FlexDirection::ROW_REVERSE, FlexDirection::COLUMN_REVERSE };
66 const size_t GRID_ITEM_SIZE_RESULT_LENGTH = 2;
67 const size_t GRID_ITEM_RECT_RESULT_LENGTH = 4;
68
ParseGridItemSize(const JSRef<JSVal> & value,GridItemSize & gridItemSize)69 void ParseGridItemSize(const JSRef<JSVal>& value, GridItemSize& gridItemSize)
70 {
71 if (value->IsArray()) {
72 JSRef<JSArray> array = JSRef<JSArray>::Cast(value);
73 auto length = array->Length();
74 if (length != GRID_ITEM_SIZE_RESULT_LENGTH) {
75 return;
76 }
77 JSRef<JSVal> rows = array->GetValueAt(0);
78 if (rows->IsNumber()) {
79 gridItemSize.rows = rows->ToNumber<int32_t>();
80 }
81 JSRef<JSVal> columns = array->GetValueAt(1);
82 if (columns->IsNumber()) {
83 gridItemSize.columns = columns->ToNumber<int32_t>();
84 }
85 }
86 }
87
ParseGridItemRect(const JSRef<JSVal> & value,GridItemRect & gridItemRect)88 void ParseGridItemRect(const JSRef<JSVal>& value, GridItemRect& gridItemRect)
89 {
90 if (value->IsArray()) {
91 JSRef<JSArray> array = JSRef<JSArray>::Cast(value);
92 auto length = array->Length();
93 if (length != GRID_ITEM_RECT_RESULT_LENGTH) {
94 return;
95 }
96 JSRef<JSVal> rowStart = array->GetValueAt(GridItemRect::ROW_START);
97 if (rowStart->IsNumber()) {
98 gridItemRect.rowStart = rowStart->ToNumber<int32_t>();
99 }
100 JSRef<JSVal> rowSpan = array->GetValueAt(GridItemRect::ROW_SPAN);
101 if (rowSpan->IsNumber()) {
102 gridItemRect.rowSpan = rowSpan->ToNumber<int32_t>();
103 }
104 JSRef<JSVal> columnStart = array->GetValueAt(GridItemRect::COLUMN_START);
105 if (columnStart->IsNumber()) {
106 gridItemRect.columnStart = columnStart->ToNumber<int32_t>();
107 }
108 JSRef<JSVal> columnSpan = array->GetValueAt(GridItemRect::COLUMN_SPAN);
109 if (columnSpan->IsNumber()) {
110 gridItemRect.columnSpan = columnSpan->ToNumber<int32_t>();
111 }
112 }
113 }
114
ParseGetGridItemSize(const JSCallbackInfo & info,JSRef<JSObject> & obj,GridLayoutOptions & option)115 void ParseGetGridItemSize(const JSCallbackInfo& info, JSRef<JSObject>& obj, GridLayoutOptions& option)
116 {
117 auto getSizeByIndex = obj->GetProperty("onGetIrregularSizeByIndex");
118 if (getSizeByIndex->IsFunction()) {
119 auto onGetIrregularSizeByIndex = [execCtx = info.GetExecutionContext(),
120 func = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(),
121 JSRef<JSFunc>::Cast(getSizeByIndex))](int32_t index) {
122 JAVASCRIPT_EXECUTION_SCOPE(execCtx);
123 GridItemSize gridItemSize;
124 JSRef<JSVal> itemIndex = JSRef<JSVal>::Make(ToJSValue(index));
125 auto result = func->ExecuteJS(1, &itemIndex);
126 if (!result->IsArray()) {
127 return gridItemSize;
128 }
129 ParseGridItemSize(result, gridItemSize);
130 return gridItemSize;
131 };
132 option.getSizeByIndex = std::move(onGetIrregularSizeByIndex);
133 }
134 }
135
ParseGetGridItemRect(const JSCallbackInfo & info,JSRef<JSObject> & obj,GridLayoutOptions & option)136 void ParseGetGridItemRect(const JSCallbackInfo& info, JSRef<JSObject>& obj, GridLayoutOptions& option)
137 {
138 auto getRectByIndex = obj->GetProperty("onGetRectByIndex");
139 if (getRectByIndex->IsFunction()) {
140 auto onGetRectByIndex = [execCtx = info.GetExecutionContext(),
141 func = AceType::MakeRefPtr<JsFunction>(
142 JSRef<JSObject>(), JSRef<JSFunc>::Cast(getRectByIndex))](int32_t index) {
143 JAVASCRIPT_EXECUTION_SCOPE(execCtx);
144 GridItemRect gridItemRect;
145 JSRef<JSVal> itemIndex = JSRef<JSVal>::Make(ToJSValue(index));
146 auto result = func->ExecuteJS(1, &itemIndex);
147 if (!result->IsArray()) {
148 return gridItemRect;
149 }
150 ParseGridItemRect(result, gridItemRect);
151 return gridItemRect;
152 };
153 option.getRectByIndex = std::move(onGetRectByIndex);
154 }
155 }
156
SetGridLayoutOptions(const JSCallbackInfo & info)157 void SetGridLayoutOptions(const JSCallbackInfo& info)
158 {
159 if (!(info.Length() > 1 && info[1]->IsObject())) {
160 return;
161 }
162 GridLayoutOptions option;
163 auto obj = JSRef<JSObject>::Cast(info[1]);
164 auto value = obj->GetProperty("regularSize");
165 ParseGridItemSize(value, option.regularSize);
166
167 // only support regularSize(1, 1)
168 option.regularSize.rows = 1;
169 option.regularSize.columns = 1;
170
171 auto indexes = obj->GetProperty("irregularIndexes");
172 if (indexes->IsArray()) {
173 JSRef<JSArray> array = JSRef<JSArray>::Cast(indexes);
174 auto length = array->Length();
175 for (size_t i = 0; i < length; i++) {
176 JSRef<JSVal> index = array->GetValueAt(i);
177 if (!index->IsNumber()) {
178 continue;
179 }
180 auto indexNum = index->ToNumber<int32_t>();
181 if (indexNum >= 0) {
182 option.irregularIndexes.emplace(indexNum);
183 }
184 }
185 }
186
187 ParseGetGridItemSize(info, obj, option);
188 ParseGetGridItemRect(info, obj, option);
189
190 GridModel::GetInstance()->SetLayoutOptions(option);
191 }
192
JsOnScrollToIndex(const JSCallbackInfo & info)193 void JsOnScrollToIndex(const JSCallbackInfo& info)
194 {
195 if (!info[0]->IsFunction()) {
196 return;
197 }
198
199 auto onScrollIndex = [execCtx = info.GetExecutionContext(), func = JSRef<JSFunc>::Cast(info[0])](
200 const BaseEventInfo* event) {
201 JAVASCRIPT_EXECUTION_SCOPE(execCtx);
202 const auto* eventInfo = TypeInfoHelper::DynamicCast<V2::GridEventInfo>(event);
203 if (!eventInfo) {
204 return;
205 }
206 auto params = ConvertToJSValues(eventInfo->GetScrollIndex());
207 func->Call(JSRef<JSObject>(), static_cast<int>(params.size()), params.data());
208 };
209 GridModel::GetInstance()->SetOnScrollToIndex(std::move(onScrollIndex));
210 }
211 } // namespace
212
Create(const JSCallbackInfo & info)213 void JSGrid::Create(const JSCallbackInfo& info)
214 {
215 RefPtr<ScrollControllerBase> positionController;
216 RefPtr<ScrollProxy> scrollBarProxy;
217 if (info.Length() > 0 && info[0]->IsObject()) {
218 JSScroller* jsScroller = JSRef<JSObject>::Cast(info[0])->Unwrap<JSScroller>();
219 if (jsScroller) {
220 jsScroller->SetInstanceId(Container::CurrentId());
221 positionController = GridModel::GetInstance()->CreatePositionController();
222 jsScroller->SetController(positionController);
223
224 // Init scroll bar proxy.
225 scrollBarProxy = jsScroller->GetScrollBarProxy();
226 if (!scrollBarProxy) {
227 scrollBarProxy = GridModel::GetInstance()->CreateScrollBarProxy();
228 jsScroller->SetScrollBarProxy(scrollBarProxy);
229 }
230 }
231 }
232 GridModel::GetInstance()->Create(positionController, scrollBarProxy);
233
234 SetGridLayoutOptions(info);
235 }
236
PopGrid()237 void JSGrid::PopGrid()
238 {
239 if (ViewStackModel::GetInstance()->IsPrebuilding()) {
240 return ViewStackModel::GetInstance()->PushPrebuildCompCmd("[JSGrid][pop]", &JSGrid::PopGrid);
241 }
242 GridModel::GetInstance()->Pop();
243 }
244
UseProxy(const JSCallbackInfo & args)245 void JSGrid::UseProxy(const JSCallbackInfo& args)
246 {
247 #ifdef NG_BUILD
248 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(false)));
249 #else
250 auto parentGrid = ViewStackProcessor::GetInstance()->GetTopGrid();
251
252 // return true if code path for GridElement and its children will rely on
253 // ElementProxy. Only in this case shallow render functionality can be used
254 // see also GridLayoutComponent::CreateElement() and GridItemElementProxy class
255 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(parentGrid ? !parentGrid->UseNonProxiedCodePath() : false)));
256 #endif
257 }
258
SetColumnsTemplate(const std::string & value)259 void JSGrid::SetColumnsTemplate(const std::string& value)
260 {
261 GridModel::GetInstance()->SetColumnsTemplate(value);
262 }
263
SetRowsTemplate(const std::string & value)264 void JSGrid::SetRowsTemplate(const std::string& value)
265 {
266 GridModel::GetInstance()->SetRowsTemplate(value);
267 }
268
SetColumnsGap(const JSCallbackInfo & info)269 void JSGrid::SetColumnsGap(const JSCallbackInfo& info)
270 {
271 if (info.Length() < 1) {
272 return;
273 }
274 CalcDimension colGap;
275
276 if (!ParseJsDimensionVp(info[0], colGap) || colGap.Value() < 0) {
277 colGap.SetValue(0.0);
278 }
279
280 GridModel::GetInstance()->SetColumnsGap(colGap);
281 }
282
SetRowsGap(const JSCallbackInfo & info)283 void JSGrid::SetRowsGap(const JSCallbackInfo& info)
284 {
285 if (info.Length() < 1) {
286 return;
287 }
288 CalcDimension rowGap;
289
290 if (!ParseJsDimensionVp(info[0], rowGap) || rowGap.Value() < 0) {
291 rowGap.SetValue(0.0);
292 }
293
294 GridModel::GetInstance()->SetRowsGap(rowGap);
295 }
296
JsGridHeight(const JSCallbackInfo & info)297 void JSGrid::JsGridHeight(const JSCallbackInfo& info)
298 {
299 if (info.Length() < 1) {
300 return;
301 }
302
303 CalcDimension value;
304 if (!ParseJsDimensionVp(info[0], value)) {
305 return;
306 }
307 if (LessNotEqual(value.Value(), 0.0)) {
308 value.SetValue(0.0);
309 }
310 GridModel::GetInstance()->SetGridHeight(value);
311 }
312
JsOnScrollBarUpdate(const JSCallbackInfo & info)313 void JSGrid::JsOnScrollBarUpdate(const JSCallbackInfo& info)
314 {
315 if (!info[0]->IsFunction()) {
316 return;
317 }
318 auto onScrollBarUpdate = [execCtx = info.GetExecutionContext(),
319 func = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(),
320 JSRef<JSFunc>::Cast(info[0]))](int32_t index, const Dimension& offset) {
321 JSRef<JSVal> itemIndex = JSRef<JSVal>::Make(ToJSValue(index));
322 JSRef<JSVal> itemOffset = ConvertToJSValue(offset);
323 JSRef<JSVal> params[2] = { itemIndex, itemOffset };
324 auto result = func->ExecuteJS(2, params);
325 if (result->IsObject()) {
326 JSRef<JSObject> obj = JSRef<JSObject>::Cast(result);
327
328 Dimension totalOffset_;
329 Dimension totalLength_;
330 if (!ConvertFromJSValue(obj->GetProperty("totalOffset"), totalOffset_) ||
331 !ConvertFromJSValue(obj->GetProperty("totalLength"), totalLength_)) {
332 return std::pair<float, float>(0, 0);
333 } else {
334 return std::pair<float, float>(totalOffset_.ConvertToPx(), totalLength_.ConvertToPx());
335 }
336 }
337 return std::pair<float, float>(0, 0);
338 };
339 GridModel::GetInstance()->SetOnScrollBarUpdate(std::move(onScrollBarUpdate));
340 }
341
SetScrollEnabled(const JSCallbackInfo & args)342 void JSGrid::SetScrollEnabled(const JSCallbackInfo& args)
343 {
344 GridModel::GetInstance()->SetScrollEnabled(args[0]->IsBoolean() ? args[0]->ToBoolean() : true);
345 }
346
JSBind(BindingTarget globalObj)347 void JSGrid::JSBind(BindingTarget globalObj)
348 {
349 JSClass<JSGrid>::Declare("Grid");
350
351 MethodOptions opt = MethodOptions::NONE;
352 JSClass<JSGrid>::StaticMethod("create", &JSGrid::Create, opt);
353 JSClass<JSGrid>::StaticMethod("pop", &JSGrid::PopGrid, opt);
354 JSClass<JSGrid>::StaticMethod("willUseProxy", &JSGrid::UseProxy, opt);
355 JSClass<JSGrid>::StaticMethod("columnsTemplate", &JSGrid::SetColumnsTemplate, opt);
356 JSClass<JSGrid>::StaticMethod("rowsTemplate", &JSGrid::SetRowsTemplate, opt);
357 JSClass<JSGrid>::StaticMethod("columnsGap", &JSGrid::SetColumnsGap, opt);
358 JSClass<JSGrid>::StaticMethod("rowsGap", &JSGrid::SetRowsGap, opt);
359 JSClass<JSGrid>::StaticMethod("onClick", &JSInteractableView::JsOnClick);
360 JSClass<JSGrid>::StaticMethod("onAttach", &JSInteractableView::JsOnAttach);
361 JSClass<JSGrid>::StaticMethod("onAppear", &JSInteractableView::JsOnAppear);
362 JSClass<JSGrid>::StaticMethod("onDetach", &JSInteractableView::JsOnDetach);
363 JSClass<JSGrid>::StaticMethod("onDisAppear", &JSInteractableView::JsOnDisAppear);
364 JSClass<JSGrid>::StaticMethod("onTouch", &JSInteractableView::JsOnTouch);
365 JSClass<JSGrid>::StaticMethod("onHover", &JSInteractableView::JsOnHover);
366 JSClass<JSGrid>::StaticMethod("onKeyEvent", &JSInteractableView::JsOnKey);
367 JSClass<JSGrid>::StaticMethod("onDeleteEvent", &JSInteractableView::JsOnDelete);
368 JSClass<JSGrid>::StaticMethod("scrollBar", &JSGrid::SetScrollBar, opt);
369 JSClass<JSGrid>::StaticMethod("scrollBarWidth", &JSGrid::SetScrollBarWidth, opt);
370 JSClass<JSGrid>::StaticMethod("scrollBarColor", &JSGrid::SetScrollBarColor, opt);
371 JSClass<JSGrid>::StaticMethod("clip", &JSScrollable::JsClip);
372
373 JSClass<JSGrid>::StaticMethod("onScrollBarUpdate", &JSGrid::JsOnScrollBarUpdate);
374 JSClass<JSGrid>::StaticMethod("cachedCount", &JSGrid::SetCachedCount);
375 JSClass<JSGrid>::StaticMethod("editMode", &JSGrid::SetEditMode, opt);
376 JSClass<JSGrid>::StaticMethod("multiSelectable", &JSGrid::SetMultiSelectable, opt);
377 JSClass<JSGrid>::StaticMethod("maxCount", &JSGrid::SetMaxCount, opt);
378 JSClass<JSGrid>::StaticMethod("minCount", &JSGrid::SetMinCount, opt);
379 JSClass<JSGrid>::StaticMethod("cellLength", &JSGrid::CellLength, opt);
380 JSClass<JSGrid>::StaticMethod("layoutDirection", &JSGrid::SetLayoutDirection, opt);
381 JSClass<JSGrid>::StaticMethod("dragAnimation", &JSGrid::SetDragAnimation, opt);
382 JSClass<JSGrid>::StaticMethod("edgeEffect", &JSGrid::SetEdgeEffect, opt);
383 JSClass<JSGrid>::StaticMethod("direction", &JSGrid::SetDirection, opt);
384 JSClass<JSGrid>::StaticMethod("supportAnimation", &JSGrid::SetSupportAnimation, opt);
385 JSClass<JSGrid>::StaticMethod("onItemDragEnter", &JSGrid::JsOnGridDragEnter);
386 JSClass<JSGrid>::StaticMethod("onItemDragMove", &JSGrid::JsOnGridDragMove);
387 JSClass<JSGrid>::StaticMethod("onItemDragLeave", &JSGrid::JsOnGridDragLeave);
388 JSClass<JSGrid>::StaticMethod("onItemDragStart", &JSGrid::JsOnGridDragStart);
389 JSClass<JSGrid>::StaticMethod("height", &JSGrid::JsGridHeight);
390 JSClass<JSGrid>::StaticMethod("onItemDrop", &JSGrid::JsOnGridDrop);
391 JSClass<JSGrid>::StaticMethod("remoteMessage", &JSInteractableView::JsCommonRemoteMessage);
392 JSClass<JSGrid>::StaticMethod("nestedScroll", &JSGrid::SetNestedScroll);
393 JSClass<JSGrid>::StaticMethod("enableScrollInteraction", &JSGrid::SetScrollEnabled);
394 JSClass<JSGrid>::StaticMethod("friction", &JSGrid::SetFriction);
395 JSClass<JSGrid>::StaticMethod("alignItems", &JSGrid::SetAlignItems);
396
397 JSClass<JSGrid>::StaticMethod("onScroll", &JSGrid::JsOnScroll);
398 JSClass<JSGrid>::StaticMethod("onReachStart", &JSGrid::JsOnReachStart);
399 JSClass<JSGrid>::StaticMethod("onReachEnd", &JSGrid::JsOnReachEnd);
400 JSClass<JSGrid>::StaticMethod("onScrollStart", &JSGrid::JsOnScrollStart);
401 JSClass<JSGrid>::StaticMethod("onScrollStop", &JSGrid::JsOnScrollStop);
402 JSClass<JSGrid>::StaticMethod("onScrollIndex", &JSGrid::JsOnScrollIndex);
403 JSClass<JSGrid>::StaticMethod("onScrollFrameBegin", &JSGrid::JsOnScrollFrameBegin);
404
405 JSClass<JSGrid>::InheritAndBind<JSScrollableBase>(globalObj);
406 }
407
SetScrollBar(const JSCallbackInfo & info)408 void JSGrid::SetScrollBar(const JSCallbackInfo& info)
409 {
410 auto displayMode = JSScrollable::ParseDisplayMode(info, GridModel::GetInstance()->GetDisplayMode());
411 GridModel::GetInstance()->SetScrollBarMode(displayMode);
412 }
413
SetScrollBarColor(const JSCallbackInfo & info)414 void JSGrid::SetScrollBarColor(const JSCallbackInfo& info)
415 {
416 auto scrollBarColor = JSScrollable::ParseBarColor(info);
417 if (!scrollBarColor.empty()) {
418 GridModel::GetInstance()->SetScrollBarColor(scrollBarColor);
419 }
420 }
421
SetScrollBarWidth(const JSCallbackInfo & scrollWidth)422 void JSGrid::SetScrollBarWidth(const JSCallbackInfo& scrollWidth)
423 {
424 auto scrollBarWidth = JSScrollable::ParseBarWidth(scrollWidth);
425 if (!scrollBarWidth.empty()) {
426 GridModel::GetInstance()->SetScrollBarWidth(scrollBarWidth);
427 }
428 }
429
SetCachedCount(const JSCallbackInfo & info)430 void JSGrid::SetCachedCount(const JSCallbackInfo& info)
431 {
432 int32_t cachedCount = 1;
433 auto jsValue = info[0];
434
435 if (!jsValue->IsUndefined() && jsValue->IsNumber()) {
436 cachedCount = jsValue->ToNumber<int32_t>();
437 if (cachedCount < 0) {
438 cachedCount = 1;
439 }
440 }
441 bool show = false;
442 if (info.Length() > 1) {
443 show = info[1]->ToBoolean();
444 }
445 GridModel::GetInstance()->SetCachedCount(cachedCount, show);
446 }
447
SetEditMode(const JSCallbackInfo & info)448 void JSGrid::SetEditMode(const JSCallbackInfo& info)
449 {
450 // undefined means false to EditMode
451 bool editMode = false;
452 if (!info[0]->IsUndefined() && info[0]->IsBoolean()) {
453 ParseJsBool(info[0], editMode);
454 }
455 GridModel::GetInstance()->SetEditable(editMode);
456 }
457
SetMaxCount(const JSCallbackInfo & info)458 void JSGrid::SetMaxCount(const JSCallbackInfo& info)
459 {
460 int32_t maxCount = Infinity<int32_t>();
461 if (!info[0]->IsUndefined() && info[0]->IsNumber()) {
462 ParseJsInt32(info[0], maxCount);
463 if (maxCount < 1) {
464 maxCount = Infinity<int32_t>();
465 }
466 }
467 GridModel::GetInstance()->SetMaxCount(maxCount);
468 }
469
SetMinCount(const JSCallbackInfo & info)470 void JSGrid::SetMinCount(const JSCallbackInfo& info)
471 {
472 int32_t minCount = 1;
473 if (!info[0]->IsUndefined() && info[0]->IsNumber()) {
474 ParseJsInt32(info[0], minCount);
475 if (minCount < 1) {
476 minCount = 1;
477 }
478 }
479 GridModel::GetInstance()->SetMinCount(minCount);
480 }
481
CellLength(int32_t cellLength)482 void JSGrid::CellLength(int32_t cellLength)
483 {
484 GridModel::GetInstance()->SetCellLength(cellLength);
485 }
486
SetSupportAnimation(bool supportAnimation)487 void JSGrid::SetSupportAnimation(bool supportAnimation)
488 {
489 GridModel::GetInstance()->SetSupportAnimation(supportAnimation);
490 }
491
SetDragAnimation(bool value)492 void JSGrid::SetDragAnimation(bool value)
493 {
494 GridModel::GetInstance()->SetSupportDragAnimation(value);
495 }
496
SetEdgeEffect(const JSCallbackInfo & info)497 void JSGrid::SetEdgeEffect(const JSCallbackInfo& info)
498 {
499 auto edgeEffect = EdgeEffect::NONE;
500 auto effectEdge = EffectEdge::ALL;
501 if (info.Length() > 0) {
502 edgeEffect = JSScrollable::ParseEdgeEffect(info[0], EdgeEffect::NONE);
503 }
504 auto alwaysEnabled = false;
505 if (info.Length() > 1) {
506 alwaysEnabled = JSScrollable::ParseAlwaysEnable(info[1], false);
507 effectEdge = JSScrollable::ParseEffectEdge(info[1]);
508 }
509 GridModel::GetInstance()->SetEdgeEffect(edgeEffect, alwaysEnabled, effectEdge);
510 }
511
SetLayoutDirection(int32_t value)512 void JSGrid::SetLayoutDirection(int32_t value)
513 {
514 if (value < 0 || value >= static_cast<int32_t>(LAYOUT_DIRECTION.size())) {
515 return;
516 }
517 GridModel::GetInstance()->SetLayoutDirection(LAYOUT_DIRECTION[value]);
518 }
519
SetDirection(const std::string & dir)520 void JSGrid::SetDirection(const std::string& dir)
521 {
522 TextDirection direction;
523 if (dir == "Ltr") {
524 direction = TextDirection::LTR;
525 } else if (dir == "Rtl") {
526 direction = TextDirection::RTL;
527 } else {
528 direction = TextDirection::AUTO;
529 }
530 GridModel::GetInstance()->SetIsRTL(direction);
531 }
532
JsOnGridDragEnter(const JSCallbackInfo & info)533 void JSGrid::JsOnGridDragEnter(const JSCallbackInfo& info)
534 {
535 if (!info[0]->IsFunction()) {
536 return;
537 }
538
539 RefPtr<JsDragFunction> jsOnDragEnterFunc = AceType::MakeRefPtr<JsDragFunction>(JSRef<JSFunc>::Cast(info[0]));
540 auto onItemDragEnter = [execCtx = info.GetExecutionContext(), func = std::move(jsOnDragEnterFunc)](
541 const ItemDragInfo& dragInfo) {
542 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
543 ACE_SCORING_EVENT("Grid.onItemDragEnter");
544 func->ItemDragEnterExecute(dragInfo);
545 };
546 GridModel::GetInstance()->SetOnItemDragEnter(std::move(onItemDragEnter));
547 }
548
JsOnGridDragMove(const JSCallbackInfo & info)549 void JSGrid::JsOnGridDragMove(const JSCallbackInfo& info)
550 {
551 if (!info[0]->IsFunction()) {
552 return;
553 }
554
555 RefPtr<JsDragFunction> jsOnDragMoveFunc = AceType::MakeRefPtr<JsDragFunction>(JSRef<JSFunc>::Cast(info[0]));
556 auto onItemDragMove = [execCtx = info.GetExecutionContext(), func = std::move(jsOnDragMoveFunc)](
557 const ItemDragInfo& dragInfo, int32_t itemIndex, int32_t insertIndex) {
558 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
559 ACE_SCORING_EVENT("Grid.onItemDragMove");
560 func->ItemDragMoveExecute(dragInfo, itemIndex, insertIndex);
561 };
562 GridModel::GetInstance()->SetOnItemDragMove(std::move(onItemDragMove));
563 }
564
JsOnGridDragLeave(const JSCallbackInfo & info)565 void JSGrid::JsOnGridDragLeave(const JSCallbackInfo& info)
566 {
567 if (!info[0]->IsFunction()) {
568 return;
569 }
570
571 RefPtr<JsDragFunction> jsOnDragLeaveFunc = AceType::MakeRefPtr<JsDragFunction>(JSRef<JSFunc>::Cast(info[0]));
572 auto onItemDragLeave = [execCtx = info.GetExecutionContext(), func = std::move(jsOnDragLeaveFunc)](
573 const ItemDragInfo& dragInfo, int32_t itemIndex) {
574 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
575 ACE_SCORING_EVENT("Grid.onItemDragLeave");
576 func->ItemDragLeaveExecute(dragInfo, itemIndex);
577 };
578 GridModel::GetInstance()->SetOnItemDragLeave(std::move(onItemDragLeave));
579 }
580
JsOnGridDragStart(const JSCallbackInfo & info)581 void JSGrid::JsOnGridDragStart(const JSCallbackInfo& info)
582 {
583 if (!info[0]->IsFunction()) {
584 return;
585 }
586
587 auto jsOnDragFunc = AceType::MakeRefPtr<JsDragFunction>(JSRef<JSFunc>::Cast(info[0]));
588 WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
589 auto onItemDragStart = [execCtx = info.GetExecutionContext(), func = std::move(jsOnDragFunc), node = targetNode](
590 const ItemDragInfo& dragInfo, int32_t itemIndex) {
591 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
592 ACE_SCORING_EVENT("Grid.onItemDragStart");
593 auto ret = func->ItemDragStartExecute(dragInfo, itemIndex);
594 if (!ret->IsObject()) {
595 return;
596 }
597
598 auto builderObj = JSRef<JSObject>::Cast(ret);
599 auto builder = builderObj->GetProperty("builder");
600 if (!builder->IsFunction()) {
601 return;
602 }
603 auto builderFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSFunc>::Cast(builder));
604 CHECK_NULL_VOID(builderFunc);
605 PipelineContext::SetCallBackNode(node);
606 builderFunc->Execute();
607 };
608 GridModel::GetInstance()->SetOnItemDragStart(std::move(onItemDragStart));
609 }
610
JsOnGridDrop(const JSCallbackInfo & info)611 void JSGrid::JsOnGridDrop(const JSCallbackInfo& info)
612 {
613 if (!info[0]->IsFunction()) {
614 return;
615 }
616
617 RefPtr<JsDragFunction> jsOnDropFunc = AceType::MakeRefPtr<JsDragFunction>(JSRef<JSFunc>::Cast(info[0]));
618 auto onItemDrop = [execCtx = info.GetExecutionContext(), func = std::move(jsOnDropFunc)](
619 const ItemDragInfo& dragInfo, int32_t itemIndex, int32_t insertIndex, bool isSuccess) {
620 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
621 ACE_SCORING_EVENT("Grid.onItemDrop");
622 func->ItemDropExecute(dragInfo, itemIndex, insertIndex, isSuccess);
623 UiSessionManager::GetInstance()->ReportComponentChangeEvent("event", "Grid.onItemDrop");
624 };
625 GridModel::GetInstance()->SetOnItemDrop(std::move(onItemDrop));
626 }
627
SetMultiSelectable(bool multiSelectable)628 void JSGrid::SetMultiSelectable(bool multiSelectable)
629 {
630 GridModel::GetInstance()->SetMultiSelectable(multiSelectable);
631 }
632
SetNestedScroll(const JSCallbackInfo & args)633 void JSGrid::SetNestedScroll(const JSCallbackInfo& args)
634 {
635 NestedScrollOptions nestedOpt = {
636 .forward = NestedScrollMode::SELF_ONLY,
637 .backward = NestedScrollMode::SELF_ONLY,
638 };
639 if (args.Length() < 1 || !args[0]->IsObject()) {
640 GridModel::GetInstance()->SetNestedScroll(nestedOpt);
641 return;
642 }
643 JSRef<JSObject> obj = JSRef<JSObject>::Cast(args[0]);
644 int32_t froward = 0;
645 JSViewAbstract::ParseJsInt32(obj->GetProperty("scrollForward"), froward);
646 if (froward < static_cast<int32_t>(NestedScrollMode::SELF_ONLY) ||
647 froward > static_cast<int32_t>(NestedScrollMode::PARALLEL)) {
648 froward = 0;
649 }
650 int32_t backward = 0;
651 JSViewAbstract::ParseJsInt32(obj->GetProperty("scrollBackward"), backward);
652 if (backward < static_cast<int32_t>(NestedScrollMode::SELF_ONLY) ||
653 backward > static_cast<int32_t>(NestedScrollMode::PARALLEL)) {
654 backward = 0;
655 }
656 nestedOpt.forward = static_cast<NestedScrollMode>(froward);
657 nestedOpt.backward = static_cast<NestedScrollMode>(backward);
658 GridModel::GetInstance()->SetNestedScroll(nestedOpt);
659 args.ReturnSelf();
660 }
661
SetFriction(const JSCallbackInfo & info)662 void JSGrid::SetFriction(const JSCallbackInfo& info)
663 {
664 double friction = -1.0;
665 if (!JSViewAbstract::ParseJsDouble(info[0], friction)) {
666 friction = -1.0;
667 }
668 GridModel::GetInstance()->SetFriction(friction);
669 }
670
SetAlignItems(const JSCallbackInfo & info)671 void JSGrid::SetAlignItems(const JSCallbackInfo& info)
672 {
673 if (info.Length() < 1) {
674 GridModel::GetInstance()->SetAlignItems(GridItemAlignment::DEFAULT);
675 return;
676 }
677
678 if (info[0]->IsNumber()) {
679 auto itemAlign = static_cast<GridItemAlignment>(info[0]->ToNumber<int32_t>());
680 if (itemAlign < GridItemAlignment::DEFAULT || itemAlign > GridItemAlignment::STRETCH) {
681 itemAlign = GridItemAlignment::DEFAULT;
682 }
683 GridModel::GetInstance()->SetAlignItems(itemAlign);
684 } else {
685 GridModel::GetInstance()->SetAlignItems(GridItemAlignment::DEFAULT);
686 }
687 }
688
JsOnScroll(const JSCallbackInfo & args)689 void JSGrid::JsOnScroll(const JSCallbackInfo& args)
690 {
691 if (args[0]->IsFunction()) {
692 auto onScroll = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])](
693 const CalcDimension& scrollOffset, const ScrollState& scrollState) {
694 auto params = ConvertToJSValues(scrollOffset, scrollState);
695 func->Call(JSRef<JSObject>(), params.size(), params.data());
696 return;
697 };
698 GridModel::GetInstance()->SetOnScroll(std::move(onScroll));
699 }
700 args.ReturnSelf();
701 }
702
JsOnScrollStart(const JSCallbackInfo & args)703 void JSGrid::JsOnScrollStart(const JSCallbackInfo& args)
704 {
705 if (args[0]->IsFunction()) {
706 auto onScrollStart = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])]() {
707 func->Call(JSRef<JSObject>());
708 return;
709 };
710 GridModel::GetInstance()->SetOnScrollStart(std::move(onScrollStart));
711 }
712 args.ReturnSelf();
713 }
714
JsOnScrollStop(const JSCallbackInfo & args)715 void JSGrid::JsOnScrollStop(const JSCallbackInfo& args)
716 {
717 if (args[0]->IsFunction()) {
718 auto onScrollStop = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])]() {
719 func->Call(JSRef<JSObject>());
720 UiSessionManager::GetInstance()->ReportComponentChangeEvent("event", "Grid.onScrollStop");
721 return;
722 };
723 GridModel::GetInstance()->SetOnScrollStop(std::move(onScrollStop));
724 }
725 args.ReturnSelf();
726 }
727
JsOnScrollIndex(const JSCallbackInfo & args)728 void JSGrid::JsOnScrollIndex(const JSCallbackInfo& args)
729 {
730 if (Container::LessThanAPIVersion(PlatformVersion::VERSION_TEN)) {
731 JsOnScrollToIndex(args);
732 return;
733 }
734
735 if (args[0]->IsFunction()) {
736 auto onScrollIndex = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])](
737 const int32_t first, const int32_t last) {
738 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
739 auto params = ConvertToJSValues(first, last);
740 func->Call(JSRef<JSObject>(), params.size(), params.data());
741 return;
742 };
743 GridModel::GetInstance()->SetOnScrollIndex(std::move(onScrollIndex));
744 }
745 args.ReturnSelf();
746 }
747
JsOnScrollFrameBegin(const JSCallbackInfo & args)748 void JSGrid::JsOnScrollFrameBegin(const JSCallbackInfo& args)
749 {
750 if (args[0]->IsFunction()) {
751 auto onScrollBegin = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])](
752 const Dimension& offset, const ScrollState& state) -> ScrollFrameResult {
753 ScrollFrameResult scrollRes { .offset = offset };
754 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx, scrollRes);
755 auto params = ConvertToJSValues(offset, state);
756 auto result = func->Call(JSRef<JSObject>(), params.size(), params.data());
757 if (result.IsEmpty()) {
758 return scrollRes;
759 }
760
761 if (!result->IsObject()) {
762 return scrollRes;
763 }
764
765 auto resObj = JSRef<JSObject>::Cast(result);
766 auto dxRemainValue = resObj->GetProperty("offsetRemain");
767 if (dxRemainValue->IsNumber()) {
768 scrollRes.offset = Dimension(dxRemainValue->ToNumber<float>(), DimensionUnit::VP);
769 }
770 return scrollRes;
771 };
772 GridModel::GetInstance()->SetOnScrollFrameBegin(std::move(onScrollBegin));
773 }
774 }
775
JsOnReachStart(const JSCallbackInfo & args)776 void JSGrid::JsOnReachStart(const JSCallbackInfo& args)
777 {
778 if (args[0]->IsFunction()) {
779 auto onReachStart = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])]() {
780 func->Call(JSRef<JSObject>());
781 UiSessionManager::GetInstance()->ReportComponentChangeEvent("event", "Grid.onReachStart");
782 return;
783 };
784 GridModel::GetInstance()->SetOnReachStart(std::move(onReachStart));
785 }
786 args.ReturnSelf();
787 }
788
JsOnReachEnd(const JSCallbackInfo & args)789 void JSGrid::JsOnReachEnd(const JSCallbackInfo& args)
790 {
791 if (args[0]->IsFunction()) {
792 auto onReachEnd = [execCtx = args.GetExecutionContext(), func = JSRef<JSFunc>::Cast(args[0])]() {
793 func->Call(JSRef<JSObject>());
794 UiSessionManager::GetInstance()->ReportComponentChangeEvent("event", "Grid.onReachEnd");
795 return;
796 };
797 GridModel::GetInstance()->SetOnReachEnd(std::move(onReachEnd));
798 }
799 args.ReturnSelf();
800 }
801
802 } // namespace OHOS::Ace::Framework
803