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
GetFlexWrap(FrameNode * frameNode)220 int FlexModelNG::GetFlexWrap(FrameNode* frameNode)
221 {
222 int value = 0;
223 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
224 if (!pattern->GetIsWrap()) {
225 value = static_cast<int>(FlexWrap::NO_WRAP);
226 } else {
227 WrapDirection direction = WrapDirection::HORIZONTAL;
228 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(
229 FlexLayoutProperty, WrapDirection, direction, frameNode, direction);
230 int intDirection = static_cast<int>(direction);
231 if (intDirection == 0 || intDirection == 1) {
232 value = static_cast<int>(FlexWrap::WRAP);
233 } else {
234 value = static_cast<int>(FlexWrap::WRAP_REVERSE);
235 }
236 }
237 return value;
238 }
239
GetFlexDirection(FrameNode * frameNode)240 int FlexModelNG::GetFlexDirection(FrameNode* frameNode)
241 {
242 FlexDirection value = FlexDirection::ROW;
243 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, FlexDirection, value, frameNode, value);
244 return static_cast<int>(value);
245 }
246
GetFlexJustifyContent(FrameNode * frameNode)247 int FlexModelNG::GetFlexJustifyContent(FrameNode* frameNode)
248 {
249 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
250 if (!pattern->GetIsWrap()) {
251 FlexAlign value = FlexAlign::AUTO;
252 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, MainAxisAlign, value, frameNode, value);
253 return static_cast<int>(value);
254 }
255 WrapAlignment value = WrapAlignment::START;
256 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, MainAlignment, value, frameNode, value);
257 return static_cast<int>(value);
258 }
259
GetFlexAlignItems(FrameNode * frameNode)260 int FlexModelNG::GetFlexAlignItems(FrameNode* frameNode)
261 {
262 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
263 if (!pattern->GetIsWrap()) {
264 FlexAlign value = FlexAlign::AUTO;
265 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, CrossAxisAlign, value, frameNode, value);
266 return static_cast<int>(value);
267 }
268 WrapAlignment value = WrapAlignment::START;
269 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, CrossAlignment, value, frameNode, value);
270 return static_cast<int>(value);
271 }
272
GetFlexAlignContent(FrameNode * frameNode)273 int FlexModelNG::GetFlexAlignContent(FrameNode* frameNode)
274 {
275 auto pattern = frameNode->GetPattern<FlexLayoutPattern>();
276 if (!pattern->GetIsWrap()) {
277 return 0;
278 }
279 WrapAlignment value = WrapAlignment::START;
280 ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(FlexLayoutProperty, Alignment, value, frameNode, value);
281 return static_cast<int>(value);
282 }
283
SetMainSpace(const std::optional<Dimension> & space)284 void FlexModelNG::SetMainSpace(const std::optional<Dimension>& space)
285 {
286 CHECK_NULL_VOID(space);
287 if (GreatOrEqual(space->Value(), 0.0)) {
288 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, Space, space.value());
289 }
290 }
291
SetCrossSpace(const std::optional<Dimension> & space)292 void FlexModelNG::SetCrossSpace(const std::optional<Dimension>& space)
293 {
294 CHECK_NULL_VOID(space);
295 if (GreatOrEqual(space->Value(), 0.0)) {
296 ACE_UPDATE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossSpace, space.value());
297 }
298 }
299
SetMainSpace(FrameNode * frameNode,const std::optional<Dimension> & space)300 void FlexModelNG::SetMainSpace(FrameNode* frameNode, const std::optional<Dimension>& space)
301 {
302 CHECK_NULL_VOID(space);
303 if (GreatOrEqual(space->Value(), 0.0)) {
304 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, Space, space.value(), frameNode);
305 }
306 }
307
SetCrossSpace(FrameNode * frameNode,const std::optional<Dimension> & space)308 void FlexModelNG::SetCrossSpace(FrameNode* frameNode, const std::optional<Dimension>& space)
309 {
310 CHECK_NULL_VOID(space);
311 if (GreatOrEqual(space->Value(), 0.0)) {
312 ACE_UPDATE_NODE_LAYOUT_PROPERTY(FlexLayoutProperty, CrossSpace, space.value(), frameNode);
313 }
314 }
315 } // namespace OHOS::Ace::NG
316