1 /*
2 * Copyright (c) 2024 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 "render_node.h"
17
18 #include "node_model.h"
19
20 #include "base/error/error_code.h"
21 #include "base/utils/utils.h"
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26
27 std::map<int32_t, ArkUIRenderNodeHandle> g_renderNodeMap;
28 std::set<ArkUIRenderModifierHandle> g_modifierSet;
29 std::set<ArkUIPropertyHandle> g_propertySet;
30
OH_ArkUI_RenderNodeUtils_AddRenderNode(ArkUI_NodeHandle node,ArkUI_RenderNodeHandle child)31 int32_t OH_ArkUI_RenderNodeUtils_AddRenderNode(ArkUI_NodeHandle node, ArkUI_RenderNodeHandle child)
32 {
33 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
34 CHECK_NULL_RETURN(child, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
35 if (node->type != ArkUI_NodeType::ARKUI_NODE_CUSTOM) {
36 return OHOS::Ace::ERROR_CODE_NOT_CUSTOM_NODE;
37 }
38 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
39 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
40 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->addRenderNode(
41 node->uiNodeHandle, child->renderNodeHandle);
42 }
43
OH_ArkUI_RenderNodeUtils_RemoveRenderNode(ArkUI_NodeHandle node,ArkUI_RenderNodeHandle child)44 int32_t OH_ArkUI_RenderNodeUtils_RemoveRenderNode(ArkUI_NodeHandle node, ArkUI_RenderNodeHandle child)
45 {
46 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
47 CHECK_NULL_RETURN(child, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
48 if (node->type != ArkUI_NodeType::ARKUI_NODE_CUSTOM) {
49 return OHOS::Ace::ERROR_CODE_NOT_CUSTOM_NODE;
50 }
51 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
52 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
53 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->removeRenderNode(
54 node->uiNodeHandle, child->renderNodeHandle);
55 }
56
OH_ArkUI_RenderNodeUtils_ClearRenderNodeChildren(ArkUI_NodeHandle node)57 int32_t OH_ArkUI_RenderNodeUtils_ClearRenderNodeChildren(ArkUI_NodeHandle node)
58 {
59 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
60 if (node->type != ArkUI_NodeType::ARKUI_NODE_CUSTOM) {
61 return OHOS::Ace::ERROR_CODE_NOT_CUSTOM_NODE;
62 }
63 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
64 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
65 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->clearRenderNodeChildren(node->uiNodeHandle);
66 }
67
OH_ArkUI_RenderNodeUtils_Invalidate(ArkUI_NodeHandle node)68 int32_t OH_ArkUI_RenderNodeUtils_Invalidate(ArkUI_NodeHandle node)
69 {
70 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
71 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
72 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
73 impl->getNodeModifiers()->getFrameNodeModifier()->invalidate(node->uiNodeHandle);
74 return OHOS::Ace::ERROR_CODE_NO_ERROR;
75 }
76
OH_ArkUI_RenderNodeUtils_CreateNode()77 ArkUI_RenderNodeHandle OH_ArkUI_RenderNodeUtils_CreateNode()
78 {
79 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
80 CHECK_NULL_RETURN(impl, nullptr);
81
82 int32_t nodeId = 0;
83 auto* renderNode = impl->getNodeModifiers()->getNDKRenderNodeModifier()->createNode(&nodeId);
84 if (!renderNode) {
85 return nullptr;
86 }
87 ArkUI_RenderNode* arkUIRenderNode = new ArkUI_RenderNode({ renderNode });
88 g_renderNodeMap.insert(std::pair<int32_t, ArkUIRenderNodeHandle>(nodeId, renderNode));
89 return arkUIRenderNode;
90 }
91
OH_ArkUI_RenderNodeUtils_DisposeNode(ArkUI_RenderNodeHandle node)92 int32_t OH_ArkUI_RenderNodeUtils_DisposeNode(ArkUI_RenderNodeHandle node)
93 {
94 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
95 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
96 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
97 auto nodeId = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getId(node->renderNodeHandle);
98 if (nodeId == 0) {
99 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
100 }
101 auto it = g_renderNodeMap.find(nodeId);
102 if (it != g_renderNodeMap.end()) {
103 g_renderNodeMap.erase(it);
104 }
105 delete node;
106 node = nullptr;
107 return OHOS::Ace::ERROR_CODE_NO_ERROR;
108 }
109
OH_ArkUI_RenderNodeUtils_AddChild(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeHandle child)110 int32_t OH_ArkUI_RenderNodeUtils_AddChild(ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle child)
111 {
112 CHECK_NULL_RETURN(node && child, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
113 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
114 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
115 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->addChild(
116 node->renderNodeHandle, child->renderNodeHandle);
117 }
118
OH_ArkUI_RenderNodeUtils_InsertChildAfter(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeHandle child,ArkUI_RenderNodeHandle sibling)119 int32_t OH_ArkUI_RenderNodeUtils_InsertChildAfter(
120 ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle child, ArkUI_RenderNodeHandle sibling)
121 {
122 CHECK_NULL_RETURN(node && child && sibling, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
123 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
124 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
125 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->insertChildAfter(
126 node->renderNodeHandle, child->renderNodeHandle, sibling->renderNodeHandle);
127 }
128
OH_ArkUI_RenderNodeUtils_RemoveChild(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeHandle child)129 int32_t OH_ArkUI_RenderNodeUtils_RemoveChild(ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle child)
130 {
131 CHECK_NULL_RETURN(node && child, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
132 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
133 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
134 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->removeChild(
135 node->renderNodeHandle, child->renderNodeHandle);
136 }
137
OH_ArkUI_RenderNodeUtils_ClearChildren(ArkUI_RenderNodeHandle node)138 int32_t OH_ArkUI_RenderNodeUtils_ClearChildren(ArkUI_RenderNodeHandle node)
139 {
140 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
141 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
142 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
143 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->clearChildren(node->renderNodeHandle);
144 }
145
OH_ArkUI_RenderNodeUtils_GetChild(ArkUI_RenderNodeHandle node,int32_t index,ArkUI_RenderNodeHandle * child)146 int32_t OH_ArkUI_RenderNodeUtils_GetChild(ArkUI_RenderNodeHandle node, int32_t index, ArkUI_RenderNodeHandle* child)
147 {
148 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
149 if (index < 0) {
150 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
151 }
152 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
153 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
154 ArkUIRenderNodeHandle renderNode;
155 int32_t nodeId = 0;
156 auto result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getChild(
157 node->renderNodeHandle, index, &renderNode, &nodeId);
158 if (result == OHOS::Ace::ERROR_CODE_NO_ERROR) {
159 // Find in map first, try return same handle.
160 auto it = g_renderNodeMap.find(nodeId);
161 if (it != g_renderNodeMap.end()) {
162 // delete renderNode;
163 renderNode = it->second;
164 }
165 // If don't exit, create a new handle.
166 *child = new ArkUI_RenderNode({ renderNode });
167 g_renderNodeMap.insert(std::pair<int32_t, ArkUIRenderNodeHandle>(nodeId, renderNode));
168 }
169 return result;
170 }
171
OH_ArkUI_RenderNodeUtils_GetFirstChild(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeHandle * child)172 int32_t OH_ArkUI_RenderNodeUtils_GetFirstChild(ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle* child)
173 {
174 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
175 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
176 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
177 ArkUIRenderNodeHandle renderNode;
178 int32_t nodeId = 0;
179 auto result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getFirstChild(
180 node->renderNodeHandle, &renderNode, &nodeId);
181 if (result == OHOS::Ace::ERROR_CODE_NO_ERROR) {
182 // Find in map first, try return same handle.
183 auto it = g_renderNodeMap.find(nodeId);
184 if (it != g_renderNodeMap.end()) {
185 // delete renderNode;
186 renderNode = it->second;
187 }
188 // If don't exit, create a new handle.
189 *child = new ArkUI_RenderNode({ renderNode });
190 g_renderNodeMap.insert(std::pair<int32_t, ArkUIRenderNodeHandle>(nodeId, renderNode));
191 }
192 return result;
193 }
194
OH_ArkUI_RenderNodeUtils_GetNextSibling(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeHandle * sibling)195 int32_t OH_ArkUI_RenderNodeUtils_GetNextSibling(ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle* sibling)
196 {
197 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
198 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
199 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
200 ArkUIRenderNodeHandle renderNode;
201 int32_t nodeId = 0;
202 auto result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getNextSibling(
203 node->renderNodeHandle, &renderNode, &nodeId);
204 if (result == OHOS::Ace::ERROR_CODE_NO_ERROR) {
205 // Find in map first, try return same handle.
206 auto it = g_renderNodeMap.find(nodeId);
207 if (it != g_renderNodeMap.end()) {
208 // delete renderNode;
209 renderNode = it->second;
210 }
211 // If don't exit, create a new handle.
212 *sibling = new ArkUI_RenderNode({ renderNode });
213 g_renderNodeMap.insert(std::pair<int32_t, ArkUIRenderNodeHandle>(nodeId, renderNode));
214 }
215 return result;
216 }
217
OH_ArkUI_RenderNodeUtils_GetPreviousSibling(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeHandle * sibling)218 int32_t OH_ArkUI_RenderNodeUtils_GetPreviousSibling(ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle* sibling)
219 {
220 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
221 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
222 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
223 ArkUIRenderNodeHandle renderNode;
224 int32_t nodeId = 0;
225 auto result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getPreviousSibling(
226 node->renderNodeHandle, &renderNode, &nodeId);
227 if (result == OHOS::Ace::ERROR_CODE_NO_ERROR) {
228 // Find in map first, try return same handle.
229 auto it = g_renderNodeMap.find(nodeId);
230 if (it != g_renderNodeMap.end()) {
231 // delete renderNode;
232 renderNode = it->second;
233 }
234 // If don't exit, create a new handle.
235 *sibling = new ArkUI_RenderNode({ renderNode });
236 g_renderNodeMap.insert(std::pair<int32_t, ArkUIRenderNodeHandle>(nodeId, renderNode));
237 }
238 return result;
239 }
240
OH_ArkUI_RenderNodeUtils_GetChildren(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeHandle ** children,int32_t * count)241 int32_t OH_ArkUI_RenderNodeUtils_GetChildren(
242 ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle** children, int32_t* count)
243 {
244 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
245 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
246 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
247 ArkUIRenderNodeHandle* renderNode;
248 uint32_t* nodeId;
249 int32_t nodeCount = 0;
250 auto result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getChildren(
251 node->renderNodeHandle, &renderNode, &nodeId, &nodeCount);
252 *count = nodeCount;
253 if (nodeCount > 0 && result == OHOS::Ace::ERROR_CODE_NO_ERROR) {
254 ArkUI_RenderNodeHandle* childrenList = new ArkUI_RenderNodeHandle[nodeCount];
255 for (int32_t i = 0; i < nodeCount; i++) {
256 childrenList[i] = new ArkUI_RenderNode({ renderNode[i] });
257 g_renderNodeMap.insert(std::pair<int32_t, ArkUIRenderNodeHandle>(nodeId[i], renderNode[i]));
258 }
259 *children = childrenList;
260 }
261 return result;
262 }
263
OH_ArkUI_RenderNodeUtils_GetChildrenCount(ArkUI_RenderNodeHandle node,int32_t * count)264 int32_t OH_ArkUI_RenderNodeUtils_GetChildrenCount(ArkUI_RenderNodeHandle node, int32_t* count)
265 {
266 CHECK_NULL_RETURN(node, OHOS::Ace::ERROR_CODE_PARAM_INVALID);
267 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
268 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
269 int32_t childCount;
270 auto result =
271 impl->getNodeModifiers()->getNDKRenderNodeModifier()->getChildrenCount(node->renderNodeHandle, &childCount);
272 if (result == OHOS::Ace::ERROR_CODE_NO_ERROR) {
273 *count = childCount;
274 }
275 return result;
276 }
277
OH_ArkUI_RenderNodeUtils_SetBackgroundColor(ArkUI_RenderNodeHandle node,uint32_t color)278 int32_t OH_ArkUI_RenderNodeUtils_SetBackgroundColor(ArkUI_RenderNodeHandle node, uint32_t color)
279 {
280 if (node == nullptr) {
281 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
282 }
283 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
284 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
285 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setBackgroundColor(node->renderNodeHandle, color);
286 }
287
OH_ArkUI_RenderNodeUtils_GetBackgroundColor(ArkUI_RenderNodeHandle node,uint32_t * color)288 int32_t OH_ArkUI_RenderNodeUtils_GetBackgroundColor(ArkUI_RenderNodeHandle node, uint32_t* color)
289 {
290 if (node == nullptr) {
291 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
292 }
293 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
294 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
295 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getBackgroundColor(node->renderNodeHandle, color);
296 }
297
OH_ArkUI_RenderNodeUtils_SetOpacity(ArkUI_RenderNodeHandle node,float opacity)298 int32_t OH_ArkUI_RenderNodeUtils_SetOpacity(ArkUI_RenderNodeHandle node, float opacity)
299 {
300 if (node == nullptr) {
301 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
302 }
303 if (!OHOS::Ace::InRegion(0, 1, opacity)) {
304 return OHOS::Ace::ERROR_CODE_PARAM_OUT_OF_RANGE;
305 }
306 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
307 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
308 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setOpacity(node->renderNodeHandle, opacity);
309 }
310
OH_ArkUI_RenderNodeUtils_GetOpacity(ArkUI_RenderNodeHandle node,float * opacity)311 int32_t OH_ArkUI_RenderNodeUtils_GetOpacity(ArkUI_RenderNodeHandle node, float* opacity)
312 {
313 if (node == nullptr) {
314 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
315 }
316 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
317 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
318 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getOpacity(node->renderNodeHandle, opacity);
319 }
320
OH_ArkUI_RenderNodeUtils_SetSize(ArkUI_RenderNodeHandle node,int32_t width,int32_t height)321 int32_t OH_ArkUI_RenderNodeUtils_SetSize(ArkUI_RenderNodeHandle node, int32_t width, int32_t height)
322 {
323 if (node == nullptr) {
324 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
325 }
326 if (width < 0 || height < 0) {
327 return OHOS::Ace::ERROR_CODE_PARAM_OUT_OF_RANGE;
328 }
329 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
330 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
331 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setSize(node->renderNodeHandle, width, height);
332 }
333
OH_ArkUI_RenderNodeUtils_GetSize(ArkUI_RenderNodeHandle node,int32_t * width,int32_t * height)334 int32_t OH_ArkUI_RenderNodeUtils_GetSize(ArkUI_RenderNodeHandle node, int32_t* width, int32_t* height)
335 {
336 if (node == nullptr) {
337 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
338 }
339 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
340 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
341 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getSize(node->renderNodeHandle, width, height);
342 }
343
OH_ArkUI_RenderNodeUtils_SetPosition(ArkUI_RenderNodeHandle node,int32_t x,int32_t y)344 int32_t OH_ArkUI_RenderNodeUtils_SetPosition(ArkUI_RenderNodeHandle node, int32_t x, int32_t y)
345 {
346 if (node == nullptr) {
347 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
348 }
349 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
350 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
351 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setPosition(node->renderNodeHandle, x, y);
352 }
353
OH_ArkUI_RenderNodeUtils_GetPosition(ArkUI_RenderNodeHandle node,int32_t * x,int32_t * y)354 int32_t OH_ArkUI_RenderNodeUtils_GetPosition(ArkUI_RenderNodeHandle node, int32_t* x, int32_t* y)
355 {
356 if (node == nullptr) {
357 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
358 }
359 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
360 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
361 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getPosition(node->renderNodeHandle, x, y);
362 }
363
OH_ArkUI_RenderNodeUtils_SetPivot(ArkUI_RenderNodeHandle node,float x,float y)364 int32_t OH_ArkUI_RenderNodeUtils_SetPivot(ArkUI_RenderNodeHandle node, float x, float y)
365 {
366 if (node == nullptr) {
367 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
368 }
369 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
370 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
371 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setPivot(node->renderNodeHandle, x, y);
372 }
373
OH_ArkUI_RenderNodeUtils_GetPivot(ArkUI_RenderNodeHandle node,float * x,float * y)374 int32_t OH_ArkUI_RenderNodeUtils_GetPivot(ArkUI_RenderNodeHandle node, float* x, float* y)
375 {
376 if (node == nullptr) {
377 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
378 }
379 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
380 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
381 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getPivot(node->renderNodeHandle, x, y);
382 }
383
OH_ArkUI_RenderNodeUtils_SetScale(ArkUI_RenderNodeHandle node,float x,float y)384 int32_t OH_ArkUI_RenderNodeUtils_SetScale(ArkUI_RenderNodeHandle node, float x, float y)
385 {
386 if (node == nullptr) {
387 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
388 }
389 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
390 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
391 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setScale(node->renderNodeHandle, x, y);
392 }
393
OH_ArkUI_RenderNodeUtils_GetScale(ArkUI_RenderNodeHandle node,float * x,float * y)394 int32_t OH_ArkUI_RenderNodeUtils_GetScale(ArkUI_RenderNodeHandle node, float* x, float* y)
395 {
396 if (node == nullptr) {
397 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
398 }
399 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
400 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
401 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getScale(node->renderNodeHandle, x, y);
402 }
403
OH_ArkUI_RenderNodeUtils_SetTranslation(ArkUI_RenderNodeHandle node,float x,float y)404 int32_t OH_ArkUI_RenderNodeUtils_SetTranslation(ArkUI_RenderNodeHandle node, float x, float y)
405 {
406 if (node == nullptr) {
407 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
408 }
409 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
410 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
411 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setTranslation(node->renderNodeHandle, x, y);
412 }
413
OH_ArkUI_RenderNodeUtils_GetTranslation(ArkUI_RenderNodeHandle node,float * x,float * y)414 int32_t OH_ArkUI_RenderNodeUtils_GetTranslation(ArkUI_RenderNodeHandle node, float* x, float* y)
415 {
416 if (node == nullptr) {
417 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
418 }
419 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
420 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
421 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getTranslation(node->renderNodeHandle, x, y);
422 }
423
OH_ArkUI_RenderNodeUtils_SetRotation(ArkUI_RenderNodeHandle node,float x,float y,float z)424 int32_t OH_ArkUI_RenderNodeUtils_SetRotation(ArkUI_RenderNodeHandle node, float x, float y, float z)
425 {
426 if (node == nullptr) {
427 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
428 }
429 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
430 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
431 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setRotation(node->renderNodeHandle, x, y, z);
432 }
433
OH_ArkUI_RenderNodeUtils_GetRotation(ArkUI_RenderNodeHandle node,float * x,float * y,float * z)434 int32_t OH_ArkUI_RenderNodeUtils_GetRotation(ArkUI_RenderNodeHandle node, float* x, float* y, float* z)
435 {
436 if (node == nullptr) {
437 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
438 }
439 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
440 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
441 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getRotation(node->renderNodeHandle, x, y, z);
442 }
443
OH_ArkUI_RenderNodeUtils_SetTransform(ArkUI_RenderNodeHandle node,float * matrix)444 int32_t OH_ArkUI_RenderNodeUtils_SetTransform(ArkUI_RenderNodeHandle node, float* matrix)
445 {
446 if (node == nullptr) {
447 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
448 }
449 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
450 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
451 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setTransform(node->renderNodeHandle, matrix);
452 }
453
OH_ArkUI_RenderNodeUtils_SetShadowColor(ArkUI_RenderNodeHandle node,uint32_t color)454 int32_t OH_ArkUI_RenderNodeUtils_SetShadowColor(ArkUI_RenderNodeHandle node, uint32_t color)
455 {
456 if (node == nullptr) {
457 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
458 }
459 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
460 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
461 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setShadowColor(node->renderNodeHandle, color);
462 }
463
OH_ArkUI_RenderNodeUtils_GetShadowColor(ArkUI_RenderNodeHandle node,uint32_t * color)464 int32_t OH_ArkUI_RenderNodeUtils_GetShadowColor(ArkUI_RenderNodeHandle node, uint32_t* color)
465 {
466 if (node == nullptr) {
467 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
468 }
469 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
470 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
471 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getShadowColor(node->renderNodeHandle, color);
472 }
473
OH_ArkUI_RenderNodeUtils_SetShadowOffset(ArkUI_RenderNodeHandle node,int32_t x,int32_t y)474 int32_t OH_ArkUI_RenderNodeUtils_SetShadowOffset(ArkUI_RenderNodeHandle node, int32_t x, int32_t y)
475 {
476 if (node == nullptr) {
477 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
478 }
479 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
480 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
481 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setShadowOffset(node->renderNodeHandle, x, y);
482 }
483
OH_ArkUI_RenderNodeUtils_GetShadowOffset(ArkUI_RenderNodeHandle node,int32_t * x,int32_t * y)484 int32_t OH_ArkUI_RenderNodeUtils_GetShadowOffset(ArkUI_RenderNodeHandle node, int32_t* x, int32_t* y)
485 {
486 if (node == nullptr) {
487 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
488 }
489 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
490 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
491 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getShadowOffset(node->renderNodeHandle, x, y);
492 }
493
OH_ArkUI_RenderNodeUtils_SetShadowAlpha(ArkUI_RenderNodeHandle node,float alpha)494 int32_t OH_ArkUI_RenderNodeUtils_SetShadowAlpha(ArkUI_RenderNodeHandle node, float alpha)
495 {
496 if (node == nullptr) {
497 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
498 }
499 if (!OHOS::Ace::InRegion(0, 1, alpha)) {
500 return OHOS::Ace::ERROR_CODE_PARAM_OUT_OF_RANGE;
501 }
502 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
503 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
504 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setShadowAlpha(node->renderNodeHandle, alpha);
505 }
506
OH_ArkUI_RenderNodeUtils_GetShadowAlpha(ArkUI_RenderNodeHandle node,float * alpha)507 int32_t OH_ArkUI_RenderNodeUtils_GetShadowAlpha(ArkUI_RenderNodeHandle node, float* alpha)
508 {
509 if (node == nullptr) {
510 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
511 }
512 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
513 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
514 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getShadowAlpha(node->renderNodeHandle, alpha);
515 }
516
OH_ArkUI_RenderNodeUtils_SetShadowElevation(ArkUI_RenderNodeHandle node,float elevation)517 int32_t OH_ArkUI_RenderNodeUtils_SetShadowElevation(ArkUI_RenderNodeHandle node, float elevation)
518 {
519 if (node == nullptr) {
520 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
521 }
522 if (elevation < 0) {
523 return OHOS::Ace::ERROR_CODE_PARAM_OUT_OF_RANGE;
524 }
525 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
526 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
527 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setShadowElevation(node->renderNodeHandle, elevation);
528 }
529
OH_ArkUI_RenderNodeUtils_GetShadowElevation(ArkUI_RenderNodeHandle node,float * radius)530 int32_t OH_ArkUI_RenderNodeUtils_GetShadowElevation(ArkUI_RenderNodeHandle node, float* radius)
531 {
532 if (node == nullptr) {
533 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
534 }
535 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
536 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
537 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getShadowElevation(node->renderNodeHandle, radius);
538 }
539
OH_ArkUI_RenderNodeUtils_GetShadowRadius(ArkUI_RenderNodeHandle node,float * radius)540 int32_t OH_ArkUI_RenderNodeUtils_GetShadowRadius(ArkUI_RenderNodeHandle node, float* radius)
541 {
542 if (node == nullptr) {
543 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
544 }
545 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
546 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
547 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getShadowRadius(node->renderNodeHandle, radius);
548 }
549
OH_ArkUI_RenderNodeUtils_SetShadowRadius(ArkUI_RenderNodeHandle node,float radius)550 int32_t OH_ArkUI_RenderNodeUtils_SetShadowRadius(ArkUI_RenderNodeHandle node, float radius)
551 {
552 if (node == nullptr) {
553 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
554 }
555 if (radius < 0) {
556 return OHOS::Ace::ERROR_CODE_PARAM_OUT_OF_RANGE;
557 }
558 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
559 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
560 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setShadowRadius(node->renderNodeHandle, radius);
561 }
562
OH_ArkUI_RenderNodeUtils_SetBorderStyle(ArkUI_RenderNodeHandle node,ArkUI_NodeBorderStyleOption * borderStyle)563 int32_t OH_ArkUI_RenderNodeUtils_SetBorderStyle(ArkUI_RenderNodeHandle node, ArkUI_NodeBorderStyleOption* borderStyle)
564 {
565 if (node == nullptr || borderStyle == nullptr) {
566 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
567 }
568 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
569 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
570 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setBorderStyle(node->renderNodeHandle,
571 borderStyle->leftStyle, borderStyle->topStyle, borderStyle->rightStyle, borderStyle->bottomStyle);
572 }
573
OH_ArkUI_RenderNodeUtils_GetBorderStyle(ArkUI_RenderNodeHandle node,ArkUI_NodeBorderStyleOption ** borderStyle)574 int32_t OH_ArkUI_RenderNodeUtils_GetBorderStyle(ArkUI_RenderNodeHandle node, ArkUI_NodeBorderStyleOption** borderStyle)
575 {
576 if (node == nullptr) {
577 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
578 }
579
580 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
581 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
582 int32_t code = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getBorderStyle(node->renderNodeHandle,
583 reinterpret_cast<uint32_t*>(&((*borderStyle)->leftStyle)),
584 reinterpret_cast<uint32_t*>(&((*borderStyle)->topStyle)),
585 reinterpret_cast<uint32_t*>(&((*borderStyle)->rightStyle)),
586 reinterpret_cast<uint32_t*>(&((*borderStyle)->leftStyle)));
587 return code;
588 }
589
OH_ArkUI_RenderNodeUtils_SetBorderWidth(ArkUI_RenderNodeHandle node,ArkUI_NodeBorderWidthOption * borderWidth)590 int32_t OH_ArkUI_RenderNodeUtils_SetBorderWidth(ArkUI_RenderNodeHandle node, ArkUI_NodeBorderWidthOption* borderWidth)
591 {
592 if (node == nullptr || borderWidth == nullptr) {
593 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
594 }
595 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
596 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
597 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setBorderWidth(node->renderNodeHandle,
598 borderWidth->leftWidth, borderWidth->topWidth, borderWidth->rightWidth, borderWidth->bottomWidth);
599 }
600
OH_ArkUI_RenderNodeUtils_GetBorderWidth(ArkUI_RenderNodeHandle node,ArkUI_NodeBorderWidth ** borderWidth)601 int32_t OH_ArkUI_RenderNodeUtils_GetBorderWidth(ArkUI_RenderNodeHandle node, ArkUI_NodeBorderWidth** borderWidth)
602 {
603 if (node == nullptr) {
604 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
605 }
606 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
607 int32_t code = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getBorderWidth(node->renderNodeHandle,
608 reinterpret_cast<float*>(&((*borderWidth)->leftWidth)), reinterpret_cast<float*>(&((*borderWidth)->topWidth)),
609 reinterpret_cast<float*>(&((*borderWidth)->rightWidth)),
610 reinterpret_cast<float*>(&((*borderWidth)->leftWidth)));
611 return code;
612 }
613
OH_ArkUI_RenderNodeUtils_SetBorderColor(ArkUI_RenderNodeHandle node,ArkUI_NodeBorderColor * borderColor)614 int32_t OH_ArkUI_RenderNodeUtils_SetBorderColor(ArkUI_RenderNodeHandle node, ArkUI_NodeBorderColor* borderColor)
615 {
616 if (node == nullptr || borderColor == nullptr) {
617 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
618 }
619 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
620 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
621 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setBorderColor(node->renderNodeHandle,
622 borderColor->leftColor, borderColor->topColor, borderColor->rightColor, borderColor->bottomColor);
623 }
624
OH_ArkUI_RenderNodeUtils_GetBorderColor(ArkUI_RenderNodeHandle node,ArkUI_NodeBorderColor ** borderColor)625 int32_t OH_ArkUI_RenderNodeUtils_GetBorderColor(ArkUI_RenderNodeHandle node, ArkUI_NodeBorderColor** borderColor)
626 {
627 if (node == nullptr) {
628 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
629 }
630 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
631 int32_t code = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getBorderColor(node->renderNodeHandle,
632 reinterpret_cast<uint32_t*>(&((*borderColor)->leftColor)),
633 reinterpret_cast<uint32_t*>(&((*borderColor)->topColor)),
634 reinterpret_cast<uint32_t*>(&((*borderColor)->rightColor)),
635 reinterpret_cast<uint32_t*>(&((*borderColor)->leftColor)));
636 return code;
637 }
638
OH_ArkUI_RenderNodeUtils_SetBorderRadius(ArkUI_RenderNodeHandle node,ArkUI_NodeBorderRadiusOption * borderRadius)639 int32_t OH_ArkUI_RenderNodeUtils_SetBorderRadius(ArkUI_RenderNodeHandle node,
640 ArkUI_NodeBorderRadiusOption* borderRadius)
641 {
642 if (node == nullptr || borderRadius == nullptr) {
643 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
644 }
645 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
646 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setBorderRadius(node->renderNodeHandle,
647 borderRadius->topLeftRadius, borderRadius->topRightRadius,
648 borderRadius->bottomLeftRadius, borderRadius->bottomRightRadius);
649 }
650
OH_ArkUI_RenderNodeUtils_GetBorderRadius(ArkUI_RenderNodeHandle node,ArkUI_NodeBorderRadiusOption ** borderRadius)651 int32_t OH_ArkUI_RenderNodeUtils_GetBorderRadius(ArkUI_RenderNodeHandle node,
652 ArkUI_NodeBorderRadiusOption** borderRadius)
653 {
654 if (node == nullptr) {
655 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
656 }
657 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
658 int32_t code = impl->getNodeModifiers()->getNDKRenderNodeModifier()->getBorderRadius(node->renderNodeHandle,
659 reinterpret_cast<float*>(&((*borderRadius)->topLeftRadius)),
660 reinterpret_cast<float*>(&((*borderRadius)->topRightRadius)),
661 reinterpret_cast<float*>(&((*borderRadius)->bottomLeftRadius)),
662 reinterpret_cast<float*>(&((*borderRadius)->bottomRightRadius)));
663 return code;
664 }
665
OH_ArkUI_RenderNodeUtils_SetMarkNodeGroup(ArkUI_RenderNodeHandle node,bool markNodeGroup)666 int32_t OH_ArkUI_RenderNodeUtils_SetMarkNodeGroup(ArkUI_RenderNodeHandle node, bool markNodeGroup)
667 {
668 if (node == nullptr) {
669 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
670 }
671 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
672 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
673 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setMarkNodeGroup(node->renderNodeHandle,
674 static_cast<int32_t>(markNodeGroup));
675 }
676
OH_ArkUI_RenderNodeUtils_SetBounds(ArkUI_RenderNodeHandle node,int32_t x,int32_t y,int32_t width,int32_t height)677 int32_t OH_ArkUI_RenderNodeUtils_SetBounds(ArkUI_RenderNodeHandle node,
678 int32_t x, int32_t y, int32_t width, int32_t height)
679 {
680 if (node == nullptr) {
681 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
682 }
683 if (width < 0 || height < 0) {
684 return OHOS::Ace::ERROR_CODE_PARAM_OUT_OF_RANGE;
685 }
686 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
687 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
688 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setBounds(node->renderNodeHandle,
689 static_cast<uint32_t>(x), static_cast<uint32_t>(y),
690 static_cast<uint32_t>(width), static_cast<uint32_t>(height));
691 }
692
OH_ArkUI_RenderNodeUtils_GetBounds(ArkUI_RenderNodeHandle node,int32_t * x,int32_t * y,int32_t * width,int32_t * height)693 int32_t OH_ArkUI_RenderNodeUtils_GetBounds(ArkUI_RenderNodeHandle node, int32_t* x, int32_t* y, int32_t* width,
694 int32_t* height)
695 {
696 if (node == nullptr) {
697 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
698 }
699 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
700 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
701 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getBounds(node->renderNodeHandle,
702 reinterpret_cast<uint32_t*>(x), reinterpret_cast<uint32_t*>(y),
703 reinterpret_cast<uint32_t*>(width), reinterpret_cast<uint32_t*>(height));
704 }
705
OH_ArkUI_RenderNodeUtils_SetDrawRegion(ArkUI_RenderNodeHandle node,float x,float y,float w,float h)706 int32_t OH_ArkUI_RenderNodeUtils_SetDrawRegion(ArkUI_RenderNodeHandle node, float x, float y, float w, float h)
707 {
708 if (node == nullptr) {
709 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
710 }
711 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
712 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
713 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setDrawRegion(node->renderNodeHandle, x, y, w, h);
714 }
715
OH_ArkUI_RenderNodeUtils_SetClipToFrame(ArkUI_RenderNodeHandle node,int32_t clipToFrame)716 int32_t OH_ArkUI_RenderNodeUtils_SetClipToFrame(ArkUI_RenderNodeHandle node, int32_t clipToFrame)
717 {
718 if (node == nullptr) {
719 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
720 }
721 if (!OHOS::Ace::InRegion(0, 1, clipToFrame)) {
722 return OHOS::Ace::ERROR_CODE_PARAM_OUT_OF_RANGE;
723 }
724 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
725 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
726 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setClipToFrame(node->renderNodeHandle, clipToFrame);
727 }
728
OH_ArkUI_RenderNodeUtils_GetClipToFrame(ArkUI_RenderNodeHandle node,int32_t * clipToFrame)729 int32_t OH_ArkUI_RenderNodeUtils_GetClipToFrame(ArkUI_RenderNodeHandle node, int32_t* clipToFrame)
730 {
731 if (node == nullptr) {
732 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
733 }
734 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
735 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
736 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getClipToFrame(node->renderNodeHandle, clipToFrame);
737 }
738
OH_ArkUI_RenderNodeUtils_SetClipToBounds(ArkUI_RenderNodeHandle node,int32_t clipToBounds)739 int32_t OH_ArkUI_RenderNodeUtils_SetClipToBounds(ArkUI_RenderNodeHandle node, int32_t clipToBounds)
740 {
741 if (node == nullptr) {
742 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
743 }
744 if (!OHOS::Ace::InRegion(0, 1, clipToBounds)) {
745 return OHOS::Ace::ERROR_CODE_PARAM_OUT_OF_RANGE;
746 }
747 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
748 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
749 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setClipToBounds(node->renderNodeHandle, clipToBounds);
750 }
751
OH_ArkUI_RenderNodeUtils_GetClipToBounds(ArkUI_RenderNodeHandle node,int32_t * clipToBounds)752 int32_t OH_ArkUI_RenderNodeUtils_GetClipToBounds(ArkUI_RenderNodeHandle node, int32_t* clipToBounds)
753 {
754 if (node == nullptr) {
755 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
756 }
757 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
758 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
759 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getClipToBounds(node->renderNodeHandle, clipToBounds);
760 }
761
OH_ArkUI_RenderNodeUtils_AttachContentModifier(ArkUI_RenderNodeHandle node,ArkUI_RenderContentModifierHandle modifier)762 int32_t OH_ArkUI_RenderNodeUtils_AttachContentModifier(
763 ArkUI_RenderNodeHandle node, ArkUI_RenderContentModifierHandle modifier)
764 {
765 if (node == nullptr || modifier == nullptr) {
766 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
767 }
768 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
769 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
770 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->attachModifier(
771 node->renderNodeHandle, modifier->RenderModifierHandle);
772 }
773
OH_ArkUI_RenderNodeUtils_CreateContentModifier()774 ArkUI_RenderContentModifierHandle OH_ArkUI_RenderNodeUtils_CreateContentModifier()
775 {
776 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
777 CHECK_NULL_RETURN(impl, nullptr);
778 auto* modifierPtr = impl->getNodeModifiers()->getNDKRenderNodeModifier()->createModifier();
779 if (!modifierPtr) {
780 return nullptr;
781 }
782 ArkUI_RenderContentModifier* arkUIRenderModifier = new ArkUI_RenderContentModifier({ modifierPtr });
783 g_modifierSet.insert(modifierPtr);
784 return arkUIRenderModifier;
785 }
786
OH_ArkUI_RenderNodeUtils_DisposeContentModifier(ArkUI_RenderContentModifierHandle modifier)787 void OH_ArkUI_RenderNodeUtils_DisposeContentModifier(ArkUI_RenderContentModifierHandle modifier)
788 {
789 CHECK_NULL_VOID(modifier);
790 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
791 CHECK_NULL_VOID(impl);
792 g_modifierSet.erase(modifier->RenderModifierHandle);
793 impl->getNodeModifiers()->getNDKRenderNodeModifier()->disposeModifier(modifier->RenderModifierHandle);
794 delete modifier;
795 modifier = nullptr;
796 }
797
OH_ArkUI_RenderNodeUtils_AttachFloatProperty(ArkUI_RenderContentModifierHandle modifier,ArkUI_FloatPropertyHandle property)798 int32_t OH_ArkUI_RenderNodeUtils_AttachFloatProperty(
799 ArkUI_RenderContentModifierHandle modifier, ArkUI_FloatPropertyHandle property)
800 {
801 if (modifier == nullptr || property == nullptr) {
802 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
803 }
804 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
805 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
806 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->attachProperty(
807 modifier->RenderModifierHandle, property->rsPropertyHandle);
808 }
809
OH_ArkUI_RenderNodeUtils_AttachVector2Property(ArkUI_RenderContentModifierHandle modifier,ArkUI_Vector2PropertyHandle property)810 int32_t OH_ArkUI_RenderNodeUtils_AttachVector2Property(
811 ArkUI_RenderContentModifierHandle modifier, ArkUI_Vector2PropertyHandle property)
812 {
813 if (modifier == nullptr || property == nullptr) {
814 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
815 }
816 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
817 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
818 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->attachProperty(
819 modifier->RenderModifierHandle, property->rsPropertyHandle);
820 }
821
OH_ArkUI_RenderNodeUtils_AttachColorProperty(ArkUI_RenderContentModifierHandle modifier,ArkUI_ColorPropertyHandle property)822 int32_t OH_ArkUI_RenderNodeUtils_AttachColorProperty(
823 ArkUI_RenderContentModifierHandle modifier, ArkUI_ColorPropertyHandle property)
824 {
825 if (modifier == nullptr || property == nullptr) {
826 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
827 }
828 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
829 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
830 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->attachProperty(
831 modifier->RenderModifierHandle, property->rsPropertyHandle);
832 }
833
OH_ArkUI_RenderNodeUtils_AttachFloatAnimatableProperty(ArkUI_RenderContentModifierHandle modifier,ArkUI_FloatAnimatablePropertyHandle property)834 int32_t OH_ArkUI_RenderNodeUtils_AttachFloatAnimatableProperty(
835 ArkUI_RenderContentModifierHandle modifier, ArkUI_FloatAnimatablePropertyHandle property)
836 {
837 if (modifier == nullptr || property == nullptr) {
838 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
839 }
840 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
841 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
842 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->attachProperty(
843 modifier->RenderModifierHandle, property->rsPropertyHandle);
844 }
845
OH_ArkUI_RenderNodeUtils_AttachVector2AnimatableProperty(ArkUI_RenderContentModifierHandle modifier,ArkUI_Vector2AnimatablePropertyHandle property)846 int32_t OH_ArkUI_RenderNodeUtils_AttachVector2AnimatableProperty(
847 ArkUI_RenderContentModifierHandle modifier, ArkUI_Vector2AnimatablePropertyHandle property)
848 {
849 if (modifier == nullptr || property == nullptr) {
850 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
851 }
852 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
853 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
854 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->attachProperty(
855 modifier->RenderModifierHandle, property->rsPropertyHandle);
856 }
857
OH_ArkUI_RenderNodeUtils_AttachColorAnimatableProperty(ArkUI_RenderContentModifierHandle modifier,ArkUI_ColorAnimatablePropertyHandle property)858 int32_t OH_ArkUI_RenderNodeUtils_AttachColorAnimatableProperty(
859 ArkUI_RenderContentModifierHandle modifier, ArkUI_ColorAnimatablePropertyHandle property)
860 {
861 if (modifier == nullptr || property == nullptr) {
862 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
863 }
864 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
865 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
866 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->attachProperty(
867 modifier->RenderModifierHandle, property->rsPropertyHandle);
868 }
869
OH_ArkUI_RenderNodeUtils_CreateFloatProperty(float value)870 ArkUI_FloatPropertyHandle OH_ArkUI_RenderNodeUtils_CreateFloatProperty(float value)
871 {
872 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
873 CHECK_NULL_RETURN(impl, nullptr);
874 auto* propertyPtr = impl->getNodeModifiers()->getNDKRenderNodeModifier()->createFloatProperty(value);
875 if (!propertyPtr) {
876 return nullptr;
877 }
878 ArkUI_FloatProperty* rsProperty = new ArkUI_FloatProperty({ propertyPtr });
879 g_propertySet.insert(propertyPtr);
880 return rsProperty;
881 }
882
OH_ArkUI_RenderNodeUtils_SetFloatPropertyValue(ArkUI_FloatPropertyHandle property,float value)883 int32_t OH_ArkUI_RenderNodeUtils_SetFloatPropertyValue(ArkUI_FloatPropertyHandle property, float value)
884 {
885 if (property == nullptr) {
886 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
887 }
888 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
889 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
890 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setFloatProperty(property->rsPropertyHandle, value);
891 }
892
OH_ArkUI_RenderNodeUtils_GetFloatPropertyValue(ArkUI_FloatPropertyHandle property,float * value)893 int32_t OH_ArkUI_RenderNodeUtils_GetFloatPropertyValue(ArkUI_FloatPropertyHandle property, float* value)
894 {
895 if (property == nullptr) {
896 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
897 }
898 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
899 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
900 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getFloatProperty(property->rsPropertyHandle, value);
901 }
902
OH_ArkUI_RenderNodeUtils_DisposeFloatProperty(ArkUI_FloatPropertyHandle property)903 void OH_ArkUI_RenderNodeUtils_DisposeFloatProperty(ArkUI_FloatPropertyHandle property)
904 {
905 CHECK_NULL_VOID(property);
906 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
907 CHECK_NULL_VOID(impl);
908 g_propertySet.erase(property->rsPropertyHandle);
909 impl->getNodeModifiers()->getNDKRenderNodeModifier()->disposeProperty(property->rsPropertyHandle);
910 delete property;
911 property = nullptr;
912 }
913
OH_ArkUI_RenderNodeUtils_CreateVector2Property(float x,float y)914 ArkUI_Vector2PropertyHandle OH_ArkUI_RenderNodeUtils_CreateVector2Property(float x, float y)
915 {
916 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
917 CHECK_NULL_RETURN(impl, nullptr);
918 auto* propertyPtr = impl->getNodeModifiers()->getNDKRenderNodeModifier()->createVector2Property(x, y);
919 if (!propertyPtr) {
920 return nullptr;
921 }
922 ArkUI_Vector2Property* rsProperty = new ArkUI_Vector2Property({ propertyPtr });
923 g_propertySet.insert(propertyPtr);
924 return rsProperty;
925 }
926
OH_ArkUI_RenderNodeUtils_SetVector2PropertyValue(ArkUI_Vector2PropertyHandle property,float x,float y)927 int32_t OH_ArkUI_RenderNodeUtils_SetVector2PropertyValue(ArkUI_Vector2PropertyHandle property, float x, float y)
928 {
929 if (property == nullptr) {
930 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
931 }
932 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
933 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
934 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setVector2Property(property->rsPropertyHandle, x, y);
935 }
936
OH_ArkUI_RenderNodeUtils_GetVector2PropertyValue(ArkUI_Vector2PropertyHandle property,float * x,float * y)937 int32_t OH_ArkUI_RenderNodeUtils_GetVector2PropertyValue(ArkUI_Vector2PropertyHandle property, float* x, float* y)
938 {
939 if (property == nullptr) {
940 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
941 }
942 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
943 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
944 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getVector2Property(property->rsPropertyHandle, x, y);
945 }
946
OH_ArkUI_RenderNodeUtils_DisposeVector2Property(ArkUI_Vector2PropertyHandle property)947 void OH_ArkUI_RenderNodeUtils_DisposeVector2Property(ArkUI_Vector2PropertyHandle property)
948 {
949 CHECK_NULL_VOID(property);
950 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
951 CHECK_NULL_VOID(impl);
952 g_propertySet.erase(property->rsPropertyHandle);
953 impl->getNodeModifiers()->getNDKRenderNodeModifier()->disposeProperty(property->rsPropertyHandle);
954 delete property;
955 property = nullptr;
956 }
957
OH_ArkUI_RenderNodeUtils_CreateColorProperty(uint32_t value)958 ArkUI_ColorPropertyHandle OH_ArkUI_RenderNodeUtils_CreateColorProperty(uint32_t value)
959 {
960 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
961 CHECK_NULL_RETURN(impl, nullptr);
962 auto* propertyPtr = impl->getNodeModifiers()->getNDKRenderNodeModifier()->createColorProperty(value);
963 if (!propertyPtr) {
964 return nullptr;
965 }
966 ArkUI_ColorProperty* rsProperty = new ArkUI_ColorProperty({ propertyPtr });
967 g_propertySet.insert(propertyPtr);
968 return rsProperty;
969 }
970
OH_ArkUI_RenderNodeUtils_SetColorPropertyValue(ArkUI_ColorPropertyHandle property,uint32_t value)971 int32_t OH_ArkUI_RenderNodeUtils_SetColorPropertyValue(ArkUI_ColorPropertyHandle property, uint32_t value)
972 {
973 if (property == nullptr) {
974 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
975 }
976 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
977 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
978 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setColorProperty(property->rsPropertyHandle, value);
979 }
980
OH_ArkUI_RenderNodeUtils_GetColorPropertyValue(ArkUI_ColorPropertyHandle property,uint32_t * value)981 int32_t OH_ArkUI_RenderNodeUtils_GetColorPropertyValue(ArkUI_ColorPropertyHandle property, uint32_t* value)
982 {
983 if (property == nullptr) {
984 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
985 }
986 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
987 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
988 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getColorProperty(property->rsPropertyHandle, value);
989 }
990
OH_ArkUI_RenderNodeUtils_DisposeColorProperty(ArkUI_ColorPropertyHandle property)991 void OH_ArkUI_RenderNodeUtils_DisposeColorProperty(ArkUI_ColorPropertyHandle property)
992 {
993 CHECK_NULL_VOID(property);
994 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
995 CHECK_NULL_VOID(impl);
996 g_propertySet.erase(property->rsPropertyHandle);
997 impl->getNodeModifiers()->getNDKRenderNodeModifier()->disposeProperty(property->rsPropertyHandle);
998 delete property;
999 property = nullptr;
1000 }
1001
OH_ArkUI_RenderNodeUtils_CreateFloatAnimatableProperty(float value)1002 ArkUI_FloatAnimatablePropertyHandle OH_ArkUI_RenderNodeUtils_CreateFloatAnimatableProperty(float value)
1003 {
1004 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1005 CHECK_NULL_RETURN(impl, nullptr);
1006 auto* propertyPtr = impl->getNodeModifiers()->getNDKRenderNodeModifier()->createFloatAnimatableProperty(value);
1007 if (!propertyPtr) {
1008 return nullptr;
1009 }
1010 ArkUI_FloatAnimatableProperty* rsProperty = new ArkUI_FloatAnimatableProperty({ propertyPtr });
1011 g_propertySet.insert(propertyPtr);
1012 return rsProperty;
1013 }
1014
OH_ArkUI_RenderNodeUtils_SetFloatAnimatablePropertyValue(ArkUI_FloatAnimatablePropertyHandle property,float value)1015 int32_t OH_ArkUI_RenderNodeUtils_SetFloatAnimatablePropertyValue(
1016 ArkUI_FloatAnimatablePropertyHandle property, float value)
1017 {
1018 if (property == nullptr) {
1019 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1020 }
1021 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1022 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1023 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setFloatAnimatableProperty(
1024 property->rsPropertyHandle, value);
1025 }
1026
OH_ArkUI_RenderNodeUtils_GetFloatAnimatablePropertyValue(ArkUI_FloatAnimatablePropertyHandle property,float * value)1027 int32_t OH_ArkUI_RenderNodeUtils_GetFloatAnimatablePropertyValue(
1028 ArkUI_FloatAnimatablePropertyHandle property, float* value)
1029 {
1030 if (property == nullptr) {
1031 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1032 }
1033 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1034 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1035 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getFloatAnimatableProperty(
1036 property->rsPropertyHandle, value);
1037 }
1038
OH_ArkUI_RenderNodeUtils_DisposeFloatAnimatableProperty(ArkUI_FloatAnimatablePropertyHandle property)1039 void OH_ArkUI_RenderNodeUtils_DisposeFloatAnimatableProperty(ArkUI_FloatAnimatablePropertyHandle property)
1040 {
1041 CHECK_NULL_VOID(property);
1042 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1043 CHECK_NULL_VOID(impl);
1044 g_propertySet.erase(property->rsPropertyHandle);
1045 impl->getNodeModifiers()->getNDKRenderNodeModifier()->disposeProperty(property->rsPropertyHandle);
1046 delete property;
1047 property = nullptr;
1048 }
1049
OH_ArkUI_RenderNodeUtils_CreateVector2AnimatableProperty(float x,float y)1050 ArkUI_Vector2AnimatablePropertyHandle OH_ArkUI_RenderNodeUtils_CreateVector2AnimatableProperty(float x, float y)
1051 {
1052 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1053 CHECK_NULL_RETURN(impl, nullptr);
1054 auto* propertyPtr = impl->getNodeModifiers()->getNDKRenderNodeModifier()->createVector2AnimatableProperty(x, y);
1055 if (!propertyPtr) {
1056 return nullptr;
1057 }
1058 ArkUI_Vector2AnimatableProperty* rsProperty = new ArkUI_Vector2AnimatableProperty({ propertyPtr });
1059 g_propertySet.insert(propertyPtr);
1060 return rsProperty;
1061 }
1062
OH_ArkUI_RenderNodeUtils_SetVector2AnimatablePropertyValue(ArkUI_Vector2AnimatablePropertyHandle property,float x,float y)1063 int32_t OH_ArkUI_RenderNodeUtils_SetVector2AnimatablePropertyValue(
1064 ArkUI_Vector2AnimatablePropertyHandle property, float x, float y)
1065 {
1066 if (property == nullptr) {
1067 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1068 }
1069 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1070 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1071 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setVector2AnimatableProperty(
1072 property->rsPropertyHandle, x, y);
1073 }
1074
OH_ArkUI_RenderNodeUtils_GetVector2AnimatablePropertyValue(ArkUI_Vector2AnimatablePropertyHandle property,float * x,float * y)1075 int32_t OH_ArkUI_RenderNodeUtils_GetVector2AnimatablePropertyValue(
1076 ArkUI_Vector2AnimatablePropertyHandle property, float* x, float* y)
1077 {
1078 if (property == nullptr) {
1079 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1080 }
1081 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1082 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1083 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getVector2AnimatableProperty(
1084 property->rsPropertyHandle, x, y);
1085 }
1086
OH_ArkUI_RenderNodeUtils_DisposeVector2AnimatableProperty(ArkUI_Vector2AnimatablePropertyHandle property)1087 void OH_ArkUI_RenderNodeUtils_DisposeVector2AnimatableProperty(ArkUI_Vector2AnimatablePropertyHandle property)
1088 {
1089 CHECK_NULL_VOID(property);
1090 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1091 CHECK_NULL_VOID(impl);
1092 g_propertySet.erase(property->rsPropertyHandle);
1093 impl->getNodeModifiers()->getNDKRenderNodeModifier()->disposeProperty(property->rsPropertyHandle);
1094 delete property;
1095 property = nullptr;
1096 }
1097
OH_ArkUI_RenderNodeUtils_CreateColorAnimatableProperty(uint32_t value)1098 ArkUI_ColorAnimatablePropertyHandle OH_ArkUI_RenderNodeUtils_CreateColorAnimatableProperty(uint32_t value)
1099 {
1100 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1101 CHECK_NULL_RETURN(impl, nullptr);
1102 auto* propertyPtr = impl->getNodeModifiers()->getNDKRenderNodeModifier()->createColorAnimatableProperty(value);
1103 if (!propertyPtr) {
1104 return nullptr;
1105 }
1106 ArkUI_ColorAnimatableProperty* rsProperty = new ArkUI_ColorAnimatableProperty({ propertyPtr });
1107 g_propertySet.insert(propertyPtr);
1108 return rsProperty;
1109 }
1110
OH_ArkUI_RenderNodeUtils_SetColorAnimatablePropertyValue(ArkUI_ColorAnimatablePropertyHandle property,uint32_t value)1111 int32_t OH_ArkUI_RenderNodeUtils_SetColorAnimatablePropertyValue(
1112 ArkUI_ColorAnimatablePropertyHandle property, uint32_t value)
1113 {
1114 if (property == nullptr) {
1115 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1116 }
1117 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1118 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1119 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setColorAnimatableProperty(
1120 property->rsPropertyHandle, value);
1121 }
1122
OH_ArkUI_RenderNodeUtils_GetColorAnimatablePropertyValue(ArkUI_ColorAnimatablePropertyHandle property,uint32_t * value)1123 int32_t OH_ArkUI_RenderNodeUtils_GetColorAnimatablePropertyValue(
1124 ArkUI_ColorAnimatablePropertyHandle property, uint32_t* value)
1125 {
1126 if (property == nullptr) {
1127 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1128 }
1129 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1130 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1131 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->getColorAnimatableProperty(
1132 property->rsPropertyHandle, value);
1133 }
1134
OH_ArkUI_RenderNodeUtils_DisposeColorAnimatableProperty(ArkUI_ColorAnimatablePropertyHandle property)1135 void OH_ArkUI_RenderNodeUtils_DisposeColorAnimatableProperty(ArkUI_ColorAnimatablePropertyHandle property)
1136 {
1137 CHECK_NULL_VOID(property);
1138 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1139 CHECK_NULL_VOID(impl);
1140 g_propertySet.erase(property->rsPropertyHandle);
1141 impl->getNodeModifiers()->getNDKRenderNodeModifier()->disposeProperty(property->rsPropertyHandle);
1142 delete property;
1143 property = nullptr;
1144 }
1145
OH_ArkUI_RenderNodeUtils_SetContentModifierOnDraw(ArkUI_RenderContentModifierHandle modifier,void * userData,void (* callback)(ArkUI_DrawContext * context,void * userData))1146 int32_t OH_ArkUI_RenderNodeUtils_SetContentModifierOnDraw(ArkUI_RenderContentModifierHandle modifier, void* userData,
1147 void (*callback)(ArkUI_DrawContext* context, void* userData))
1148 {
1149 CHECK_NULL_RETURN(modifier, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1150 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1151 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1152 return impl->getNodeModifiers()->getNDKRenderNodeModifier()->setModifierOnDraw(
1153 modifier->RenderModifierHandle, userData, reinterpret_cast<void (*)(ArkUIDrawingContext*, void*)>(callback));
1154 }
1155
1156 /** 结构体类型写最下面,结构体内容参考 render_node.h*/
OH_ArkUI_RenderNodeUtils_CreateRectShapeOption()1157 ArkUI_RectShapeOption* OH_ArkUI_RenderNodeUtils_CreateRectShapeOption()
1158 {
1159 ArkUI_RectShape* option = new ArkUI_RectShape { 0.0f, 0.0f, 0.0f, 0.0f };
1160 return option;
1161 }
1162
OH_ArkUI_RenderNodeUtils_DisposeRectShapeOption(ArkUI_RectShapeOption * option)1163 void OH_ArkUI_RenderNodeUtils_DisposeRectShapeOption(ArkUI_RectShapeOption* option)
1164 {
1165 CHECK_NULL_VOID(option);
1166 delete option;
1167 }
1168
OH_ArkUI_RenderNodeUtils_SetRectShapeOptionEdgeValue(ArkUI_RectShapeOption * option,float top,float right,float bottom,float left)1169 void OH_ArkUI_RenderNodeUtils_SetRectShapeOptionEdgeValue(
1170 ArkUI_RectShapeOption* option, float top, float right, float bottom, float left)
1171 {
1172 CHECK_NULL_VOID(option);
1173 option->left = left;
1174 option->right = right;
1175 option->top = top;
1176 option->bottom = bottom;
1177 }
1178
OH_ArkUI_RenderNodeUtils_CreateNodeBorderStyleOption()1179 ArkUI_NodeBorderStyleOption* OH_ArkUI_RenderNodeUtils_CreateNodeBorderStyleOption()
1180 {
1181 ArkUI_NodeBorderStyle* option = new ArkUI_NodeBorderStyle {
1182 .leftStyle = ArkUI_BorderStyle::ARKUI_BORDER_STYLE_SOLID,
1183 .rightStyle = ArkUI_BorderStyle::ARKUI_BORDER_STYLE_SOLID,
1184 .topStyle = ArkUI_BorderStyle::ARKUI_BORDER_STYLE_SOLID,
1185 .bottomStyle = ArkUI_BorderStyle::ARKUI_BORDER_STYLE_SOLID };
1186 return option;
1187 }
1188
OH_ArkUI_RenderNodeUtils_DisposeNodeBorderStyleOption(ArkUI_NodeBorderStyleOption * option)1189 void OH_ArkUI_RenderNodeUtils_DisposeNodeBorderStyleOption(ArkUI_NodeBorderStyleOption* option)
1190 {
1191 CHECK_NULL_VOID(option);
1192 delete option;
1193 }
1194
OH_ArkUI_NodeBorderStyleOption_SetLeftBorderStyle(ArkUI_NodeBorderStyleOption * option,ArkUI_BorderStyle style)1195 void OH_ArkUI_NodeBorderStyleOption_SetLeftBorderStyle(ArkUI_NodeBorderStyleOption* option, ArkUI_BorderStyle style)
1196 {
1197 CHECK_NULL_VOID(option);
1198 option->leftStyle = style;
1199 }
1200
OH_ArkUI_RenderNodeUtils_SetNodeBorderStyleOptionEdgeStyle(ArkUI_NodeBorderStyleOption * option,ArkUI_BorderStyle style,ArkUI_EdgeDirection direction)1201 void OH_ArkUI_RenderNodeUtils_SetNodeBorderStyleOptionEdgeStyle(
1202 ArkUI_NodeBorderStyleOption* option, ArkUI_BorderStyle style, ArkUI_EdgeDirection direction)
1203 {
1204 CHECK_NULL_VOID(option);
1205 switch (direction) {
1206 case ARKUI_EDGE_DIRECTION_ALL:
1207 option->leftStyle = style;
1208 option->rightStyle = style;
1209 option->topStyle = style;
1210 option->bottomStyle = style;
1211 break;
1212 case ARKUI_EDGE_DIRECTION_LEFT:
1213 option->leftStyle = style;
1214 break;
1215 case ARKUI_EDGE_DIRECTION_RIGHT:
1216 option->rightStyle = style;
1217 break;
1218 case ARKUI_EDGE_DIRECTION_TOP:
1219 option->topStyle = style;
1220 break;
1221 case ARKUI_EDGE_DIRECTION_BOTTOM:
1222 option->bottomStyle = style;
1223 break;
1224 default:
1225 return;
1226 }
1227 }
1228
OH_ArkUI_RenderNodeUtils_CreateNodeBorderWidthOption()1229 ArkUI_NodeBorderWidthOption* OH_ArkUI_RenderNodeUtils_CreateNodeBorderWidthOption()
1230 {
1231 ArkUI_NodeBorderWidth* option = new ArkUI_NodeBorderWidth { 0.0f, 0.0f, 0.0f, 0.0f };
1232 return option;
1233 }
1234
OH_ArkUI_RenderNodeUtils_DisposeNodeBorderWidthOption(ArkUI_NodeBorderWidthOption * option)1235 void OH_ArkUI_RenderNodeUtils_DisposeNodeBorderWidthOption(ArkUI_NodeBorderWidthOption* option)
1236 {
1237 CHECK_NULL_VOID(option);
1238 delete option;
1239 }
1240
OH_ArkUI_RenderNodeUtils_SetNodeBorderWidthOptionEdgeWidth(ArkUI_NodeBorderWidthOption * option,float width,ArkUI_EdgeDirection direction)1241 void OH_ArkUI_RenderNodeUtils_SetNodeBorderWidthOptionEdgeWidth(
1242 ArkUI_NodeBorderWidthOption* option, float width, ArkUI_EdgeDirection direction)
1243 {
1244 CHECK_NULL_VOID(option);
1245 if (OHOS::Ace::LessNotEqual(width, 0.0)) {
1246 return;
1247 }
1248 switch (direction) {
1249 case ARKUI_EDGE_DIRECTION_ALL:
1250 option->leftWidth = width;
1251 option->rightWidth = width;
1252 option->topWidth = width;
1253 option->bottomWidth = width;
1254 break;
1255 case ARKUI_EDGE_DIRECTION_LEFT:
1256 option->leftWidth = width;
1257 break;
1258 case ARKUI_EDGE_DIRECTION_RIGHT:
1259 option->rightWidth = width;
1260 break;
1261 case ARKUI_EDGE_DIRECTION_TOP:
1262 option->topWidth = width;
1263 break;
1264 case ARKUI_EDGE_DIRECTION_BOTTOM:
1265 option->bottomWidth = width;
1266 break;
1267 default:
1268 return;
1269 }
1270 }
1271
OH_ArkUI_RenderNodeUtils_CreateNodeBorderColorOption()1272 ArkUI_NodeBorderColorOption* OH_ArkUI_RenderNodeUtils_CreateNodeBorderColorOption()
1273 {
1274 ArkUI_NodeBorderColor* option = new ArkUI_NodeBorderColor { 0, 0, 0, 0 };
1275 return option;
1276 }
1277
OH_ArkUI_RenderNodeUtils_DisposeNodeBorderColorOption(ArkUI_NodeBorderColorOption * option)1278 void OH_ArkUI_RenderNodeUtils_DisposeNodeBorderColorOption(ArkUI_NodeBorderColorOption* option)
1279 {
1280 CHECK_NULL_VOID(option);
1281 delete option;
1282 }
1283
OH_ArkUI_RenderNodeUtils_SetNodeBorderColorOptionEdgeColor(ArkUI_NodeBorderColorOption * option,uint32_t color,ArkUI_EdgeDirection direction)1284 void OH_ArkUI_RenderNodeUtils_SetNodeBorderColorOptionEdgeColor(
1285 ArkUI_NodeBorderColorOption* option, uint32_t color, ArkUI_EdgeDirection direction)
1286 {
1287 CHECK_NULL_VOID(option);
1288 switch (direction) {
1289 case ARKUI_EDGE_DIRECTION_ALL:
1290 option->leftColor = color;
1291 option->rightColor = color;
1292 option->topColor = color;
1293 option->bottomColor = color;
1294 break;
1295 case ARKUI_EDGE_DIRECTION_LEFT:
1296 option->leftColor = color;
1297 break;
1298 case ARKUI_EDGE_DIRECTION_RIGHT:
1299 option->rightColor = color;
1300 break;
1301 case ARKUI_EDGE_DIRECTION_TOP:
1302 option->topColor = color;
1303 break;
1304 case ARKUI_EDGE_DIRECTION_BOTTOM:
1305 option->bottomColor = color;
1306 break;
1307 default:
1308 return;
1309 }
1310 }
1311
OH_ArkUI_RenderNodeUtils_CreateNodeBorderRadiusOption()1312 ArkUI_NodeBorderRadiusOption* OH_ArkUI_RenderNodeUtils_CreateNodeBorderRadiusOption()
1313 {
1314 ArkUI_NodeBorderRadius* option = new ArkUI_NodeBorderRadius { 0.0f, 0.0f, 0.0f, 0.0f };
1315 return option;
1316 }
1317
OH_ArkUI_RenderNodeUtils_DisposeNodeBorderRadiusOption(ArkUI_NodeBorderRadiusOption * option)1318 void OH_ArkUI_RenderNodeUtils_DisposeNodeBorderRadiusOption(ArkUI_NodeBorderRadiusOption* option)
1319 {
1320 CHECK_NULL_VOID(option);
1321 delete option;
1322 }
1323
OH_ArkUI_RenderNodeUtils_SetNodeBorderRadiusOptionCornerRadius(ArkUI_NodeBorderRadiusOption * option,uint32_t cornerRadius,ArkUI_CornerDirection direction)1324 void OH_ArkUI_RenderNodeUtils_SetNodeBorderRadiusOptionCornerRadius(
1325 ArkUI_NodeBorderRadiusOption* option, uint32_t cornerRadius, ArkUI_CornerDirection direction)
1326 {
1327 CHECK_NULL_VOID(option);
1328 switch (direction) {
1329 case ARKUI_CORNER_DIRECTION_ALL:
1330 option->topLeftRadius = cornerRadius;
1331 option->topRightRadius = cornerRadius;
1332 option->bottomLeftRadius = cornerRadius;
1333 option->bottomRightRadius = cornerRadius;
1334 break;
1335 case ARKUI_CORNER_DIRECTION_TOP_LEFT:
1336 option->topLeftRadius = cornerRadius;
1337 break;
1338 case ARKUI_CORNER_DIRECTION_TOP_RIGHT:
1339 option->topRightRadius = cornerRadius;
1340 break;
1341 case ARKUI_CORNER_DIRECTION_BOTTOM_LEFT:
1342 option->bottomLeftRadius = cornerRadius;
1343 break;
1344 case ARKUI_CORNER_DIRECTION_BOTTOM_RIGHT:
1345 option->bottomRightRadius = cornerRadius;
1346 break;
1347 default:
1348 return;
1349 }
1350 }
1351
OH_ArkUI_RenderNodeUtils_CreateCircleShapeOption()1352 ArkUI_CircleShapeOption* OH_ArkUI_RenderNodeUtils_CreateCircleShapeOption()
1353 {
1354 ArkUI_CircleShape* option = new ArkUI_CircleShape { 0.0f, 0.0f, 0.0f };
1355 return option;
1356 }
1357
OH_ArkUI_RenderNodeUtils_DisposeCircleShapeOption(ArkUI_CircleShapeOption * option)1358 void OH_ArkUI_RenderNodeUtils_DisposeCircleShapeOption(ArkUI_CircleShapeOption* option)
1359 {
1360 CHECK_NULL_VOID(option);
1361 delete option;
1362 }
1363
OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionCenterX(ArkUI_CircleShapeOption * option,float centerX)1364 void OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionCenterX(ArkUI_CircleShapeOption* option, float centerX)
1365 {
1366 CHECK_NULL_VOID(option);
1367 option->centerX = centerX;
1368 }
1369
OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionCenterY(ArkUI_CircleShapeOption * option,float centerY)1370 void OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionCenterY(ArkUI_CircleShapeOption* option, float centerY)
1371 {
1372 CHECK_NULL_VOID(option);
1373 option->centerY = centerY;
1374 }
1375
OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionRadius(ArkUI_CircleShapeOption * option,float radius)1376 void OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionRadius(ArkUI_CircleShapeOption* option, float radius)
1377 {
1378 CHECK_NULL_VOID(option);
1379 option->radius = radius;
1380 }
1381
OH_ArkUI_RenderNodeUtils_CreateRoundRectShapeOption()1382 ArkUI_RoundRectShapeOption* OH_ArkUI_RenderNodeUtils_CreateRoundRectShapeOption()
1383 {
1384 ArkUI_RoundRectShape* option =
1385 new ArkUI_RoundRectShape { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
1386 return option;
1387 }
1388
OH_ArkUI_RenderNodeUtils_DisposeRoundRectShapeOption(ArkUI_RoundRectShapeOption * option)1389 void OH_ArkUI_RenderNodeUtils_DisposeRoundRectShapeOption(ArkUI_RoundRectShapeOption* option)
1390 {
1391 CHECK_NULL_VOID(option);
1392 delete option;
1393 }
1394
OH_ArkUI_RenderNodeUtils_SetRoundRectShapeOptionEdgeValue(ArkUI_RoundRectShapeOption * option,float top,float right,float bottom,float left)1395 void OH_ArkUI_RenderNodeUtils_SetRoundRectShapeOptionEdgeValue(
1396 ArkUI_RoundRectShapeOption* option, float top, float right, float bottom, float left)
1397 {
1398 CHECK_NULL_VOID(option);
1399 option->left = left;
1400 option->right = right;
1401 option->top = top;
1402 option->bottom = bottom;
1403 }
1404
OH_ArkUI_RenderNodeUtils_SetRoundRectShapeOptionCornerXY(ArkUI_RoundRectShapeOption * option,float x,float y,ArkUI_CornerDirection direction)1405 void OH_ArkUI_RenderNodeUtils_SetRoundRectShapeOptionCornerXY(
1406 ArkUI_RoundRectShapeOption* option, float x, float y, ArkUI_CornerDirection direction)
1407 {
1408 CHECK_NULL_VOID(option);
1409 switch (direction) {
1410 case ARKUI_CORNER_DIRECTION_ALL:
1411 option->topLeftX = x;
1412 option->topLeftY = y;
1413 option->topRightX = x;
1414 option->topRightY = y;
1415 option->bottomLeftX = x;
1416 option->bottomLeftY = y;
1417 option->bottomRightX = x;
1418 option->bottomRightY = y;
1419 break;
1420 case ARKUI_CORNER_DIRECTION_TOP_LEFT:
1421 option->topLeftX = x;
1422 option->topLeftY = y;
1423 break;
1424 case ARKUI_CORNER_DIRECTION_TOP_RIGHT:
1425 option->topRightX = x;
1426 option->topRightY = y;
1427 break;
1428 case ARKUI_CORNER_DIRECTION_BOTTOM_LEFT:
1429 option->bottomLeftX = x;
1430 option->bottomLeftY = y;
1431 break;
1432 case ARKUI_CORNER_DIRECTION_BOTTOM_RIGHT:
1433 option->bottomRightX = x;
1434 option->bottomRightY = y;
1435 break;
1436 default:
1437 return;
1438 }
1439 }
1440
OH_ArkUI_RenderNodeUtils_CreateCommandPathOption()1441 ArkUI_CommandPathOption* OH_ArkUI_RenderNodeUtils_CreateCommandPathOption()
1442 {
1443 ArkUI_CommandPath* option = new ArkUI_CommandPath { "" };
1444 return option;
1445 }
1446
OH_ArkUI_RenderNodeUtils_DisposeCommandPathOption(ArkUI_CommandPathOption * option)1447 void OH_ArkUI_RenderNodeUtils_DisposeCommandPathOption(ArkUI_CommandPathOption* option)
1448 {
1449 CHECK_NULL_VOID(option);
1450 delete option;
1451 }
1452
OH_ArkUI_RenderNodeUtils_SetCommandPathOptionCommands(ArkUI_CommandPathOption * option,char * commands)1453 void OH_ArkUI_RenderNodeUtils_SetCommandPathOptionCommands(ArkUI_CommandPathOption* option, char* commands)
1454 {
1455 CHECK_NULL_VOID(option);
1456 CHECK_NULL_VOID(commands);
1457 option->commands = commands;
1458 }
1459
OH_ArkUI_RenderNodeUtils_SetMask(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeMaskOption * option)1460 int32_t OH_ArkUI_RenderNodeUtils_SetMask(ArkUI_RenderNodeHandle node, ArkUI_RenderNodeMaskOption* option)
1461 {
1462 if (node == nullptr || option == nullptr) {
1463 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1464 }
1465 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1466 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1467 auto result = OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1468 auto type = option->type;
1469 ArkUIMaskFill fillColor;
1470 fillColor.fillColor = option->fillColor;
1471 fillColor.strokeColor = option->strokeColor;
1472 fillColor.strokeWidth = option->strokeWidth;
1473 if (type == RECT_SHAPE) {
1474 result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->setRectMask(
1475 node->renderNodeHandle, option->rect, fillColor);
1476 } else if (type == CIRCLE_SHAPE) {
1477 result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->setCircleMask(
1478 node->renderNodeHandle, option->circle, fillColor);
1479 } else if (type == ROUND_RECT_SHAPE) {
1480 result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->setRoundRectMask(
1481 node->renderNodeHandle, option->roundRect, fillColor);
1482 } else if (type == OVAL_SHAPE) {
1483 result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->setOvalMask(
1484 node->renderNodeHandle, option->oval, fillColor);
1485 } else if (type == COMMANDS) {
1486 result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->setCommandPathMask(
1487 node->renderNodeHandle, option->commands, fillColor);
1488 }
1489 return result;
1490 }
1491
OH_ArkUI_RenderNodeUtils_SetClip(ArkUI_RenderNodeHandle node,ArkUI_RenderNodeClipOption * option)1492 int32_t OH_ArkUI_RenderNodeUtils_SetClip(ArkUI_RenderNodeHandle node, ArkUI_RenderNodeClipOption* option)
1493 {
1494 if (node == nullptr || option == nullptr) {
1495 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1496 }
1497 const auto* impl = OHOS::Ace::NodeModel::GetFullImpl();
1498 CHECK_NULL_RETURN(impl, OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR);
1499 auto result = OHOS::Ace::ERROR_CODE_CAPI_INIT_ERROR;
1500 auto type = option->type;
1501 if (type == RECT_SHAPE) {
1502 result =
1503 impl->getNodeModifiers()->getNDKRenderNodeModifier()->setRectClip(node->renderNodeHandle, option->rect);
1504 } else if (type == CIRCLE_SHAPE) {
1505 result =
1506 impl->getNodeModifiers()->getNDKRenderNodeModifier()->setCircleClip(node->renderNodeHandle, option->circle);
1507 } else if (type == ROUND_RECT_SHAPE) {
1508 result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->setRoundRectClip(
1509 node->renderNodeHandle, option->roundRect);
1510 } else if (type == OVAL_SHAPE) {
1511 result =
1512 impl->getNodeModifiers()->getNDKRenderNodeModifier()->setOvalClip(node->renderNodeHandle, option->oval);
1513 } else if (type == COMMANDS) {
1514 result = impl->getNodeModifiers()->getNDKRenderNodeModifier()->setCommandPathClip(
1515 node->renderNodeHandle, option->commands);
1516 }
1517 return result;
1518 }
1519
OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromRectShape(ArkUI_RectShapeOption * shape)1520 ArkUI_RenderNodeMaskOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromRectShape(
1521 ArkUI_RectShapeOption* shape)
1522 {
1523 CHECK_NULL_RETURN(shape, nullptr);
1524 ArkUIRectShape rectShape;
1525 rectShape.left = shape->left;
1526 rectShape.right = shape->right;
1527 rectShape.top = shape->top;
1528 rectShape.bottom = shape->bottom;
1529 ArkUI_RenderNodeMaskOption* option = new ArkUI_RenderNodeMaskOption { .rect = rectShape, .type = RECT_SHAPE };
1530 return option;
1531 }
1532
OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromRoundRectShape(ArkUI_RoundRectShapeOption * shape)1533 ArkUI_RenderNodeMaskOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromRoundRectShape(
1534 ArkUI_RoundRectShapeOption* shape)
1535 {
1536 CHECK_NULL_RETURN(shape, nullptr);
1537 ArkUIRoundRectShape rectShape;
1538 rectShape.left = shape->left;
1539 rectShape.right = shape->right;
1540 rectShape.top = shape->top;
1541 rectShape.bottom = shape->bottom;
1542 rectShape.topLeftX = shape->topLeftX;
1543 rectShape.topLeftY = shape->topLeftY;
1544 rectShape.topRightX = shape->topRightX;
1545 rectShape.topRightY = shape->topRightY;
1546 rectShape.bottomLeftX = shape->bottomLeftX;
1547 rectShape.bottomLeftY = shape->bottomLeftY;
1548 rectShape.bottomRightX = shape->bottomRightX;
1549 rectShape.bottomRightY = shape->bottomRightY;
1550 ArkUI_RenderNodeMaskOption* option = new ArkUI_RenderNodeMaskOption { .roundRect = rectShape,
1551 .type = ROUND_RECT_SHAPE };
1552 return option;
1553 }
1554
OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromCircleShape(ArkUI_CircleShapeOption * shape)1555 ArkUI_RenderNodeMaskOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromCircleShape(
1556 ArkUI_CircleShapeOption* shape)
1557 {
1558 CHECK_NULL_RETURN(shape, nullptr);
1559 ArkUICircleShape rectShape;
1560 rectShape.centerX = shape->centerX;
1561 rectShape.centerY = shape->centerY;
1562 rectShape.radius = shape->radius;
1563 ArkUI_RenderNodeMaskOption* option = new ArkUI_RenderNodeMaskOption { .circle = rectShape, .type = CIRCLE_SHAPE };
1564 return option;
1565 }
1566
OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromOvalShape(ArkUI_RectShapeOption * shape)1567 ArkUI_RenderNodeMaskOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromOvalShape(
1568 ArkUI_RectShapeOption* shape)
1569 {
1570 CHECK_NULL_RETURN(shape, nullptr);
1571 ArkUIRectShape rectShape;
1572 rectShape.left = shape->left;
1573 rectShape.right = shape->right;
1574 rectShape.top = shape->top;
1575 rectShape.bottom = shape->bottom;
1576 ArkUI_RenderNodeMaskOption* option = new ArkUI_RenderNodeMaskOption { .oval = rectShape, .type = OVAL_SHAPE };
1577 return option;
1578 }
1579
OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromCommandPath(ArkUI_CommandPathOption * path)1580 ArkUI_RenderNodeMaskOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromCommandPath(
1581 ArkUI_CommandPathOption* path)
1582 {
1583 CHECK_NULL_RETURN(path, nullptr);
1584 ArkUI_RenderNodeMaskOption* option = new ArkUI_RenderNodeMaskOption { .commands = path->commands,
1585 .type = COMMANDS };
1586 return option;
1587 }
1588
OH_ArkUI_RenderNodeUtils_DisposeRenderNodeMaskOption(ArkUI_RenderNodeMaskOption * option)1589 void OH_ArkUI_RenderNodeUtils_DisposeRenderNodeMaskOption(ArkUI_RenderNodeMaskOption* option)
1590 {
1591 CHECK_NULL_VOID(option);
1592 delete option;
1593 }
1594
OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionFillColor(ArkUI_RenderNodeMaskOption * option,uint32_t fillColor)1595 void OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionFillColor(ArkUI_RenderNodeMaskOption* option, uint32_t fillColor)
1596 {
1597 CHECK_NULL_VOID(option);
1598 option->fillColor = fillColor;
1599 }
1600
OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionStrokeColor(ArkUI_RenderNodeMaskOption * option,uint32_t strokeColor)1601 void OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionStrokeColor(
1602 ArkUI_RenderNodeMaskOption* option, uint32_t strokeColor)
1603 {
1604 CHECK_NULL_VOID(option);
1605 option->strokeColor = strokeColor;
1606 }
1607
OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionStrokeWidth(ArkUI_RenderNodeMaskOption * option,float strokeWidth)1608 void OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionStrokeWidth(ArkUI_RenderNodeMaskOption* option, float strokeWidth)
1609 {
1610 CHECK_NULL_VOID(option);
1611 option->strokeWidth = strokeWidth;
1612 }
1613
OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromRectShape(ArkUI_RectShapeOption * shape)1614 ArkUI_RenderNodeClipOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromRectShape(
1615 ArkUI_RectShapeOption* shape)
1616 {
1617 CHECK_NULL_RETURN(shape, nullptr);
1618 ArkUIRectShape rectShape;
1619 rectShape.left = shape->left;
1620 rectShape.right = shape->right;
1621 rectShape.top = shape->top;
1622 rectShape.bottom = shape->bottom;
1623 ArkUI_RenderNodeClipOption* option = new ArkUI_RenderNodeClipOption { .rect = rectShape, .type = RECT_SHAPE };
1624 return option;
1625 }
1626
OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromRoundRectShape(ArkUI_RoundRectShapeOption * shape)1627 ArkUI_RenderNodeClipOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromRoundRectShape(
1628 ArkUI_RoundRectShapeOption* shape)
1629 {
1630 CHECK_NULL_RETURN(shape, nullptr);
1631 ArkUIRoundRectShape rectShape;
1632 rectShape.left = shape->left;
1633 rectShape.right = shape->right;
1634 rectShape.top = shape->top;
1635 rectShape.bottom = shape->bottom;
1636 rectShape.topLeftX = shape->topLeftX;
1637 rectShape.topLeftY = shape->topLeftY;
1638 rectShape.topRightX = shape->topRightX;
1639 rectShape.topRightY = shape->topRightY;
1640 rectShape.bottomLeftX = shape->bottomLeftX;
1641 rectShape.bottomLeftY = shape->bottomLeftY;
1642 rectShape.bottomRightX = shape->bottomRightX;
1643 rectShape.bottomRightY = shape->bottomRightY;
1644 ArkUI_RenderNodeClipOption* option = new ArkUI_RenderNodeClipOption { .roundRect = rectShape,
1645 .type = ROUND_RECT_SHAPE };
1646 return option;
1647 }
1648
OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromCircleShape(ArkUI_CircleShapeOption * shape)1649 ArkUI_RenderNodeClipOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromCircleShape(
1650 ArkUI_CircleShapeOption* shape)
1651 {
1652 CHECK_NULL_RETURN(shape, nullptr);
1653 ArkUICircleShape rectShape;
1654 rectShape.centerX = shape->centerX;
1655 rectShape.centerY = shape->centerY;
1656 rectShape.radius = shape->radius;
1657 ArkUI_RenderNodeClipOption* option = new ArkUI_RenderNodeClipOption { .circle = rectShape, .type = CIRCLE_SHAPE };
1658 return option;
1659 }
1660
OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromOvalShape(ArkUI_RectShapeOption * shape)1661 ArkUI_RenderNodeClipOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromOvalShape(
1662 ArkUI_RectShapeOption* shape)
1663 {
1664 CHECK_NULL_RETURN(shape, nullptr);
1665 ArkUIRectShape rectShape;
1666 rectShape.left = shape->left;
1667 rectShape.right = shape->right;
1668 rectShape.top = shape->top;
1669 rectShape.bottom = shape->bottom;
1670 ArkUI_RenderNodeClipOption* option = new ArkUI_RenderNodeClipOption { .oval = rectShape, .type = OVAL_SHAPE };
1671 return option;
1672 }
1673
OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromCommandPath(ArkUI_CommandPathOption * path)1674 ArkUI_RenderNodeClipOption* OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromCommandPath(
1675 ArkUI_CommandPathOption* path)
1676 {
1677 CHECK_NULL_RETURN(path, nullptr);
1678 ArkUI_RenderNodeClipOption* option = new ArkUI_RenderNodeClipOption { .commands = path->commands,
1679 .type = COMMANDS };
1680 return option;
1681 }
1682
OH_ArkUI_RenderNodeUtils_DisposeRenderNodeClipOption(ArkUI_RenderNodeClipOption * option)1683 void OH_ArkUI_RenderNodeUtils_DisposeRenderNodeClipOption(ArkUI_RenderNodeClipOption* option)
1684 {
1685 CHECK_NULL_VOID(option);
1686 delete option;
1687 }
1688
1689 #ifdef __cplusplus
1690 };
1691 #endif
1692