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