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 "frameworks/bridge/declarative_frontend/jsview/js_tabs.h"
17 #if !defined(PREVIEW) && defined(OHOS_PLATFORM)
18 #include "interfaces/inner_api/ui_session/ui_session_manager.h"
19 #endif
20 
21 
22 #include "base/log/ace_scoring_log.h"
23 #include "bridge/declarative_frontend/engine/functions/js_swiper_function.h"
24 #include "bridge/declarative_frontend/engine/functions/js_tabs_function.h"
25 #include "bridge/declarative_frontend/jsview/js_scrollable.h"
26 #include "bridge/declarative_frontend/jsview/js_tabs_controller.h"
27 #include "bridge/declarative_frontend/jsview/js_view_common_def.h"
28 #include "bridge/declarative_frontend/jsview/models/tabs_model_impl.h"
29 #include "core/components/common/layout/constants.h"
30 #include "core/components/common/properties/decoration.h"
31 #include "core/components_ng/base/view_stack_processor.h"
32 #include "core/components_ng/pattern/tabs/tabs_model_ng.h"
33 #include "core/components_ng/pattern/tabs/tab_content_transition_proxy.h"
34 
35 namespace OHOS::Ace {
36 
37 std::unique_ptr<TabsModel> TabsModel::instance_ = nullptr;
38 std::mutex TabsModel::mutex_;
39 
GetInstance()40 TabsModel* TabsModel::GetInstance()
41 {
42     if (!instance_) {
43         std::lock_guard<std::mutex> lock(mutex_);
44         if (!instance_) {
45 #ifdef NG_BUILD
46             instance_.reset(new NG::TabsModelNG());
47 #else
48             if (Container::IsCurrentUseNewPipeline()) {
49                 instance_.reset(new NG::TabsModelNG());
50             } else {
51                 instance_.reset(new Framework::TabsModelImpl());
52             }
53 #endif
54         }
55     }
56     return instance_.get();
57 }
58 
59 } // namespace OHOS::Ace
60 
61 namespace OHOS::Ace::Framework {
62 namespace {
63 constexpr int32_t SM_COLUMN_NUM = 4;
64 constexpr int32_t MD_COLUMN_NUM = 8;
65 constexpr int32_t LG_COLUMN_NUM = 12;
66 constexpr int32_t DEFAULT_CUSTOM_ANIMATION_TIMEOUT = 1000;
67 const std::vector<BarPosition> BAR_POSITIONS = { BarPosition::START, BarPosition::END };
68 
69 const std::vector<BlurStyle> BAR_BLURSTYLE = {
70     BlurStyle::NO_MATERIAL,
71     BlurStyle::THIN,
72     BlurStyle::REGULAR,
73     BlurStyle::THICK,
74     BlurStyle::BACKGROUND_THIN,
75     BlurStyle::BACKGROUND_REGULAR,
76     BlurStyle::BACKGROUND_THICK,
77     BlurStyle::BACKGROUND_ULTRA_THICK,
78     BlurStyle::COMPONENT_ULTRA_THIN,
79     BlurStyle::COMPONENT_THIN,
80     BlurStyle::COMPONENT_REGULAR,
81     BlurStyle::COMPONENT_THICK,
82     BlurStyle::COMPONENT_ULTRA_THICK,
83 };
84 
TabContentChangeEventToJSValue(const TabContentChangeEvent & eventInfo)85 JSRef<JSVal> TabContentChangeEventToJSValue(const TabContentChangeEvent& eventInfo)
86 {
87     return JSRef<JSVal>::Make(ToJSValue(eventInfo.GetIndex()));
88 }
89 
90 } // namespace
91 
SetOnChange(const JSCallbackInfo & info)92 void JSTabs::SetOnChange(const JSCallbackInfo& info)
93 {
94     if (!info[0]->IsFunction()) {
95         return;
96     }
97 
98     auto changeHandler = AceType::MakeRefPtr<JsEventFunction<TabContentChangeEvent, 1>>(
99         JSRef<JSFunc>::Cast(info[0]), TabContentChangeEventToJSValue);
100     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
101     auto onChange = [executionContext = info.GetExecutionContext(), func = std::move(changeHandler), node = targetNode](
102                         const BaseEventInfo* info) {
103         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(executionContext);
104         const auto* tabsInfo = TypeInfoHelper::DynamicCast<TabContentChangeEvent>(info);
105         if (!tabsInfo) {
106             TAG_LOGW(AceLogTag::ACE_TABS, "Tabs onChange callback execute failed.");
107             return;
108         }
109         ACE_SCORING_EVENT("Tabs.onChange");
110         ACE_SCOPED_TRACE("Tabs.onChange index %d", tabsInfo->GetIndex());
111         PipelineContext::SetCallBackNode(node);
112         func->Execute(*tabsInfo);
113     };
114     TabsModel::GetInstance()->SetOnChange(std::move(onChange));
115 }
116 
SetOnTabBarClick(const JSCallbackInfo & info)117 void JSTabs::SetOnTabBarClick(const JSCallbackInfo& info)
118 {
119     if (!info[0]->IsFunction()) {
120         return;
121     }
122 
123     auto changeHandler = AceType::MakeRefPtr<JsEventFunction<TabContentChangeEvent, 1>>(
124         JSRef<JSFunc>::Cast(info[0]), TabContentChangeEventToJSValue);
125     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
126     auto onTabBarClick = [executionContext = info.GetExecutionContext(), func = std::move(changeHandler),
127                              node = targetNode](const BaseEventInfo* info) {
128         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(executionContext);
129         const auto* tabsInfo = TypeInfoHelper::DynamicCast<TabContentChangeEvent>(info);
130         if (!tabsInfo) {
131             TAG_LOGW(AceLogTag::ACE_TABS, "Tabs onTabBarClick callback execute failed.");
132             return;
133         }
134         ACE_SCORING_EVENT("Tabs.onTabBarClick");
135         PipelineContext::SetCallBackNode(node);
136         func->Execute(*tabsInfo);
137 #if !defined(PREVIEW) && defined(OHOS_PLATFORM)
138         UiSessionManager::GetInstance().ReportComponentChangeEvent("event", "Tabs.onTabBarClick");
139 #endif
140     };
141     TabsModel::GetInstance()->SetOnTabBarClick(std::move(onTabBarClick));
142 }
143 
SetOnAnimationStart(const JSCallbackInfo & info)144 void JSTabs::SetOnAnimationStart(const JSCallbackInfo& info)
145 {
146     if (!info[0]->IsFunction()) {
147         return;
148     }
149 
150     auto animationStartHandler = AceType::MakeRefPtr<JsSwiperFunction>(JSRef<JSFunc>::Cast(info[0]));
151     auto onAnimationStart = [executionContext = info.GetExecutionContext(),
152                                 func = std::move(animationStartHandler)](
153                                 int32_t index, int32_t targetIndex, const AnimationCallbackInfo& info) {
154         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(executionContext);
155         ACE_SCORING_EVENT("Tabs.onAnimationStart");
156         func->Execute(index, targetIndex, info);
157     };
158     TabsModel::GetInstance()->SetOnAnimationStart(std::move(onAnimationStart));
159 }
160 
SetOnAnimationEnd(const JSCallbackInfo & info)161 void JSTabs::SetOnAnimationEnd(const JSCallbackInfo& info)
162 {
163     if (!info[0]->IsFunction()) {
164         return;
165     }
166 
167     auto animationEndHandler = AceType::MakeRefPtr<JsSwiperFunction>(JSRef<JSFunc>::Cast(info[0]));
168     auto onAnimationEnd = [executionContext = info.GetExecutionContext(), func = std::move(animationEndHandler)](
169                               int32_t index, const AnimationCallbackInfo& info) {
170         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(executionContext);
171         ACE_SCORING_EVENT("Tabs.onAnimationEnd");
172         func->Execute(index, info);
173 #if !defined(PREVIEW) && defined(OHOS_PLATFORM)
174         UiSessionManager::GetInstance().ReportComponentChangeEvent("event", "Tabs.onAnimationEnd");
175 #endif
176     };
177     TabsModel::GetInstance()->SetOnAnimationEnd(std::move(onAnimationEnd));
178 }
179 
SetOnGestureSwipe(const JSCallbackInfo & info)180 void JSTabs::SetOnGestureSwipe(const JSCallbackInfo& info)
181 {
182     if (!info[0]->IsFunction()) {
183         return;
184     }
185 
186     auto gestureSwipeHandler = AceType::MakeRefPtr<JsSwiperFunction>(JSRef<JSFunc>::Cast(info[0]));
187     auto onGestureSwipe = [executionContext = info.GetExecutionContext(), func = std::move(gestureSwipeHandler)](
188                               int32_t index, const AnimationCallbackInfo& info) {
189         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(executionContext);
190         ACE_SCORING_EVENT("Tabs.onGestureSwipe");
191         func->Execute(index, info);
192     };
193     TabsModel::GetInstance()->SetOnGestureSwipe(std::move(onGestureSwipe));
194 }
195 
ParseTabsIndexObject(const JSCallbackInfo & info,const JSRef<JSVal> & changeEventVal)196 void ParseTabsIndexObject(const JSCallbackInfo& info, const JSRef<JSVal>& changeEventVal)
197 {
198     CHECK_NULL_VOID(changeEventVal->IsFunction());
199 
200     auto jsFunc = AceType::MakeRefPtr<JsFunction>(JSRef<JSObject>(), JSRef<JSFunc>::Cast(changeEventVal));
201     WeakPtr<NG::FrameNode> targetNode = AceType::WeakClaim(NG::ViewStackProcessor::GetInstance()->GetMainFrameNode());
202     auto onChangeEvent = [executionContext = info.GetExecutionContext(), func = std::move(jsFunc), node = targetNode](
203                              const BaseEventInfo* info) {
204         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(executionContext);
205         const auto* tabsInfo = TypeInfoHelper::DynamicCast<TabContentChangeEvent>(info);
206         if (!tabsInfo) {
207             TAG_LOGW(AceLogTag::ACE_TABS, "ParseTabsIndexObject execute onChange event failed.");
208             return;
209         }
210         ACE_SCORING_EVENT("Tabs.onChangeEvent");
211         PipelineContext::SetCallBackNode(node);
212         auto newJSVal = JSRef<JSVal>::Make(ToJSValue(tabsInfo->GetIndex()));
213         func->ExecuteJS(1, &newJSVal);
214     };
215     TabsModel::GetInstance()->SetOnChangeEvent(std::move(onChangeEvent));
216 }
217 
Create(const JSCallbackInfo & info)218 void JSTabs::Create(const JSCallbackInfo& info)
219 {
220     BarPosition barPosition = BarPosition::START;
221     RefPtr<TabController> tabController;
222     RefPtr<NG::TabsControllerNG> tabsController;
223     int32_t index = -1;
224     JSRef<JSVal> changeEventVal;
225     auto jsValue = info[0];
226     if (jsValue->IsObject()) {
227         JSRef<JSObject> obj = JSRef<JSObject>::Cast(jsValue);
228         JSRef<JSVal> val = obj->GetProperty("barPosition");
229         if (val->IsNumber()) {
230             auto barPositionVal = val->ToNumber<int32_t>();
231             if (barPositionVal >= 0 && barPositionVal < static_cast<int32_t>(BAR_POSITIONS.size())) {
232                 barPosition = BAR_POSITIONS[barPositionVal];
233             }
234         }
235         JSRef<JSVal> controller = obj->GetProperty("controller");
236         if (controller->IsObject()) {
237             auto* jsTabsController = JSRef<JSObject>::Cast(controller)->Unwrap<JSTabsController>();
238             if (jsTabsController) {
239                 jsTabsController->SetInstanceId(Container::CurrentId());
240                 tabController = jsTabsController->GetController();
241                 tabsController = jsTabsController->GetTabsController();
242             }
243         }
244         JSRef<JSVal> indexVal = obj->GetProperty("index");
245         if (indexVal->IsNumber()) {
246             index = indexVal->ToNumber<int32_t>();
247             index = index < 0 ? 0 : index;
248             if (!tabController) {
249                 tabController = JSTabsController::CreateController();
250             }
251 #ifndef NG_BUILD
252             tabController->SetInitialIndex(index);
253 #endif
254         } else if (indexVal->IsObject()) {
255             JSRef<JSObject> indexObj = JSRef<JSObject>::Cast(indexVal);
256             auto indexValueProperty = indexObj->GetProperty("value");
257             if (indexValueProperty->IsNumber()) {
258                 index = indexValueProperty->ToNumber<int32_t>();
259                 index = index < 0 ? 0 : index;
260             }
261             changeEventVal = indexObj->GetProperty("changeEvent");
262         }
263     }
264 
265     TabsModel::GetInstance()->Create(barPosition, index, tabController, tabsController);
266     if (!changeEventVal->IsUndefined() && changeEventVal->IsFunction()) {
267         ParseTabsIndexObject(info, changeEventVal);
268     }
269 }
270 
Pop()271 void JSTabs::Pop()
272 {
273     TabsModel::GetInstance()->Pop();
274 }
275 
SetBarPosition(const JSCallbackInfo & info)276 void JSTabs::SetBarPosition(const JSCallbackInfo& info)
277 {
278     BarPosition barVal = BarPosition::START;
279     if (info.Length() > 0 && info[0]->IsNumber()) {
280         auto barPositionVal = info[0]->ToNumber<int32_t>();
281         if (barPositionVal >= 0 && barPositionVal < static_cast<int32_t>(BAR_POSITIONS.size())) {
282             barVal = BAR_POSITIONS[barPositionVal];
283         }
284     }
285 
286     TabsModel::GetInstance()->SetTabBarPosition(barVal);
287 }
288 
SetVertical(const std::string & value)289 void JSTabs::SetVertical(const std::string& value)
290 {
291     TabsModel::GetInstance()->SetIsVertical(StringToBool(value));
292 }
293 
SetScrollable(const std::string & value)294 void JSTabs::SetScrollable(const std::string& value)
295 {
296     if (value == "undefined") {
297         TabsModel::GetInstance()->SetScrollable(true);
298         return;
299     }
300     TabsModel::GetInstance()->SetScrollable(StringToBool(value));
301 }
302 
SetBarMode(const JSCallbackInfo & info)303 void JSTabs::SetBarMode(const JSCallbackInfo& info)
304 {
305     TabBarMode barMode = TabBarMode::FIXED;
306     if (info.Length() < 1) {
307         TabsModel::GetInstance()->SetTabBarMode(barMode);
308         return;
309     }
310     auto barModeInfo = info[0];
311     if (barModeInfo->IsString()) {
312         barMode = ConvertStrToTabBarMode(barModeInfo->ToString());
313     }
314     if (barMode == TabBarMode::SCROLLABLE) {
315         if (info.Length() > 1 && info[1]->IsObject()) {
316             SetScrollableBarModeOptions(info[1]);
317         } else {
318             ScrollableBarModeOptions option;
319             TabsModel::GetInstance()->SetScrollableBarModeOptions(option);
320         }
321     }
322     TabsModel::GetInstance()->SetTabBarMode(barMode);
323 }
324 
SetBarWidth(const JSCallbackInfo & info)325 void JSTabs::SetBarWidth(const JSCallbackInfo& info)
326 {
327     if (info.Length() < 1) {
328         return;
329     }
330 
331     CalcDimension width = Dimension(-1.0, DimensionUnit::VP);
332     if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_TEN)) {
333         if (!ParseJsDimensionVpNG(info[0], width)) {
334             width = Dimension(-1.0, DimensionUnit::VP);
335             TabsModel::GetInstance()->SetTabBarWidth(width);
336             return;
337         }
338     } else {
339         ParseJsDimensionVp(info[0], width);
340     }
341 
342     TabsModel::GetInstance()->SetTabBarWidth(width);
343 }
344 
SetBarHeight(const JSCallbackInfo & info)345 void JSTabs::SetBarHeight(const JSCallbackInfo& info)
346 {
347     if (info.Length() < 1) {
348         return;
349     }
350     CalcDimension height = Dimension(-1.0, DimensionUnit::VP);
351     bool adaptiveHeight = false;
352     auto barHeightInfo = info[0];
353     if (barHeightInfo->IsString() && barHeightInfo->ToString() == "auto") {
354         adaptiveHeight = true;
355     } else {
356         if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_TEN)) {
357             if (!ParseJsDimensionVpNG(barHeightInfo, height)) {
358                 height = Dimension(-1.0, DimensionUnit::VP);
359             }
360         } else {
361             ParseJsDimensionVp(barHeightInfo, height);
362         }
363     }
364     TabsModel::GetInstance()->SetBarAdaptiveHeight(adaptiveHeight);
365     TabsModel::GetInstance()->SetTabBarHeight(height);
366 }
367 
SetWidth(const JSCallbackInfo & info)368 void JSTabs::SetWidth(const JSCallbackInfo& info)
369 {
370     JSViewAbstract::JsWidth(info);
371     if (info.Length() < 1) {
372         return;
373     }
374     if (info[0]->IsString() && info[0]->ToString().empty()) {
375         return;
376     }
377     if (info[0]->IsString() && info[0]->ToString() == "auto") {
378         ViewAbstractModel::GetInstance()->ClearWidthOrHeight(true);
379         TabsModel::GetInstance()->SetWidthAuto(true);
380         return;
381     }
382 
383     TabsModel::GetInstance()->SetWidthAuto(false);
384 }
385 
SetHeight(const JSCallbackInfo & info)386 void JSTabs::SetHeight(const JSCallbackInfo& info)
387 {
388     JSViewAbstract::JsHeight(info);
389     if (info.Length() < 1) {
390         return;
391     }
392     if (info[0]->IsString() && info[0]->ToString().empty()) {
393         return;
394     }
395     if (info[0]->IsString() && info[0]->ToString() == "auto") {
396         ViewAbstractModel::GetInstance()->ClearWidthOrHeight(false);
397         TabsModel::GetInstance()->SetHeightAuto(true);
398         return;
399     }
400 
401     TabsModel::GetInstance()->SetHeightAuto(false);
402 }
403 
SetIndex(int32_t index)404 void JSTabs::SetIndex(int32_t index)
405 {
406     TabsModel::GetInstance()->SetIndex(index);
407 }
408 
SetAnimationDuration(const JSCallbackInfo & info)409 void JSTabs::SetAnimationDuration(const JSCallbackInfo& info)
410 {
411     if (info.Length() <= 0) {
412         TabsModel::GetInstance()->SetAnimationDuration(-1);
413         return;
414     }
415     auto animationDurationInfo = info[0];
416     if ((!animationDurationInfo->IsNull() && !animationDurationInfo->IsNumber()) ||
417         (animationDurationInfo->IsNull() && Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_ELEVEN))) {
418         TabsModel::GetInstance()->SetAnimationDuration(-1);
419         return;
420     }
421     auto value = animationDurationInfo->IsNumber() ? animationDurationInfo->ToNumber<int32_t>() : 0;
422     TabsModel::GetInstance()->SetAnimationDuration(value);
423 }
424 
SetFadingEdge(const JSCallbackInfo & info)425 void JSTabs::SetFadingEdge(const JSCallbackInfo& info)
426 {
427     bool fadingEdge = true;
428     if (info.Length() > 0) {
429         ParseJsBool(info[0], fadingEdge);
430     }
431     TabsModel::GetInstance()->SetFadingEdge(fadingEdge);
432 }
433 
SetBarOverlap(const JSCallbackInfo & info)434 void JSTabs::SetBarOverlap(const JSCallbackInfo& info)
435 {
436     bool barOverlap = false;
437     if (info.Length() > 0) {
438         ParseJsBool(info[0], barOverlap);
439     }
440     TabsModel::GetInstance()->SetBarOverlap(barOverlap);
441 }
442 
SetBarBackgroundColor(const JSCallbackInfo & info)443 void JSTabs::SetBarBackgroundColor(const JSCallbackInfo& info)
444 {
445     Color backgroundColor = Color::BLACK.BlendOpacity(0.0f);
446     if (info.Length() > 0) {
447         ConvertFromJSValue(info[0], backgroundColor);
448     }
449     TabsModel::GetInstance()->SetBarBackgroundColor(backgroundColor);
450 }
451 
SetBarBackgroundBlurStyle(const JSCallbackInfo & info)452 void JSTabs::SetBarBackgroundBlurStyle(const JSCallbackInfo& info)
453 {
454     BlurStyle blurStyle = BlurStyle::NO_MATERIAL;
455     if (info.Length() > 0 && info[0]->IsNumber()) {
456         auto barBlurStyle = info[0]->ToNumber<int32_t>();
457         if (barBlurStyle >= 0 && barBlurStyle < static_cast<int32_t>(BAR_BLURSTYLE.size())) {
458             blurStyle = BAR_BLURSTYLE[barBlurStyle];
459         }
460     }
461     TabsModel::GetInstance()->SetBarBackgroundBlurStyle(blurStyle);
462 }
463 
SetDivider(const JSCallbackInfo & info)464 void JSTabs::SetDivider(const JSCallbackInfo& info)
465 {
466     TabsItemDivider divider;
467     CalcDimension dividerStrokeWidth;
468     CalcDimension dividerStartMargin;
469     CalcDimension dividerEndMargin;
470     RefPtr<TabTheme> tabTheme = GetTheme<TabTheme>();
471     CHECK_NULL_VOID(tabTheme);
472 
473     if (info.Length() > 0) {
474         auto dividerInfo = info[0];
475         JSRef<JSObject> obj = JSRef<JSObject>::New();
476         if (dividerInfo->IsObject()) {
477             obj = JSRef<JSObject>::Cast(dividerInfo);
478         }
479         if (dividerInfo->IsNull()) {
480             divider.isNull = true;
481         } else {
482             if (!dividerInfo->IsObject() || !ParseJsDimensionVp(obj->GetProperty("strokeWidth"), dividerStrokeWidth) ||
483                 dividerStrokeWidth.Value() < 0.0f || dividerStrokeWidth.Unit() == DimensionUnit::PERCENT) {
484                 divider.strokeWidth.Reset();
485             } else {
486                 divider.strokeWidth = dividerStrokeWidth;
487             }
488             if (!dividerInfo->IsObject() || !ConvertFromJSValue(obj->GetProperty("color"), divider.color)) {
489                 divider.color = tabTheme->GetDividerColor();
490             }
491             if (!dividerInfo->IsObject() || !ParseJsDimensionVp(obj->GetProperty("startMargin"), dividerStartMargin) ||
492                 dividerStartMargin.Value() < 0.0f || dividerStartMargin.Unit() == DimensionUnit::PERCENT) {
493                 divider.startMargin.Reset();
494             } else {
495                 divider.startMargin = dividerStartMargin;
496             }
497             if (!dividerInfo->IsObject() || !ParseJsDimensionVp(obj->GetProperty("endMargin"), dividerEndMargin) ||
498                 dividerEndMargin.Value() < 0.0f || dividerEndMargin.Unit() == DimensionUnit::PERCENT) {
499                 divider.endMargin.Reset();
500             } else {
501                 divider.endMargin = dividerEndMargin;
502             }
503         }
504     }
505     TabsModel::GetInstance()->SetDivider(divider);
506 }
507 
SetClip(const JSCallbackInfo & info)508 void JSTabs::SetClip(const JSCallbackInfo& info)
509 {
510     if (info[0]->IsObject() || !Container::IsCurrentUseNewPipeline()) {
511         JSViewAbstract::JsClip(info);
512         return;
513     }
514     if (info[0]->IsBoolean()) {
515         TabsModel::GetInstance()->SetClipEdge(info[0]->ToBoolean());
516     }
517 }
518 
SetScrollableBarModeOptions(const JSRef<JSVal> & info)519 void JSTabs::SetScrollableBarModeOptions(const JSRef<JSVal>& info)
520 {
521     ScrollableBarModeOptions option;
522     auto optionParam = JSRef<JSObject>::Cast(info);
523     CalcDimension margin = Dimension(0.0, DimensionUnit::VP);
524     if (!ParseJsDimensionVp(optionParam->GetProperty("margin"), margin) || Negative(margin.Value()) ||
525         margin.Unit() == DimensionUnit::PERCENT) {
526         option.margin = 0.0_vp;
527     } else {
528         option.margin = margin;
529     }
530 
531     auto nonScrollableLayoutStyle = optionParam->GetProperty("nonScrollableLayoutStyle");
532     int32_t layoutStyle;
533     if (!ConvertFromJSValue(nonScrollableLayoutStyle, layoutStyle)) {
534         option.nonScrollableLayoutStyle = LayoutStyle::ALWAYS_CENTER;
535     } else {
536         option.nonScrollableLayoutStyle = (static_cast<LayoutStyle>(layoutStyle));
537     }
538     TabsModel::GetInstance()->SetScrollableBarModeOptions(option);
539 }
540 
SetBarGridAlign(const JSCallbackInfo & info)541 void JSTabs::SetBarGridAlign(const JSCallbackInfo& info)
542 {
543     BarGridColumnOptions columnOption;
544     if (info.Length() > 0 && info[0]->IsObject()) {
545         auto gridParam = JSRef<JSObject>::Cast(info[0]);
546         auto sm = gridParam->GetProperty("sm");
547         if (sm->IsNumber() && sm->ToNumber<int32_t>() >= 0 && sm->ToNumber<int32_t>() <= SM_COLUMN_NUM &&
548             sm->ToNumber<int32_t>() % 2 == 0) {
549             columnOption.sm = sm->ToNumber<int32_t>();
550         }
551         auto md = gridParam->GetProperty("md");
552         if (md->IsNumber() && md->ToNumber<int32_t>() >= 0 && md->ToNumber<int32_t>() <= MD_COLUMN_NUM &&
553             md->ToNumber<int32_t>() % 2 == 0) {
554             columnOption.md = md->ToNumber<int32_t>();
555         }
556         auto lg = gridParam->GetProperty("lg");
557         if (lg->IsNumber() && lg->ToNumber<int32_t>() >= 0 && lg->ToNumber<int32_t>() <= LG_COLUMN_NUM &&
558             lg->ToNumber<int32_t>() % 2 == 0) {
559             columnOption.lg = lg->ToNumber<int32_t>();
560         }
561         CalcDimension columnGutter;
562         if (ParseJsDimensionVp(gridParam->GetProperty("gutter"), columnGutter) && NonNegative(columnGutter.Value()) &&
563             columnGutter.Unit() != DimensionUnit::PERCENT) {
564             columnOption.gutter = columnGutter;
565         }
566         CalcDimension columnMargin;
567         if (ParseJsDimensionVp(gridParam->GetProperty("margin"), columnMargin) && NonNegative(columnMargin.Value()) &&
568             columnMargin.Unit() != DimensionUnit::PERCENT) {
569             columnOption.margin = columnMargin;
570         }
571     }
572     TabsModel::GetInstance()->SetBarGridAlign(columnOption);
573 }
574 
SetCustomContentTransition(const JSCallbackInfo & info)575 void JSTabs::SetCustomContentTransition(const JSCallbackInfo& info)
576 {
577     if (info.Length() != 1) {
578         return;
579     }
580 
581     auto customContentTransitionInfo = info[0];
582     if (customContentTransitionInfo->IsUndefined() || !customContentTransitionInfo->IsFunction()) {
583         TabsModel::GetInstance()->SetIsCustomAnimation(false);
584         return;
585     }
586 
587     RefPtr<JsTabsFunction> jsCustomAnimationFunc =
588         AceType::MakeRefPtr<JsTabsFunction>(JSRef<JSFunc>::Cast(customContentTransitionInfo));
589     auto onCustomAnimation = [execCtx = info.GetExecutionContext(), func = std::move(jsCustomAnimationFunc)](
590                                  int32_t from, int32_t to) -> TabContentAnimatedTransition {
591         TabContentAnimatedTransition transitionInfo;
592         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx, transitionInfo);
593 
594         auto ret = func->Execute(from, to);
595         if (!ret->IsObject()) {
596             return transitionInfo;
597         }
598 
599         auto transitionObj = JSRef<JSObject>::Cast(ret);
600         JSRef<JSVal> timeoutProperty = transitionObj->GetProperty("timeout");
601         if (timeoutProperty->IsNumber()) {
602             auto timeout = timeoutProperty->ToNumber<int32_t>();
603             transitionInfo.timeout = timeout < 0 ? DEFAULT_CUSTOM_ANIMATION_TIMEOUT : timeout;
604         } else {
605             transitionInfo.timeout = DEFAULT_CUSTOM_ANIMATION_TIMEOUT;
606         }
607 
608         JSRef<JSVal> transition = transitionObj->GetProperty("transition");
609         if (transition->IsFunction()) {
610             RefPtr<JsTabsFunction> jsOnTransition =
611                 AceType::MakeRefPtr<JsTabsFunction>(JSRef<JSFunc>::Cast(transition));
612             auto onTransition = [execCtx, func = std::move(jsOnTransition)](
613                                     const RefPtr<TabContentTransitionProxy>& proxy) {
614                 JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
615                 ACE_SCORING_EVENT("onTransition");
616                 func->Execute(proxy);
617             };
618 
619             transitionInfo.transition = std::move(onTransition);
620         }
621 
622         return transitionInfo;
623     };
624     TabsModel::GetInstance()->SetIsCustomAnimation(true);
625     TabsModel::GetInstance()->SetOnCustomAnimation(std::move(onCustomAnimation));
626 }
627 
SetOnContentWillChange(const JSCallbackInfo & info)628 void JSTabs::SetOnContentWillChange(const JSCallbackInfo& info)
629 {
630     if (!info[0]->IsFunction()) {
631         return;
632     }
633 
634     auto handler = AceType::MakeRefPtr<JsTabsFunction>(JSRef<JSFunc>::Cast(info[0]));
635     auto callback = [execCtx = info.GetExecutionContext(), func = std::move(handler)]
636         (int32_t currentIndex, int32_t comingIndex) -> bool {
637         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx, true);
638         ACE_SCORING_EVENT("Tabs.onContentWillChange");
639         auto ret = func->Execute(currentIndex, comingIndex);
640         if (!ret->IsBoolean()) {
641             return true;
642         }
643         return ret->ToBoolean();
644     };
645     TabsModel::GetInstance()->SetOnContentWillChange(std::move(callback));
646 }
647 
SetAnimateMode(const JSCallbackInfo & info)648 void JSTabs::SetAnimateMode(const JSCallbackInfo& info)
649 {
650     JSRef<JSVal> args = info[0];
651     if (!args->IsNumber()) {
652         TabsModel::GetInstance()->SetAnimateMode(TabAnimateMode::CONTENT_FIRST);
653         return;
654     }
655     uint32_t value = args->ToNumber<uint32_t>();
656     if (value >= static_cast<uint32_t>(TabAnimateMode::MAX_VALUE)) {
657         TabsModel::GetInstance()->SetAnimateMode(TabAnimateMode::CONTENT_FIRST);
658         return;
659     }
660     TabsModel::GetInstance()->SetAnimateMode(static_cast<TabAnimateMode>(value));
661 }
662 
SetEdgeEffect(const JSCallbackInfo & info)663 void JSTabs::SetEdgeEffect(const JSCallbackInfo& info)
664 {
665     auto edgeEffect = EdgeEffect::SPRING;
666     if (info.Length() > 0) {
667         edgeEffect = JSScrollable::ParseEdgeEffect(info[0], EdgeEffect::SPRING);
668     }
669     TabsModel::GetInstance()->SetEdgeEffect(edgeEffect);
670 }
671 
JSBind(BindingTarget globalObj)672 void JSTabs::JSBind(BindingTarget globalObj)
673 {
674     JsTabContentTransitionProxy::JSBind(globalObj);
675     JSClass<JSTabs>::Declare("Tabs");
676     JSClass<JSTabs>::StaticMethod("create", &JSTabs::Create);
677     JSClass<JSTabs>::StaticMethod("pop", &JSTabs::Pop);
678     JSClass<JSTabs>::StaticMethod("vertical", &JSTabs::SetVertical);
679     JSClass<JSTabs>::StaticMethod("barPosition", &JSTabs::SetBarPosition);
680     JSClass<JSTabs>::StaticMethod("barBackgroundBlurStyle", &JSTabs::SetBarBackgroundBlurStyle);
681     JSClass<JSTabs>::StaticMethod("scrollable", &JSTabs::SetScrollable);
682     JSClass<JSTabs>::StaticMethod("barMode", &JSTabs::SetBarMode);
683     JSClass<JSTabs>::StaticMethod("barWidth", &JSTabs::SetBarWidth);
684     JSClass<JSTabs>::StaticMethod("barHeight", &JSTabs::SetBarHeight);
685     JSClass<JSTabs>::StaticMethod("width", &JSTabs::SetWidth);
686     JSClass<JSTabs>::StaticMethod("height", &JSTabs::SetHeight);
687     JSClass<JSTabs>::StaticMethod("index", &JSTabs::SetIndex);
688     JSClass<JSTabs>::StaticMethod("animationDuration", &JSTabs::SetAnimationDuration);
689     JSClass<JSTabs>::StaticMethod("divider", &JSTabs::SetDivider);
690     JSClass<JSTabs>::StaticMethod("onChange", &JSTabs::SetOnChange);
691     JSClass<JSTabs>::StaticMethod("onTabBarClick", &JSTabs::SetOnTabBarClick);
692     JSClass<JSTabs>::StaticMethod("onAnimationStart", &JSTabs::SetOnAnimationStart);
693     JSClass<JSTabs>::StaticMethod("onAnimationEnd", &JSTabs::SetOnAnimationEnd);
694     JSClass<JSTabs>::StaticMethod("onGestureSwipe", &JSTabs::SetOnGestureSwipe);
695     JSClass<JSTabs>::StaticMethod("onAttach", &JSInteractableView::JsOnAttach);
696     JSClass<JSTabs>::StaticMethod("onAppear", &JSInteractableView::JsOnAppear);
697     JSClass<JSTabs>::StaticMethod("onDetach", &JSInteractableView::JsOnDetach);
698     JSClass<JSTabs>::StaticMethod("onDisAppear", &JSInteractableView::JsOnDisAppear);
699     JSClass<JSTabs>::StaticMethod("onTouch", &JSInteractableView::JsOnTouch);
700     JSClass<JSTabs>::StaticMethod("onHover", &JSInteractableView::JsOnHover);
701     JSClass<JSTabs>::StaticMethod("onKeyEvent", &JSInteractableView::JsOnKey);
702     JSClass<JSTabs>::StaticMethod("onDeleteEvent", &JSInteractableView::JsOnDelete);
703     JSClass<JSTabs>::StaticMethod("onClick", &JSInteractableView::JsOnClick);
704     JSClass<JSTabs>::StaticMethod("remoteMessage", &JSInteractableView::JsCommonRemoteMessage);
705     JSClass<JSTabs>::StaticMethod("fadingEdge", &JSTabs::SetFadingEdge);
706     JSClass<JSTabs>::StaticMethod("barOverlap", &JSTabs::SetBarOverlap);
707     JSClass<JSTabs>::StaticMethod("barBackgroundColor", &JSTabs::SetBarBackgroundColor);
708     JSClass<JSTabs>::StaticMethod("clip", &JSTabs::SetClip);
709     JSClass<JSTabs>::StaticMethod("barGridAlign", &JSTabs::SetBarGridAlign);
710     JSClass<JSTabs>::StaticMethod("customContentTransition", &JSTabs::SetCustomContentTransition);
711     JSClass<JSTabs>::StaticMethod("onContentWillChange", &JSTabs::SetOnContentWillChange);
712     JSClass<JSTabs>::StaticMethod("animationMode", &JSTabs::SetAnimateMode);
713     JSClass<JSTabs>::StaticMethod("edgeEffect", &JSTabs::SetEdgeEffect);
714 
715     JSClass<JSTabs>::InheritAndBind<JSContainerBase>(globalObj);
716 }
717 
718 } // namespace OHOS::Ace::Framework
719