1 /*
2 * Copyright (c) 2023-2025 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 #include "core/interfaces/native/node/grid_row_modifier.h"
16
17 #include "core/components_ng/pattern/grid_row/grid_row_model_ng.h"
18 #include "core/common/container.h"
19 #include "core/components_v2/grid_layout/grid_container_utils.h"
20
21 namespace OHOS::Ace::NG {
22 constexpr int XS = 0;
23 constexpr int SM = 1;
24 constexpr int MD = 2;
25 constexpr int LG = 3;
26 constexpr int XL = 4;
27 constexpr int XXL = 5;
28 constexpr int X_XS = 0;
29 constexpr int X_SM = 1;
30 constexpr int X_MD = 2;
31 constexpr int X_LG = 3;
32 constexpr int X_XL = 4;
33 constexpr int X_XXL = 5;
34 constexpr int Y_XS = 6;
35 constexpr int Y_SM = 7;
36 constexpr int Y_MD = 8;
37 constexpr int Y_LG = 9;
38 constexpr int Y_XL = 10;
39 constexpr int Y_XXL = 11;
SetAlignItems(ArkUINodeHandle node,int32_t alignItems)40 void SetAlignItems(ArkUINodeHandle node, int32_t alignItems)
41 {
42 auto* frameNode = reinterpret_cast<FrameNode*>(node);
43 CHECK_NULL_VOID(frameNode);
44 FlexAlign alignItemsValue = static_cast<FlexAlign>(alignItems);
45 GridRowModelNG::SetAlignItems(frameNode, alignItemsValue);
46 }
47
ResetAlignItems(ArkUINodeHandle node)48 void ResetAlignItems(ArkUINodeHandle node)
49 {
50 auto* frameNode = reinterpret_cast<FrameNode*>(node);
51 CHECK_NULL_VOID(frameNode);
52 FlexAlign resetValue = FlexAlign::FLEX_START;
53 GridRowModelNG::SetAlignItems(frameNode, resetValue);
54 }
55
InheritGridRowGutterOption(const RefPtr<V2::Gutter> & gutter,int32_t * gutterSizeArray)56 void InheritGridRowGutterOption(const RefPtr<V2::Gutter>& gutter,
57 int32_t *gutterSizeArray)
58 {
59 gutter->xXs = Dimension(gutterSizeArray[X_XS], DimensionUnit::VP);
60 gutter->xSm = Dimension(gutterSizeArray[X_SM], DimensionUnit::VP);
61 gutter->xMd = Dimension(gutterSizeArray[X_MD], DimensionUnit::VP);
62 gutter->xLg = Dimension(gutterSizeArray[X_LG], DimensionUnit::VP);
63 gutter->xXl = Dimension(gutterSizeArray[X_XL], DimensionUnit::VP);
64 gutter->xXXl = Dimension(gutterSizeArray[X_XXL], DimensionUnit::VP);
65 gutter->yXs = Dimension(gutterSizeArray[Y_XS], DimensionUnit::VP);
66 gutter->ySm = Dimension(gutterSizeArray[Y_SM], DimensionUnit::VP);
67 gutter->yMd = Dimension(gutterSizeArray[Y_MD], DimensionUnit::VP);
68 gutter->yLg = Dimension(gutterSizeArray[Y_LG], DimensionUnit::VP);
69 gutter->yXl = Dimension(gutterSizeArray[Y_XL], DimensionUnit::VP);
70 gutter->yXXl = Dimension(gutterSizeArray[Y_XXL], DimensionUnit::VP);
71 }
72
InheritGridRowOption(const RefPtr<OHOS::Ace::V2::GridContainerSize> & gridContainerSize,int32_t * containerSizeArray,int32_t size,int32_t defaultVal)73 void InheritGridRowOption(const RefPtr<OHOS::Ace::V2::GridContainerSize> &gridContainerSize,
74 int32_t *containerSizeArray, int32_t size, int32_t defaultVal)
75 {
76 if (containerSizeArray[0] == -1) {
77 containerSizeArray[0] = defaultVal;
78 }
79 for (int32_t i = 1; i < size; i++) {
80 if (containerSizeArray[i] == -1) {
81 containerSizeArray[i] = containerSizeArray[i - 1];
82 }
83 }
84 gridContainerSize->xs = containerSizeArray[XS];
85 gridContainerSize->sm = containerSizeArray[SM];
86 gridContainerSize->md = containerSizeArray[MD];
87 gridContainerSize->lg = containerSizeArray[LG];
88 gridContainerSize->xl = containerSizeArray[XL];
89 gridContainerSize->xxl = containerSizeArray[XXL];
90 }
91
SetDirection(ArkUINodeHandle node,int32_t direction)92 void SetDirection(ArkUINodeHandle node, int32_t direction)
93 {
94 auto* frameNode = reinterpret_cast<FrameNode*>(node);
95 CHECK_NULL_VOID(frameNode);
96
97 auto parsedDirection = static_cast<V2::GridRowDirection>(direction);
98 GridRowModelNG::SetDirection(frameNode, parsedDirection);
99 }
100
ResetDirection(ArkUINodeHandle node)101 void ResetDirection(ArkUINodeHandle node)
102 {
103 auto* frameNode = reinterpret_cast<FrameNode*>(node);
104 CHECK_NULL_VOID(frameNode);
105 auto direction = V2::GridRowDirection::Row;
106 GridRowModelNG::SetDirection(frameNode, direction);
107 }
108
SetBreakpoints(ArkUINodeHandle node,int32_t reference,const ArkUI_Float32 * pointValues,const char * pointStr[],int32_t size)109 void SetBreakpoints(ArkUINodeHandle node, int32_t reference, const ArkUI_Float32* pointValues,
110 const char* pointStr[], int32_t size)
111 {
112 auto* frameNode = reinterpret_cast<FrameNode*>(node);
113 CHECK_NULL_VOID(frameNode);
114
115 auto parsedBreakpoints = Referenced::MakeRefPtr<V2::BreakPoints>();
116 parsedBreakpoints->reference = static_cast<V2::BreakPointsReference>(reference);
117 if (size >= 0) {
118 parsedBreakpoints->breakpoints.clear();
119 double width = -1.0;
120 for (int32_t i = 0; i < size; i++) {
121 CalcDimension valueDimension = Dimension(pointValues[i], DimensionUnit::VP);
122 if (GreatNotEqual(width, valueDimension.Value())) {
123 break;
124 }
125 width = valueDimension.Value();
126 parsedBreakpoints->breakpoints.push_back(pointStr[i]);
127 }
128 }
129 GridRowModelNG::SetBreakpoints(frameNode, parsedBreakpoints);
130 }
131
ResetBreakpoints(ArkUINodeHandle node)132 void ResetBreakpoints(ArkUINodeHandle node)
133 {
134 auto* frameNode = reinterpret_cast<FrameNode*>(node);
135 CHECK_NULL_VOID(frameNode);
136 auto parsedBreakpoints = Referenced::MakeRefPtr<V2::BreakPoints>();
137 GridRowModelNG::SetBreakpoints(frameNode, parsedBreakpoints);
138 }
139
SetColumns(ArkUINodeHandle node,int32_t * containerSizeArray,int32_t size)140 void SetColumns(ArkUINodeHandle node, int32_t *containerSizeArray, int32_t size)
141 {
142 auto* frameNode = reinterpret_cast<FrameNode*>(node);
143 CHECK_NULL_VOID(frameNode);
144 if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWENTY)) {
145 auto parsedColumns = Referenced::MakeRefPtr<V2::GridContainerSize>(12);
146 InheritGridRowOption(parsedColumns, containerSizeArray, size, 0);
147 GridRowModelNG::SetColumns(frameNode, parsedColumns);
148 return;
149 }
150 auto parsedColumns = Referenced::MakeRefPtr<V2::GridContainerSize>();
151 V2::GridContainerUtils::InheritGridRowColumns(parsedColumns, containerSizeArray, size);
152 GridRowModelNG::SetColumns(frameNode, parsedColumns);
153 }
154
ResetColumns(ArkUINodeHandle node)155 void ResetColumns(ArkUINodeHandle node)
156 {
157 auto* frameNode = reinterpret_cast<FrameNode*>(node);
158 CHECK_NULL_VOID(frameNode);
159 if (Container::LessThanAPITargetVersion(PlatformVersion::VERSION_TWENTY)) {
160 auto parsedColumns = Referenced::MakeRefPtr<V2::GridContainerSize>(12);
161 GridRowModelNG::SetColumns(frameNode, parsedColumns);
162 return;
163 }
164 auto parsedColumns = Referenced::MakeRefPtr<V2::GridContainerSize>();
165 GridRowModelNG::SetColumns(frameNode, parsedColumns);
166 }
167
SetGutter(ArkUINodeHandle node,int32_t * containerSizeArray,int32_t size)168 void SetGutter(ArkUINodeHandle node, int32_t *containerSizeArray, int32_t size)
169 {
170 auto* frameNode = reinterpret_cast<FrameNode*>(node);
171 CHECK_NULL_VOID(frameNode);
172
173 auto parsedGutter = Referenced::MakeRefPtr<V2::Gutter>();
174 InheritGridRowGutterOption(parsedGutter, containerSizeArray);
175 GridRowModelNG::SetGutter(frameNode, parsedGutter);
176 }
177
ResetGutter(ArkUINodeHandle node)178 void ResetGutter(ArkUINodeHandle node)
179 {
180 auto* frameNode = reinterpret_cast<FrameNode*>(node);
181 CHECK_NULL_VOID(frameNode);
182 auto parsedGutter = Referenced::MakeRefPtr<V2::Gutter>();
183 GridRowModelNG::SetGutter(frameNode, parsedGutter);
184 }
185
SetOnBreakpointChange(ArkUINodeHandle node,void * callback)186 void SetOnBreakpointChange(ArkUINodeHandle node, void* callback)
187 {
188 auto* frameNode = reinterpret_cast<FrameNode*>(node);
189 CHECK_NULL_VOID(frameNode);
190 if (callback) {
191 auto onBreakpointChange = reinterpret_cast<std::function<void(const std::string&)>*>(callback);
192 GridRowModelNG::SetOnBreakPointChange(frameNode, std::move(*onBreakpointChange));
193 } else {
194 GridRowModelNG::SetOnBreakPointChange(frameNode, nullptr);
195 }
196 }
197
ResetOnBreakpointChange(ArkUINodeHandle node)198 void ResetOnBreakpointChange(ArkUINodeHandle node)
199 {
200 auto *frameNode = reinterpret_cast<FrameNode *>(node);
201 CHECK_NULL_VOID(frameNode);
202 GridRowModelNG::SetOnBreakPointChange(frameNode, nullptr);
203 }
204
205 namespace NodeModifier {
GetGridRowModifier()206 const ArkUIGridRowModifier* GetGridRowModifier()
207 {
208 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
209 static const ArkUIGridRowModifier modifier = {
210 .setAlignItems = SetAlignItems,
211 .resetAlignItems = ResetAlignItems,
212 .setDirection = SetDirection,
213 .resetDirection = ResetDirection,
214 .setBreakpoints = SetBreakpoints,
215 .resetBreakpoints = ResetBreakpoints,
216 .setColumns = SetColumns,
217 .resetColumns = ResetColumns,
218 .setGutter = SetGutter,
219 .resetGutter = ResetGutter,
220 .setOnBreakpointChange = SetOnBreakpointChange,
221 .resetOnBreakpointChange = ResetOnBreakpointChange,
222 };
223 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
224 return &modifier;
225 }
226
GetCJUIGridRowModifier()227 const CJUIGridRowModifier* GetCJUIGridRowModifier()
228 {
229 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
230 static const CJUIGridRowModifier modifier = {
231 .setAlignItems = SetAlignItems,
232 .resetAlignItems = ResetAlignItems,
233 .setDirection = SetDirection,
234 .resetDirection = ResetDirection,
235 .setBreakpoints = SetBreakpoints,
236 .resetBreakpoints = ResetBreakpoints,
237 .setColumns = SetColumns,
238 .resetColumns = ResetColumns,
239 .setGutter = SetGutter,
240 .resetGutter = ResetGutter,
241 };
242 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
243 return &modifier;
244 }
245 }
246 }
247