1 /*
2  * Copyright (c) 2021-2022 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_stack.h"
17 
18 #include "base/log/ace_trace.h"
19 #include "base/log/log_wrapper.h"
20 #include "core/common/container.h"
21 #include "frameworks/bridge/declarative_frontend/engine/js_ref_ptr.h"
22 #include "frameworks/bridge/declarative_frontend/jsview/js_view_common_def.h"
23 #include "frameworks/bridge/declarative_frontend/jsview/models/stack_model_impl.h"
24 #include "frameworks/core/components_ng/pattern/stack/stack_model_ng.h"
25 
26 namespace OHOS::Ace {
27 
28 std::unique_ptr<StackModel> StackModel::instance_ = nullptr;
29 std::mutex StackModel::mutex_;
30 
GetInstance()31 StackModel* StackModel::GetInstance()
32 {
33     if (!instance_) {
34         std::lock_guard<std::mutex> lock(mutex_);
35         if (!instance_) {
36 #ifdef NG_BUILD
37             instance_.reset(new NG::StackModelNG());
38 #else
39             if (Container::IsCurrentUseNewPipeline()) {
40                 instance_.reset(new NG::StackModelNG());
41             } else {
42                 instance_.reset(new Framework::StackModelImpl());
43             }
44 #endif
45         }
46     }
47     return instance_.get();
48 }
49 } // namespace OHOS::Ace
50 namespace OHOS::Ace::Framework {
51 
52 #define SET_ALIGNMENT(info, name)                        \
53     do {                                                 \
54         Alignment alignment = Alignment::TOP_LEFT;       \
55         if (!GetAlignment(info, alignment)) {            \
56             break;                                       \
57         }                                                \
58         StackModel::GetInstance()->Set##name(alignment); \
59     } while (false)
60 
61 const static std::array<Alignment, 9> ALIGNMENT_ARR { Alignment::TOP_LEFT, Alignment::TOP_CENTER, Alignment::TOP_RIGHT,
62     Alignment::CENTER_LEFT, Alignment::CENTER, Alignment::CENTER_RIGHT, Alignment::BOTTOM_LEFT,
63     Alignment::BOTTOM_CENTER, Alignment::BOTTOM_RIGHT };
64 
SetStackFit(int value)65 void JSStack::SetStackFit(int value)
66 {
67     if (value >= static_cast<int>(StackFit::KEEP) && value <= static_cast<int>(StackFit::FIRST_CHILD)) {
68         StackModel::GetInstance()->SetStackFit(static_cast<StackFit>(value));
69     }
70 }
71 
SetOverflow(int value)72 void JSStack::SetOverflow(int value)
73 {
74     if (value >= static_cast<int>(Overflow::CLIP) && value <= static_cast<int>(Overflow::OBSERVABLE)) {
75         StackModel::GetInstance()->SetOverflow(static_cast<Overflow>(value));
76     }
77 }
78 
GetAlignment(const JSCallbackInfo & info,Alignment & alignment)79 bool GetAlignment(const JSCallbackInfo& info, Alignment& alignment)
80 {
81     if (info.Length() != 1 || !info[0]->IsNumber()) {
82         StackModel::GetInstance()->SetAlignment(Alignment::CENTER);
83         return false;
84     }
85     auto value = info[0]->ToNumber<size_t>();
86     alignment = Alignment::TOP_LEFT;
87 
88     switch (value) {
89         case 0:
90             alignment = Alignment::TOP_LEFT;
91             break;
92         case 1:
93             alignment = Alignment::TOP_CENTER;
94             break;
95         case 2:
96             alignment = Alignment::TOP_RIGHT;
97             break;
98         case 3:
99             alignment = Alignment::CENTER_LEFT;
100             break;
101         case 4:
102             alignment = Alignment::CENTER;
103             break;
104         case 5:
105             alignment = Alignment::CENTER_RIGHT;
106             break;
107         case 6:
108             alignment = Alignment::BOTTOM_LEFT;
109             break;
110         case 7:
111             alignment = Alignment::BOTTOM_CENTER;
112             break;
113         case 8:
114             alignment = Alignment::BOTTOM_RIGHT;
115             break;
116         default:
117             return false;
118     }
119     return true;
120 }
121 
SetAlignment(const JSCallbackInfo & info)122 void JSStack::SetAlignment(const JSCallbackInfo& info)
123 {
124     SET_ALIGNMENT(info, Alignment);
125 }
126 
SetWidth(const JSCallbackInfo & info)127 void JSStack::SetWidth(const JSCallbackInfo& info)
128 {
129     if (info.Length() < 1) {
130         return;
131     }
132 
133     SetWidth(info[0]);
134 }
135 
SetWidth(const JSRef<JSVal> & jsValue)136 void JSStack::SetWidth(const JSRef<JSVal>& jsValue)
137 {
138     JSViewAbstract::JsWidth(jsValue);
139     StackModel::GetInstance()->SetHasWidth();
140 }
141 
SetHeight(const JSCallbackInfo & info)142 void JSStack::SetHeight(const JSCallbackInfo& info)
143 {
144     if (info.Length() < 1) {
145         return;
146     }
147 
148     SetHeight(info[0]);
149 }
150 
SetHeight(const JSRef<JSVal> & jsValue)151 void JSStack::SetHeight(const JSRef<JSVal>& jsValue)
152 {
153     JSViewAbstract::JsHeight(jsValue);
154     StackModel::GetInstance()->SetHasHeight();
155 }
156 
SetSize(const JSCallbackInfo & info)157 void JSStack::SetSize(const JSCallbackInfo& info)
158 {
159     if (info.Length() < 1) {
160         return;
161     }
162 
163     if (!info[0]->IsObject()) {
164         return;
165     }
166 
167     JSRef<JSObject> sizeObj = JSRef<JSObject>::Cast(info[0]);
168     SetWidth(sizeObj->GetProperty("width"));
169     SetHeight(sizeObj->GetProperty("height"));
170 }
171 
Create(const JSCallbackInfo & info)172 void JSStack::Create(const JSCallbackInfo& info)
173 {
174     Alignment alignment = Alignment::CENTER;
175 
176     if (info.Length() > 0 && info[0]->IsObject()) {
177         JSRef<JSObject> obj = JSRef<JSObject>::Cast(info[0]);
178         JSRef<JSVal> stackAlign = obj->GetProperty("alignContent");
179         if (stackAlign->IsNumber()) {
180             int32_t value = stackAlign->ToNumber<int32_t>();
181             if (value >= 0 && value < static_cast<int>(ALIGNMENT_ARR.size())) {
182                 alignment = ALIGNMENT_ARR[value];
183             } else {
184                 StackModel::GetInstance()->Create();
185                 return;
186             }
187         } else {
188             StackModel::GetInstance()->Create();
189             return;
190         }
191     } else {
192         StackModel::GetInstance()->Create();
193         return;
194     }
195 
196     StackModel::GetInstance()->Create(alignment);
197 }
198 
JSBind(BindingTarget globalObj)199 void JSStack::JSBind(BindingTarget globalObj)
200 {
201     JSClass<JSStack>::Declare("Stack");
202 
203     MethodOptions opt = MethodOptions::NONE;
204     JSClass<JSStack>::StaticMethod("create", &JSStack::Create, opt);
205     JSClass<JSStack>::StaticMethod("stackFit", &JSStack::SetStackFit, opt);
206     JSClass<JSStack>::StaticMethod("overflow", &JSStack::SetOverflow, opt);
207     JSClass<JSStack>::StaticMethod("align", &JSStack::SetAlignment, opt);
208     JSClass<JSStack>::StaticMethod("alignContent", &JSStack::SetAlignment, opt);
209     JSClass<JSStack>::StaticMethod("onTouch", &JSInteractableView::JsOnTouch);
210     JSClass<JSStack>::StaticMethod("width", SetWidth);
211     JSClass<JSStack>::StaticMethod("height", SetHeight);
212     JSClass<JSStack>::StaticMethod("size", SetSize);
213     JSClass<JSStack>::StaticMethod("onKeyEvent", &JSInteractableView::JsOnKey);
214     JSClass<JSStack>::StaticMethod("onDeleteEvent", &JSInteractableView::JsOnDelete);
215     JSClass<JSStack>::StaticMethod("onClick", &JSInteractableView::JsOnClick);
216     JSClass<JSStack>::StaticMethod("onHover", &JSInteractableView::JsOnHover);
217     JSClass<JSStack>::StaticMethod("onAttach", &JSInteractableView::JsOnAttach);
218     JSClass<JSStack>::StaticMethod("onAppear", &JSInteractableView::JsOnAppear);
219     JSClass<JSStack>::StaticMethod("onDetach", &JSInteractableView::JsOnDetach);
220     JSClass<JSStack>::StaticMethod("onDisAppear", &JSInteractableView::JsOnDisAppear);
221     JSClass<JSStack>::StaticMethod("remoteMessage", &JSInteractableView::JsCommonRemoteMessage);
222     JSClass<JSStack>::StaticMethod("pointLight", &JSViewAbstract::JsPointLight, opt);
223     JSClass<JSStack>::InheritAndBind<JSContainerBase>(globalObj);
224 }
225 
226 } // namespace OHOS::Ace::Framework
227