1 /*
2 * Copyright (c) 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 "core/components_ng/pattern/flex/flex_model_ng.h"
17
18 #include "core/components_ng/pattern/flex/flex_layout_pattern.h"
19
20 namespace OHOS::Ace::NG {
21
CreateFlexRow()22 void FlexModelNG::CreateFlexRow()
23 {
24 auto* stack = ViewStackProcessor::GetInstance();
25 auto nodeId = stack->ClaimNodeId();
26 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::FLEX_ETS_TAG, nodeId);
27 auto childFrameNode = FrameNode::GetFrameNode(V2::FLEX_ETS_TAG, nodeId);
28 if (!childFrameNode) {
29 auto frameNode = FrameNode::GetOrCreateFrameNode(
30 V2::FLEX_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<FlexLayoutPattern>(); });
31 stack->Push(frameNode);
32
33 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, FlexDirection, FlexDirection::ROW);
34 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, MainAxisAlign, FlexAlign::FLEX_START);
35 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossAxisAlign, FlexAlign::FLEX_START);
36 return;
37 }
38 stack->Push(childFrameNode);
39 auto pattern = childFrameNode->GetPattern<FlexLayoutPattern>();
40 if (!pattern->GetIsWrap()) {
41 return;
42 }
43 // wrap to flex
44 pattern->SetIsWrap(false);
45 auto layoutProperty = pattern->GetLayoutProperty<FlexLayoutProperty>();
46 CHECK_NULL_VOID(layoutProperty);
47 layoutProperty->ResetWrapLayoutAttribute();
48 }
49
CreateWrap()50 void FlexModelNG::CreateWrap()
51 {
52 auto* stack = ViewStackProcessor::GetInstance();
53 auto nodeId = stack->ClaimNodeId();
54 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::FLEX_ETS_TAG, nodeId);
55 auto childFrameNode = FrameNode::GetFrameNode(V2::FLEX_ETS_TAG, nodeId);
56 if (!childFrameNode) {
57 auto frameNode = FrameNode::GetOrCreateFrameNode(
58 V2::FLEX_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<FlexLayoutPattern>(true); });
59 stack->Push(frameNode);
60 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, WrapDirection, WrapDirection::HORIZONTAL);
61 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, Alignment, WrapAlignment::START);
62 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, MainAlignment, WrapAlignment::START);
63 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossAlignment, WrapAlignment::START);
64 return;
65 }
66 stack->Push(childFrameNode);
67 auto pattern = childFrameNode->GetPattern<FlexLayoutPattern>();
68 if (pattern->GetIsWrap()) {
69 return;
70 }
71 // flex to wrap
72 pattern->SetIsWrap(true);
73 auto layoutProperty = childFrameNode->GetLayoutProperty<FlexLayoutProperty>();
74 CHECK_NULL_VOID(layoutProperty);
75 layoutProperty->ResetFlexLayoutAttribute();
76 }
77
CreateFrameNode(int32_t nodeId)78 RefPtr<FrameNode> FlexModelNG::CreateFrameNode(int32_t nodeId)
79 {
80 auto frameNode = FrameNode::CreateFrameNode(
81 V2::FLEX_ETS_TAG, nodeId, AceType::MakeRefPtr<FlexLayoutPattern>());
82 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
83 auto layoutProperty = frameNode->GetLayoutProperty<FlexLayoutProperty>();
84 layoutProperty->UpdateFlexDirection(FlexDirection::ROW);
85 layoutProperty->UpdateMainAxisAlign(FlexAlign::FLEX_START);
86 layoutProperty->UpdateCrossAxisAlign(FlexAlign::FLEX_START);
87 return frameNode;
88 }
89
SetDirection(FlexDirection direction)90 void FlexModelNG::SetDirection(FlexDirection direction)
91 {
92 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, FlexDirection, direction);
93 }
94
SetWrapDirection(WrapDirection direction)95 void FlexModelNG::SetWrapDirection(WrapDirection direction)
96 {
97 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, WrapDirection, direction);
98 }
99
SetMainAxisAlign(FlexAlign align)100 void FlexModelNG::SetMainAxisAlign(FlexAlign align)
101 {
102 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, MainAxisAlign, align);
103 }
104
SetWrapMainAlignment(WrapAlignment value)105 void FlexModelNG::SetWrapMainAlignment(WrapAlignment value)
106 {
107 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, MainAlignment, value);
108 }
109
SetCrossAxisAlign(FlexAlign align)110 void FlexModelNG::SetCrossAxisAlign(FlexAlign align)
111 {
112 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossAxisAlign, align);
113 }
114
SetWrapCrossAlignment(WrapAlignment value)115 void FlexModelNG::SetWrapCrossAlignment(WrapAlignment value)
116 {
117 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossAlignment, value);
118 }
119
SetWrapAlignment(WrapAlignment value)120 void FlexModelNG::SetWrapAlignment(WrapAlignment value)
121 {
122 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, Alignment, value);
123 }
124
SetAlignItems(int32_t value)125 void FlexModelNG::SetAlignItems(int32_t value)
126 {
127 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
128 CHECK_NULL_VOID(frameNode);
129 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
130 if (!pattern->GetIsWrap()) {
131 SetCrossAxisAlign(static_cast<FlexAlign>(value));
132 return;
133 }
134 SetWrapCrossAlignment(static_cast<WrapAlignment>(value));
135 }
136
SetJustifyContent(int32_t value)137 void FlexModelNG::SetJustifyContent(int32_t value)
138 {
139 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
140 CHECK_NULL_VOID(frameNode);
141 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
142 if (!pattern->GetIsWrap()) {
143 SetMainAxisAlign(static_cast<FlexAlign>(value));
144 return;
145 }
146 SetWrapMainAlignment(static_cast<WrapAlignment>(value));
147 }
148
SetAlignContent(int32_t value)149 void FlexModelNG::SetAlignContent(int32_t value)
150 {
151 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
152 CHECK_NULL_VOID(frameNode);
153 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
154 if (!pattern->GetIsWrap()) {
155 return;
156 }
157 SetWrapAlignment(static_cast<WrapAlignment>(value));
158 }
159
SetFlexRow(FrameNode * frameNode)160 void FlexModelNG::SetFlexRow(FrameNode* frameNode)
161 {
162 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, FlexDirection, FlexDirection::ROW, frameNode);
163 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, MainAxisAlign, FlexAlign::FLEX_START, frameNode);
164 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossAxisAlign, FlexAlign::FLEX_START, frameNode);
165
166 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
167 pattern->SetIsWrap(false);
168 }
169
SetFlexWrap(FrameNode * frameNode)170 void FlexModelNG::SetFlexWrap(FrameNode* frameNode)
171 {
172 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, WrapDirection, WrapDirection::HORIZONTAL, frameNode);
173 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, Alignment, WrapAlignment::START, frameNode);
174 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, MainAlignment, WrapAlignment::START, frameNode);
175 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossAlignment, WrapAlignment::START, frameNode);
176
177 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
178 pattern->SetIsWrap(true);
179 }
180
SetFlexDirection(FrameNode * frameNode,FlexDirection value)181 void FlexModelNG::SetFlexDirection(FrameNode* frameNode, FlexDirection value)
182 {
183 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, FlexDirection, value, frameNode);
184 }
185
SetFlexWrapDirection(FrameNode * frameNode,WrapDirection value)186 void FlexModelNG::SetFlexWrapDirection(FrameNode* frameNode, WrapDirection value)
187 {
188 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, WrapDirection, value, frameNode);
189 }
190
SetFlexJustifyContent(FrameNode * frameNode,int32_t value)191 void FlexModelNG::SetFlexJustifyContent(FrameNode* frameNode, int32_t value)
192 {
193 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
194 if (!pattern->GetIsWrap()) {
195 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, MainAxisAlign, static_cast<FlexAlign>(value), frameNode);
196 return;
197 }
198 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, MainAlignment, static_cast<WrapAlignment>(value), frameNode);
199 }
200
SetFlexAlignItems(FrameNode * frameNode,int32_t value)201 void FlexModelNG::SetFlexAlignItems(FrameNode* frameNode, int32_t value)
202 {
203 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
204 if (!pattern->GetIsWrap()) {
205 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossAxisAlign, static_cast<FlexAlign>(value), frameNode);
206 return;
207 }
208 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossAlignment, static_cast<WrapAlignment>(value), frameNode);
209 }
210
SetFlexAlignContent(FrameNode * frameNode,int32_t value)211 void FlexModelNG::SetFlexAlignContent(FrameNode* frameNode, int32_t value)
212 {
213 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
214 if (!pattern->GetIsWrap()) {
215 return;
216 }
217 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, Alignment, static_cast<WrapAlignment>(value), frameNode);
218 }
219
SetWidthLayoutPolicy(uint8_t widthLayoutPolicy)220 void FlexModelNG::SetWidthLayoutPolicy(uint8_t widthLayoutPolicy)
221 {
222 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, WidthLayoutPolicy, widthLayoutPolicy);
223 }
224
SetWidthLayoutPolicy(FrameNode * frameNode,uint8_t widthLayoutPolicy)225 void FlexModelNG::SetWidthLayoutPolicy(FrameNode* frameNode, uint8_t widthLayoutPolicy)
226 {
227 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, WidthLayoutPolicy, widthLayoutPolicy, frameNode);
228 }
229
SetHeightLayoutPolicy(uint8_t heightLayoutPolicy)230 void FlexModelNG::SetHeightLayoutPolicy(uint8_t heightLayoutPolicy)
231 {
232 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, HeightLayoutPolicy, heightLayoutPolicy);
233 }
234
SetHeightLayoutPolicy(FrameNode * frameNode,uint8_t heightLayoutPolicy)235 void FlexModelNG::SetHeightLayoutPolicy(FrameNode* frameNode, uint8_t heightLayoutPolicy)
236 {
237 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, HeightLayoutPolicy, heightLayoutPolicy, frameNode);
238 }
239
GetFlexWrap(FrameNode * frameNode)240 int FlexModelNG::GetFlexWrap(FrameNode* frameNode)
241 {
242 int value = 0;
243 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
244 if (!pattern->GetIsWrap()) {
245 value = static_cast<int>(FlexWrap::NO_WRAP);
246 } else {
247 WrapDirection direction = WrapDirection::HORIZONTAL;
248 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
249 FlexLayoutProperty, WrapDirection, direction, frameNode, direction);
250 int intDirection = static_cast<int>(direction);
251 if (intDirection == 0 || intDirection == 1) {
252 value = static_cast<int>(FlexWrap::WRAP);
253 } else {
254 value = static_cast<int>(FlexWrap::WRAP_REVERSE);
255 }
256 }
257 return value;
258 }
259
GetFlexDirection(FrameNode * frameNode)260 int FlexModelNG::GetFlexDirection(FrameNode* frameNode)
261 {
262 FlexDirection value = FlexDirection::ROW;
263 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, FlexDirection, value, frameNode, value);
264 return static_cast<int>(value);
265 }
266
GetFlexJustifyContent(FrameNode * frameNode)267 int FlexModelNG::GetFlexJustifyContent(FrameNode* frameNode)
268 {
269 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
270 if (!pattern->GetIsWrap()) {
271 FlexAlign value = FlexAlign::AUTO;
272 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, MainAxisAlign, value, frameNode, value);
273 return static_cast<int>(value);
274 }
275 WrapAlignment value = WrapAlignment::START;
276 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, MainAlignment, value, frameNode, value);
277 return static_cast<int>(value);
278 }
279
GetFlexAlignItems(FrameNode * frameNode)280 int FlexModelNG::GetFlexAlignItems(FrameNode* frameNode)
281 {
282 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
283 if (!pattern->GetIsWrap()) {
284 FlexAlign value = FlexAlign::AUTO;
285 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, CrossAxisAlign, value, frameNode, value);
286 return static_cast<int>(value);
287 }
288 WrapAlignment value = WrapAlignment::START;
289 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, CrossAlignment, value, frameNode, value);
290 return static_cast<int>(value);
291 }
292
GetFlexAlignContent(FrameNode * frameNode)293 int FlexModelNG::GetFlexAlignContent(FrameNode* frameNode)
294 {
295 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
296 if (!pattern->GetIsWrap()) {
297 return 0;
298 }
299 WrapAlignment value = WrapAlignment::START;
300 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, Alignment, value, frameNode, value);
301 return static_cast<int>(value);
302 }
303
SetMainSpace(const std::optional<Dimension> & space)304 void FlexModelNG::SetMainSpace(const std::optional<Dimension>& space)
305 {
306 CHECK_NULL_VOID(space);
307 if (GreatOrEqual(space->Value(), 0.0)) {
308 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, Space, space.value());
309 }
310 }
311
SetCrossSpace(const std::optional<Dimension> & space)312 void FlexModelNG::SetCrossSpace(const std::optional<Dimension>& space)
313 {
314 CHECK_NULL_VOID(space);
315 if (GreatOrEqual(space->Value(), 0.0)) {
316 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossSpace, space.value());
317 }
318 }
319
SetMainSpace(FrameNode * frameNode,const std::optional<Dimension> & space)320 void FlexModelNG::SetMainSpace(FrameNode* frameNode, const std::optional<Dimension>& space)
321 {
322 CHECK_NULL_VOID(space);
323 if (GreatOrEqual(space->Value(), 0.0)) {
324 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, Space, space.value(), frameNode);
325 }
326 }
327
SetCrossSpace(FrameNode * frameNode,const std::optional<Dimension> & space)328 void FlexModelNG::SetCrossSpace(FrameNode* frameNode, const std::optional<Dimension>& space)
329 {
330 CHECK_NULL_VOID(space);
331 if (GreatOrEqual(space->Value(), 0.0)) {
332 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossSpace, space.value(), frameNode);
333 }
334 }
335 } // namespace OHOS::Ace::NG
336