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 /** 17 * @addtogroup ArkUI_NativeModule 18 * @{ 19 * 20 * @brief 提供ArkUI在Native侧的UI能力，如UI组件创建销毁、树节点操作，属性设置，事件监听等。 21 * 22 * @since 12 23 */ 24 25 /** 26 * @file native_node.h 27 * 28 * @brief 提供NativeNode接口的类型定义。 29 * 30 * @library libace_ndk.z.so 31 * @syscap SystemCapability.ArkUI.ArkUI.Full 32 * @since 12 33 */ 34 35 #ifndef ARKUI_NATIVE_NODE_H 36 #define ARKUI_NATIVE_NODE_H 37 38 #include "native_event.h" 39 #include "native_type.h" 40 41 #ifdef __cplusplus 42 extern "C" { 43 #endif 44 45 #define MAX_NODE_SCOPE_NUM 1000 46 47 /** 48 * @brief 提供ArkUI在Native侧可创建组件类型。 49 * 50 * @since 12 51 */ 52 typedef enum { 53 /** 自定义节点。 */ 54 ARKUI_NODE_CUSTOM = 0, 55 /** 文本。 */ 56 ARKUI_NODE_TEXT = 1, 57 /** 文本段落。 */ 58 ARKUI_NODE_SPAN, 59 /** 文本图片段落。 */ 60 ARKUI_NODE_IMAGE_SPAN, 61 /** 图片。 */ 62 ARKUI_NODE_IMAGE, 63 /** 状态开关。 */ 64 ARKUI_NODE_TOGGLE, 65 /** 等待图标。 */ 66 ARKUI_NODE_LOADING_PROGRESS, 67 /** 单行文本输入。 */ 68 ARKUI_NODE_TEXT_INPUT, 69 /** 堆叠容器。 */ 70 ARKUI_NODE_STACK, 71 /** 滚动容器。 */ 72 ARKUI_NODE_SCROLL, 73 /** 列表。 */ 74 ARKUI_NODE_LIST, 75 /** 翻页容器。 */ 76 ARKUI_NODE_SWIPER, 77 /** 多行文本。 */ 78 ARKUI_NODE_TEXT_AREA, 79 /** 按钮。 */ 80 ARKUI_NODE_BUTTON, 81 /** 进度条。 */ 82 ARKUI_NODE_PROGRESS, 83 /** 复选框。 */ 84 ARKUI_NODE_CHECKBOX, 85 /** 垂直布局容器。 */ 86 ARKUI_NODE_COLUMN, 87 /** 水平布局容器。 */ 88 ARKUI_NODE_ROW, 89 /** 弹性布局容器。 */ 90 ARKUI_NODE_FLEX, 91 /** 列表项。 */ 92 ARKUI_NODE_LIST_ITEM, 93 /** 刷新组件。 */ 94 ARKUI_NODE_REFRESH, 95 /** XComponent。 */ 96 ARKUI_NODE_XCOMPONENT, 97 /** 列表item分组。 */ 98 ARKUI_NODE_LIST_ITEM_GROUP, 99 /** 日期选择器组件。 */ 100 ARKUI_NODE_DATE_PICKER, 101 /** 时间选择组件。 */ 102 ARKUI_NODE_TIME_PICKER, 103 /** 滑动选择文本内容的组件。 */ 104 ARKUI_NODE_TEXT_PICKER, 105 /** 滑动条组件 */ 106 ARKUI_NODE_SLIDER, 107 } ArkUI_NodeType; 108 109 /** 110 * @brief 定义{@link setAttribute}函数通用入参结构。 111 * 112 * @since 12 113 */ 114 typedef struct { 115 /** 数字类型数组。*/ 116 const ArkUI_NumberValue* value; 117 /** 数字类型数组大小。*/ 118 int32_t size; 119 /** 字符串类型。*/ 120 const char* string; 121 /** 对象类型。*/ 122 void* object; 123 } ArkUI_AttributeItem; 124 125 /** 126 * @brief 定义ArkUI在Native侧可以设置的属性样式集合。 127 * 128 * @since 12 129 */ 130 typedef enum { 131 /** 132 * @brief 宽度属性，支持属性设置，属性重置和属性获取接口。 133 * 134 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 135 * .value[0].f32：宽度数值，单位为vp；\n 136 * \n 137 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 138 * .value[0].f32：宽度数值，单位为vp；\n 139 * 140 * @code {.cpp} 141 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 142 * ArkUI_NumberValue value[] = { 1.2 }; 143 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 144 * nativeNodeApi->setAttribute(nodeHandle, NODE_WIDTH, &item); 145 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_WIDTH); 146 * auto nodeWidth = item->value[0].f32; 147 * @endcode 148 * 149 */ 150 NODE_WIDTH = 0, 151 /** 152 * @brief 高度属性，支持属性设置，属性重置和属性获取接口。 153 * 154 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 155 * .value[0].f32：高度数值，单位为vp；\n 156 * \n 157 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 158 * .value[0].f32：高度数值，单位为vp；\n 159 * 160 * @code {.cpp} 161 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 162 * ArkUI_NumberValue value[] = { 1.2 }; 163 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 164 * nativeNodeApi->setAttribute(nodeHandle, NODE_HEIGHT, &item);clang-tid 165 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_HEIGHT); 166 * auto nodeHeight = item->value[0].f32; 167 * @endcode 168 * 169 */ 170 NODE_HEIGHT, 171 /** 172 * @brief 背景色属性，支持属性设置，属性重置和属性获取接口。 173 * 174 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 175 * .value[0].u32：背景色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 176 * \n 177 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 178 * .value[0].u32：背景色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 179 * 180 * @code {.cpp} 181 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 182 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 183 * ArkUI_AttributeItem item = { value, 1 }; 184 * nativeNodeApi->setAttribute(nodeHandle, NODE_BACKGROUND_COLOR, &item); 185 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_BACKGROUND_COLOR); 186 * auto nodeBackgroundColor = item->value[0].u32; 187 * @endcode 188 * 189 */ 190 NODE_BACKGROUND_COLOR, 191 /** 192 * @brief 背景色图片属性，支持属性设置，属性重置和属性获取接口。 193 * 194 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 195 * .string: 图片地址；\n 196 * .value[0]?.i32：可选值，repeat参数，参数类型{@link ArkUI_ImageRepeat}，默认值为ARKUI_IMAGEREPEAT_NO_REPEAT；\n 197 * \n 198 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 199 * .string: 图片地址；\n 200 * .value[0].i32：repeat参数，参数类型{@link ArkUI_ImageRepeat}；\n 201 * 202 * @code {.cpp} 203 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 204 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_IMAGEREPEAT_NO_REPEAT} }; 205 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue), "/pages/icon.png" }; 206 * nativeNodeApi->setAttribute(nodeHandle, NODE_BACKGROUND_IMAGE, &item); 207 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_BACKGROUND_IMAGE); 208 * auto nodeBackgroundImageUrl = item->string; 209 * auto nodeBackgroundImageRepeat = item->value[0].i32; 210 * @endcode 211 * 212 */ 213 NODE_BACKGROUND_IMAGE, 214 /** 215 * @brief 内间距属性，支持属性设置，属性重置和属性获取接口。 216 * 217 * 属性设置方法参数{@link ArkUI_AttributeItem}格式有两种：\n 218 * 1：上下左右四个位置的内间距值相等。\n 219 * .value[0].f32：内间距数值，单位为vp；\n 220 * 2：分别指定上下左右四个位置的内间距值。\n 221 * .value[0].f32：上内间距数值，单位为vp；\n 222 * .value[1].f32：右内间距数值，单位为vp；\n 223 * .value[2].f32：下内间距数值，单位为vp；\n 224 * .value[3].f32：左内间距数值，单位为vp；\n 225 * \n 226 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 227 * .value[0].f32：上内间距数值，单位为vp；\n 228 * .value[1].f32：右内间距数值，单位为vp；\n 229 * .value[2].f32：下内间距数值，单位为vp；\n 230 * .value[3].f32：左内间距数值，单位为vp；\n 231 * 232 * @code {.cpp} 233 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 234 * ArkUI_NumberValue value1[] = { 1, 2, 3, 4}; 235 * ArkUI_AttributeItem item1 = { value1, sizeof(value1)/sizeof(ArkUI_NumberValue) }; 236 * ArkUI_NumberValue value2[] = { 10 }; 237 * ArkUI_AttributeItem item2 = { value2, sizeof(value2)/sizeof(ArkUI_NumberValue) }; 238 * nativeNodeApi->setAttribute(nodeHandle, NODE_PADDING, &item1); 239 * nativeNodeApi->setAttribute(nodeHandle, NODE_PADDING, &item2); 240 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_PADDING); 241 * auto nodePaddingTop = item->value[0].f32; 242 * @endcode 243 * 244 */ 245 NODE_PADDING, 246 /** 247 * @brief 组件ID属性，支持属性设置，属性重置和属性获取接口。 248 * 249 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 250 * .string: ID的内容；\n 251 * \n 252 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 253 * .string: ID的内容；\n 254 * 255 * @code {.cpp} 256 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 257 * ArkUI_AttributeItem item = { .string = "test" }; 258 * nativeNodeApi->setAttribute(nodeHandle, NODE_ID, &item); 259 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_ID); 260 * auto nodeId = item->string; 261 * @endcode 262 * 263 */ 264 NODE_ID, 265 /** 266 * @brief 通过{@link setAttribute}方法设置组件是否可交互，设置为false可不响应点击等操作。 267 * 268 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 269 * .value[0].i32：false表示不可交互，true表示可交互；\n 270 * \n 271 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 272 * .value[0].i32：0表示不可交互，1表示可交互；\n 273 * 274 * @code {.cpp} 275 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 276 * ArkUI_NumberValue value[] = { {.i32 = false} }; 277 * ArkUI_AttributeItem item = { value, 1 }; 278 * nativeNodeApi->setAttribute(nodeHandle, NODE_ENABLED, &item); 279 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_ENABLED); 280 * auto nodeEnabled = item->value[0].i32; 281 * @endcode 282 */ 283 NODE_ENABLED, 284 /** 285 * @brief 通过{@link setAttribute}方法设置组件外间距。 286 * 287 * {@link ArkUI_AttributeItem}支持两种入参格式：\n 288 * 1：上下左右四个位置的外间距值相等。\n 289 * .value[0].f32：外间距数值，单位为vp；\n 290 * 2：分别指定上下左右四个位置的外间距值。\n 291 * .value[0].f32：上外间距数值，单位为vp；\n 292 * .value[1].f32：右外间距数值，单位为vp；\n 293 * .value[2].f32：下外间距数值，单位为vp；\n 294 * .value[3].f32：左外间距数值，单位为vp。 295 * 296 * @code {.c} 297 * ArkUI_NumberValue value1[] = { 1, 2, 3, 4}; 298 * ArkUI_AttributeItem item1 = { value1, sizeof(value1)/sizeof(ArkUI_NumberValue) }; 299 * ArkUI_NumberValue value2[] = { 10 }; 300 * ArkUI_AttributeItem item2 = { value2, sizeof(value2)/sizeof(ArkUI_NumberValue) }; 301 * basicNodeApi->setAttribute(nodeHandle, NODE_MARGIN, &item1); 302 * basicNodeApi->setAttribute(nodeHandle, NODE_MARGIN, &item2); 303 * @endcode 304 * 305 */ 306 NODE_MARGIN, 307 /** 308 * @brief 通过{@link setAttribute}方法设置组件平移。 309 * 310 * {@link ArkUI_AttributeItem}参数类型：\n 311 * .value[0].f32： x轴移动距离，单位vp，默认值0；\n 312 * .value[1].f32： y轴移动距离，单位vp，默认值0；\n 313 * .value[2].f32： z轴移动距离，单位vp，默认值0。 314 * 315 * @code {.c} 316 * ArkUI_NumberValue value[] = { 100, 20, 0 }; 317 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 318 * basicNodeApi->setAttribute(nodeHandle, NODE_TRANSLATE, &item); 319 * @endcode 320 * 321 */ 322 NODE_TRANSLATE, 323 /** 324 * @brief 通过{@link setAttribute}方法设置组件缩放。 325 * 326 * {@link ArkUI_AttributeItem}参数类型：\n 327 * .value[0].f32： x轴的缩放系数，默认值1；\n 328 * .value[1].f32： y轴的缩放系数，默认值1。 329 * 330 * @code {.c} 331 * ArkUI_NumberValue value[] = { 1.0, 0.5 }; 332 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 333 * basicNodeApi->setAttribute(nodeHandle, NODE_SCALE, &item); 334 * @endcode 335 * 336 */ 337 NODE_SCALE, 338 /** 339 * @brief 通过{@link setAttribute}方法设置组件旋转。 340 * 341 * {@link ArkUI_AttributeItem}参数类型：\n 342 * .value[0].f32： 旋转轴向量x坐标，默认值0；\n 343 * .value[1].f32： 旋转轴向量y坐标，默认值0；\n 344 * .value[2].f32： 旋转轴向量z坐标，默认值0；\n 345 * .value[3].f32： 旋转角度，默认值0；\n 346 * .value[4].f32： 视距，即视点到z=0平面的距离，单位vp，默认值0。 347 * 348 * @code {.c} 349 * ArkUI_NumberValue value[] = { 0, 0, 1, 300, 0 }; 350 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 351 * basicNodeApi->setAttribute(nodeHandle, NODE_ROTATE, &item); 352 * @endcode 353 * 354 */ 355 NODE_ROTATE, 356 /** 357 * @brief 通过{@link setAttribute}方法设置组件高光效果。 358 * 359 * {@link ArkUI_AttributeItem}参数类型：\n 360 * .value[0].f32： 亮度值，默认值1.0，推荐取值范围[0,2]。 361 * 362 * @code {.c} 363 * ArkUI_NumberValue value[] = { 1.2 }; 364 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 365 * basicNodeApi->setAttribute(nodeHandle, NODE_BRIGHTNESS, &item); 366 * @endcode 367 * 368 */ 369 NODE_BRIGHTNESS, 370 /** 371 * @brief 通过{@link setAttribute}方法设置组件饱和度效果。 372 * 373 * {@link ArkUI_AttributeItem}参数类型：\n 374 * .value[0].f32： 饱和度值，默认值1.0，推荐取值范围[0,FLT_MAX]。 375 * 376 * @code {.c} 377 * ArkUI_NumberValue value[] = { 1.0 }; 378 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 379 * basicNodeApi->setAttribute(nodeHandle, NODE_SATURATE, &item); 380 * @endcode 381 * 382 */ 383 NODE_SATURATE, 384 /** 385 * @brief 通过{@link setAttribute}方法设置组件内容模糊效果。 386 * 387 * {@link ArkUI_AttributeItem}参数类型：\n 388 * .value[0].f32： 模糊半径，模糊半径越大越模糊，为0时不模糊。单位vp，默认值0.0。 389 * 390 * @code {.c} 391 * ArkUI_NumberValue value[] = { 1.0 }; 392 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 393 * basicNodeApi->setAttribute(nodeHandle, NODE_BLUR, "1.0"); 394 * @endcode 395 * 396 */ 397 NODE_BLUR, 398 /** 399 * @brief 通过{@link setAttribute}方法设置组件颜色渐变效果。 400 * 401 * {@link ArkUI_AttributeItem}参数类型：\n 402 * .string： 字符串组合参数，入参4个，以分号分割：\n 403 * 入参1： 指定某百分比位置处的渐变色颜色,设置非法颜色直接跳过。颜色和位置（单位vp）数组类型，以逗号分割；\n 404 * 入参2： 线性渐变的起始角度。0点方向顺时针旋转为正向角度，默认值：180；\n 405 * 入参3： 406 * 线性渐变的方向，设置angle后不生效。取值("left","top","right","bottom","left-top","left-bottom","right-top",\n 407 * "right-bottom","none", 默认值 "bottom")；\n 408 * 入参4： 为渐变的颜色重复着色，默认值 false；\n 409 * 如 "#ffff0000,0.0,#ff0000ff,0.3,#ffffff00,0.5;;left;true" 。 410 * @code {.c} 411 * ARKUI_AttributeItem item = { .string = "#ffff0000,0.0,#ff0000ff,0.3,#ffffff00,0.5;;left;true" }; 412 * basicNodeApi->setAttribute(nodeHandle, NODE_LINEAR_GRADIENT, &item); 413 * @endcode 414 * 415 */ 416 NODE_LINEAR_GRADIENT, 417 /** 418 * @brief 通过{@link setAttribute}方法设置组件内容在元素绘制区域内的对齐方式。 419 * 420 * {@link ArkUI_AttributeItem}参数类型：\n 421 * .value[0].i32： 对齐方式，数据类型{@link ArkUI_Alignment}，默认值ARKUI_ALIGNMENT_CENTER。 422 * 423 * @code {.c} 424 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_ALIGNMENT_CENTER } }; 425 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 426 * basicNodeApi->setAttribute(nodeHandle, NODE_ALIGN, "center"); 427 * @endcode 428 * 429 */ 430 NODE_ALIGN, 431 /** 432 * @brief 透明度属性，支持属性设置，属性重置和属性获取接口。 433 * 434 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 435 * .value[0].f32：透明度数值，取值范围为0到1。 \n 436 * \n 437 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 438 * .value[0].f32：透明度数值，取值范围为0到1。 \n 439 * 440 * @code {.cpp} 441 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 442 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 443 * ArkUI_NumberValue value[] = { 0.5 }; 444 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 445 * nativeNodeApi->setAttribute(nodeHandle, NODE_OPACITY, &item); 446 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_OPACITY); 447 * auto nodeOpacity = item->value[0].f32; 448 * @endcode 449 * 450 */ 451 NODE_OPACITY, 452 /** 453 * @brief 边框宽度属性，支持属性设置，属性重置和属性获取接口。 454 * 455 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 456 * 1: .value[0].f32：统一设置四条边的边框宽度。 \n 457 * 2: .value[0].f32：设置上边框的边框宽度。 \n 458 * .value[1].f32：设置右边框的边框宽度。 \n 459 * .value[2].f32：设置下边框的边框宽度。 \n 460 * .value[3].f32：设置左边框的边框宽度。 \n 461 * \n 462 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 463 * .value[0].f32：设置上边框的边框宽度。 \n 464 * .value[1].f32：设置右边框的边框宽度。 \n 465 * .value[2].f32：设置下边框的边框宽度。 \n 466 * .value[3].f32：设置左边框的边框宽度。 \n 467 * 468 * @code {.cpp} 469 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 470 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 471 * ArkUI_NumberValue value[] = { 5 }; 472 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 473 * nativeNodeApi->setAttribute(nodeHandle, NODE_BORDER_WIDTH, &item); 474 * ArkUI_NumberValue value[] = { 5, 5, 10, 10 }; 475 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 476 * nativeNodeApi->setAttribute(nodeHandle, NODE_BORDER_WIDTH, &item); 477 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_BORDER_WIDTH); 478 * auto nodeBorderWitdh = item->value[0].f32; 479 * @endcode 480 * 481 */ 482 NODE_BORDER_WIDTH, 483 /** 484 * @brief 边框圆角属性，支持属性设置，属性重置和属性获取接口。 485 * 486 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 487 * 1: .value[0].f32：统一设置四条边的边框圆角。 \n 488 * 2: .value[0].f32：设置左上角圆角半径。 \n 489 * .value[1].f32：设置右上角圆角半径。 \n 490 * .value[2].f32：设置左下角圆角半径。 \n 491 * .value[3].f32：设置右下角圆角半径。 \n 492 * \n 493 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 494 * .value[0].f32：设置左上角圆角半径。 \n 495 * .value[1].f32：设置右上角圆角半径。 \n 496 * .value[2].f32：设置左下角圆角半径。 \n 497 * .value[3].f32：设置右下角圆角半径。 \n 498 * 499 * @code {.cpp} 500 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 501 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 502 * ArkUI_NumberValue value[] = { 5 }; 503 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 504 * nativeNodeApi->setAttribute(nodeHandle, NODE_BORDER_RADIUS, &item); 505 * ArkUI_NumberValue value[] = { 5, 5, 10, 10 }; 506 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 507 * nativeNodeApi->setAttribute(nodeHandle, NODE_BORDER_RADIUS, &item); 508 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_BORDER_RADIUS); 509 * auto nodeBorderRadius = item->value[0].f32; 510 * @endcode 511 * 512 */ 513 NODE_BORDER_RADIUS, 514 /** 515 * @brief 边框颜色属性，支持属性设置，属性重置和属性获取接口。 516 * 517 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 518 * 1: .value[0].u32：统一设置四条边的边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 519 * 2: .value[0].u32：设置上侧边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 520 * .value[1].u32：设置右侧边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 521 * .value[2].u32：设置下侧边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 522 * .value[3].u32：设置左侧边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 523 * \n 524 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 525 * .value[0].u32：设置上侧边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 526 * .value[1].u32：设置右侧边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 527 * .value[2].u32：设置下侧边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 528 * .value[3].u32：设置左侧边框颜色，使用0xargb表示，如0xFFFF11FF。 \n 529 * 530 * @code {.cpp} 531 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 532 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 533 * ArkUI_NumberValue value[] = { {.u32 = 0xFFFF11FF} }; 534 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 535 * nativeNodeApi->setAttribute(nodeHandle, NODE_BORDER_COLOR, &item); 536 * ArkUI_NumberValue value[] = { {.u32 = 0xFFFF11FF}, {.u32 = 0xFFFF11FF}, {.u32 = 0xFFFFFFFF}, {.u32 = 0x000000} }; 537 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 538 * nativeNodeApi->setAttribute(nodeHandle, NODE_BORDER_COLOR, &item); 539 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_BORDER_COLOR); 540 * auto nodeBorderColor = item->value[0].u32; 541 * @endcode 542 * 543 */ 544 NODE_BORDER_COLOR, 545 /** 546 * @brief 边框线条样式属性，支持属性设置，属性重置和属性获取接口。 547 * 548 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 549 * 1: .value[0].i32：统一设置四条边的边框线条样式，参数类型{@link ArkUI_BorderStyle}，默认值为ARKUI_BORDER_STYLE_SOLID。 \n 550 * 2:.value[0].i32：设置上侧边框线条样式，参数类型{@linkArkUI_BorderStyle}，默认值为ARKUI_BORDER_STYLE_SOLID。 \n 551 * .value[1].i32：设置右侧边框线条样式，参数类型{@link ArkUI_BorderStyle}，默认值为ARKUI_BORDER_STYLE_SOLID。 \n 552 * .value[2].i32：设置下侧边框线条样式，参数类型{@link ArkUI_BorderStyle}，默认值为ARKUI_BORDER_STYLE_SOLID。 \n 553 * .value[3].i32：设置左侧边框线条样式，参数类型{@link ArkUI_BorderStyle}，默认值为ARKUI_BORDER_STYLE_SOLID。 \n 554 * \n 555 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 556 * .value[0].i32：上侧边框线条样式对应的数值。 \n 557 * .value[1].i32：右侧边框线条样式对应的数值。 \n 558 * .value[2].i32：下侧边框线条样式对应的数值。 \n 559 * .value[3].i32：左侧边框线条样式对应的数值。 \n 560 * 561 * @code {.cpp} 562 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 563 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 564 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_BORDER_STYLE_DOTTED} }; 565 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 566 * nativeNodeApi->setAttribute(nodeHandle, NODE_BORDER_STYLE, &item); 567 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_BORDER_STYLE_DOTTED}, {.i32 = ARKUI_BORDER_STYLE_SOLID}, 568 * {.i32 = ARKUI_BORDER_STYLE_SOLID}, {.i32 = ARKUI_BORDER_STYLE_DOTTED} }; 569 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 570 * nativeNodeApi->setAttribute(nodeHandle, NODE_BORDER_STYLE, &item); 571 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_BORDER_STYLE); 572 * auto nodeBorderStyle = item->value[0].i32; 573 * @endcode 574 * 575 */ 576 NODE_BORDER_STYLE, 577 /** 578 * @brief 组件的堆叠顺序属性，支持属性设置，属性重置和属性获取接口。 579 * 580 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 581 * .value[0].f32：堆叠顺序数值。 \n 582 * \n 583 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 584 * .value[0].f32：堆叠顺序数值。 \n 585 * 586 * @code {.cpp} 587 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 588 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 589 * ArkUI_NumberValue value[] = { 2 }; 590 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 591 * nativeNodeApi->setAttribute(nodeHandle, NODE_ZINDEX, &item); 592 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_ZINDEX); 593 * auto nodeZIndex = item->value[0].f32; 594 * @endcode 595 * 596 */ 597 NODE_ZINDEX, 598 /** 599 * @brief 组件是否可见属性，支持属性设置，属性重置和属性获取接口。 600 * 601 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 602 * .value[0].i32：控制当前组件显示或隐藏，参数类型{@link ARKUI_Visibility}，默认值为ARKUI_VISIBILITY_VISIBLE。 \n 603 * \n 604 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 605 * .value[0].i32：控制当前组件显示或隐藏，参数类型{@link ARKUI_Visibility}，默认值为ARKUI_VISIBILITY_VISIBLE。 \n 606 * 607 * @code {.cpp} 608 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 609 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 610 * ArkUI_NumberValue value[] = { {.i32=ARKUI_VISIBILITY_NONE} }; 611 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 612 * nativeNodeApi->setAttribute(nodeHandle, NODE_VISIBILITY, &item); 613 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_VISIBILITY); 614 * auto nodeVisibility = item->value[0].i32; 615 * @endcode 616 * 617 */ 618 NODE_VISIBILITY, 619 /** 620 * @brief 组件进行裁剪、遮罩处理属性，支持属性设置，属性重置和属性获取接口。 621 * 622 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 623 * .value[0].i32：控制是否按照父容器边缘轮廓进行裁剪，0表示不裁切，1表示裁切。 \n 624 * \n 625 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 626 * .value[0].i32：控制是否按照父容器边缘轮廓进行裁剪，0表示不裁切，1表示裁切。 \n 627 * 628 * @code {.cpp} 629 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 630 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 631 * ArkUI_NumberValue value[] = { {.i32 = 0} }; 632 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 633 * nativeNodeApi->setAttribute(nodeHandle, NODE_CLIP, &item); 634 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_CLIP); 635 * auto nodeClip = item->value[0].i32; 636 * @endcode 637 * 638 */ 639 NODE_CLIP, 640 /** 641 * @brief 组件进行裁剪、遮罩处理属性，支持属性设置，属性重置和属性获取接口。 642 * 643 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 644 * .string:形状描述，可选： \n 645 * "rect(10,10,10,10)"括号内分别为width、height、radiusWidth与radiusHeight"; \n 646 * "circle(10,10)"括号内分别为width、height; \n 647 * "ellipse(10,10)"括号内分别为width、height; \n 648 * "path(10,10,M0 0 L600 0)"括号内分别为width、height、commands; \n 649 * \n 650 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 651 * .string:形状描述： \n 652 * "rect(10,10,10,10)"括号内分别为width、height、radiusWidth与radiusHeight"; \n 653 * "circle(10,10)"括号内分别为width、height; \n 654 * "ellipse(10,10)"括号内分别为width、height; \n 655 * "path(10,10,M0 0 L600 0)"括号内分别为width、height、commands; \n 656 * 657 * @code {.cpp} 658 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 659 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 660 * ArkUI_AttributeItem item = { .string = "rect(10,10,10,10)" }; 661 * nativeNodeApi->setAttribute(nodeHandle, NODE_CLIP_SHAPE, &item); 662 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_CLIP); 663 * auto nodeClipShape = item[0].string; 664 * @endcode 665 * 666 */ 667 NODE_CLIP_SHAPE, 668 /** 669 * @brief 矩阵变换功能，可对图形进行平移、旋转和缩放等，支持属性设置，属性重置和属性获取接口。 670 * 671 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 672 * .data[0...15].f32: 16个浮点数字。 \n 673 * \n 674 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 675 * .data[0...15].f32: 16个浮点数字。 \n 676 * 677 * @code {.cpp} 678 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 679 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 680 * ArkUI_NumberValue value[] = { {.f32 = 1}, {.f32 = 0}, {.f32 = 0}, {.f32 = 0}, {.f32 = 0}, {.f32 = 0}, {.f32 = 0}, 681 * {.f32 = 0}, {.f32 = 0}, {.f32 = 1}, {.f32 = 0}, {.f32 = 0}, {.f32 = 0}, {.f32 = 0}, {.f32 = 0}, {.f32 = 1} }; 682 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 683 * nativeNodeApi->setAttribute(nodeHandle, NODE_TRANSFORM, &item); 684 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_TRANSFORM); 685 * auto nodeTransform = item[0].value; 686 * @endcode 687 * 688 */ 689 NODE_TRANSFORM, 690 /** 691 * @brief 触摸测试类型，支持属性设置，属性重置和属性获取接口。 692 * 693 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 694 * .value[0].i32：控制当前组件的触摸测试类型，参数类型{@link ARKUI_HitTestMode}，默认值为ARKUI_HIT_TEST_MODE_DEFAULT。 \n 695 * \n 696 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 697 * .value[0].i32：控制当前组件的触摸测试类型，参数类型{@link ARKUI_HitTestMode}，默认值为ARKUI_HIT_TEST_MODE_DEFAULT。 \n 698 * 699 * @code {.cpp} 700 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 701 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 702 * ArkUI_NumberValue value[] = { {.i32=ARKUI_HIT_TEST_MODE_BLOCK} }; 703 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 704 * nativeNodeApi->setAttribute(nodeHandle, NODE_HIT_TEST_BEHAVIOR, &item); 705 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_HIT_TEST_BEHAVIOR); 706 * auto nodeHitTestBehavior = item->value[0].i32; 707 * @endcode 708 * 709 */ 710 NODE_HIT_TEST_BEHAVIOR, 711 /** 712 * @brief 元素左上角相对于父容器左上角偏移位置，支持属性设置，属性重置和属性获取接口。 713 * 714 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 715 * .value[0].f32：x轴坐标。 \n 716 * .value[1].f32: y轴坐标。 \n 717 * \n 718 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 719 * .value[0].f32：x轴坐标。 \n 720 * .value[1].f32: y轴坐标。 \n 721 * 722 * @code {.cpp} 723 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 724 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 725 * ArkUI_NumberValue value[] = { 50, 50 }; 726 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 727 * nativeNodeApi->setAttribute(nodeHandle, NODE_POSITION, &item); 728 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_POSITION); 729 * auto nodePositionX = item->value[0].f32; 730 * auto nodePositionY = item->value[1].f32; 731 * @endcode 732 * 733 */ 734 NODE_POSITION, 735 /** 736 * @brief 阴影效果属性，支持属性设置，属性重置和属性获取接口。 737 * 738 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 739 * .value[0].i32：设置当前组件阴影效果，参数类型{@link ArkUI_ShadowStyle}。 \n 740 * \n 741 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 742 * .value[0].i32：设置当前组件阴影效果，参数类型{@link ArkUI_ShadowStyle}。 \n 743 * 744 * @code {.cpp} 745 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 746 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 747 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_SHADOW_STYLE_OUTER_DEFAULT_XS} }; 748 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 749 * nativeNodeApi->setAttribute(nodeHandle, NODE_SHADOW, &item); 750 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SHADOW); 751 * auto nodePositionX = item->value[0].i32; 752 * @endcode 753 * 754 */ 755 NODE_SHADOW, 756 /** 757 * @brief 自定义阴影效果，支持属性设置，属性重置和属性获取接口。 758 * 759 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 760 * .string: 字符串组合参数，入参6个，以分号分割： \n 761 * 入参1：阴影模糊半径。 \n 762 * 入参2：阴影的X轴偏移量。 \n 763 * 入参3：阴影的Y轴偏移量。 \n 764 * 入参4：阴影类型。 \n 765 * 入参5：阴影的颜色。 \n 766 * 入参6：阴影是否内部填充。 \n 767 * \n 768 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 769 * .string: 字符串组合参数，入参6个，以分号分割： \n 770 * 入参1：阴影模糊半径。 \n 771 * 入参2：阴影的X轴偏移量。 \n 772 * 入参3：阴影的Y轴偏移量。 \n 773 * 入参4：阴影类型。 \n 774 * 入参5：阴影的颜色。 \n 775 * 入参6：阴影是否内部填充。 \n 776 * 777 * @code {.cpp} 778 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 779 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 780 * ArkUI_AttributeItem item = { .string = "5; 10; 10; COLOR; 0xACCCCC; true" }; 781 * nativeNodeApi->setAttribute(nodeHandle, NODE_CUSTOM_SHADOW, &item); 782 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_CUSTOM_SHADOW); 783 * auto nodeCustomShadow = item[0].string; 784 * @endcode 785 * 786 */ 787 NODE_CUSTOM_SHADOW, 788 /** 789 * @brief 通过<b>setAttribute</b>方法设置组件背景图片的宽高。 790 * 791 * @note 792 * 入参width:number,height:number （默认单位vp）。 793 * @code {.c} 794 * basicNodeApi->setAttribute(nodeHandle, NODE_BACKGROUND_IMAGE_SIZE, "20 40"); 795 * @endcode 796 * 797 */ 798 NODE_BACKGROUND_IMAGE_SIZE, 799 /** 800 * @brief 通过<b>setAttribute</b>为当前组件提供一种背景和内容之间的模糊能力。 801 * 802 * @note 入参blurStyle:String("thin","regular","thick")。 803 * @code {.c} 804 * basicNodeApi->setAttribute(nodeHandle, NODE_BACKGROUND_BLUR_STYLE, "thin"); 805 * @endcode 806 * 807 */ 808 NODE_BACKGROUND_BLUR_STYLE, 809 /** 810 * @brief 通过<b>setAttribute</b>为当前组件设置转场缩放或者旋转的中心点。 811 * 812 * @note 入参: centerX: number，centerY: number，centerZ: number表示中心点。 813 * @code {.c} 814 * basicNodeApi->setAttribute(nodeHandle, NODE_TRANSITION_CENTER, "20 20 0"); 815 * @endcode 816 */ 817 NODE_TRANSITION_CENTER, 818 /** 819 * @brief 通过<b>setAttribute</b>为当前组件设置转场时的透明度效果。 820 * 821 * @note 入参: opacity: number，duration: number, 822 * curve: String("linear","ease","easein","easeout","easeinout","fastoutslowin","linearoutslowin", 823 * "fastoutlinearin"，"extremedeceleration"，"sharp"，"rhythm"，"smooth"，"friction")，delay: number，iterations: 824 * number，playmode: String("normal"，"alternate"，"reverse"，"alternate_reverse")，tempo: number 825 * opacity表示插入时的透明度起点值和删除时的透明度终点值。 826 * duration表示动画播放时长，单位毫秒。curve表示动画曲线。 827 * delay表示动画延迟播放时间，单位毫秒。 828 * iterations表示动画播放次数，默认1次。 829 * playmode表示动画播放模式，默认播放完从头开始播放。 830 * tempo表示动画播放速度，值越大播放越快，默认值1，0表示无动画。 831 * @code {.c} 832 * basicNodeApi->setAttribute(nodeHandle, NODE_OPACITY_TRANSITION, "0.5 3000 ease"); 833 * @endcode 834 */ 835 NODE_OPACITY_TRANSITION, 836 /** 837 * @brief 通过<b>setAttribute</b>为当前组件设置转场时的旋转效果。 838 * 839 * @note 入参: x: number，y: number，z: number，angle: number，perspective: number，duration: number, 840 * curve: String("linear"，"ease"，"easein"，"easeout"，"easeinout"，"fastoutslowin"，"linearoutslowin", 841 * "fastoutlinearin"，"extremedeceleration"，"sharp"，"rhythm"，"smooth"，"friction")，delay: number，iterations: 842 * number，playmode: String("normal"，"alternate"，"reverse"，"alternate_reverse")，tempo: number 843 * 表示插入时的起点值和删除时的终点值。 844 * 其中x表示横向旋转分量，y表示纵向的旋转分量，z表示竖向的旋转分量。 845 * duration表示动画播放时长，单位毫秒。curve表示动画曲线。 846 * delay表示动画延迟播放时间，单位毫秒。 847 * iterations表示动画播放次数，默认1次。 848 * playmode表示动画播放模式，默认播放完从头开始播放。 849 * tempo表示动画播放速度，值越大播放越快，默认值1，0表示无动画。 850 * @code {.c} 851 * basicNodeApi->setAttribute(nodeHandle, NODE_ROTATE_TRANSITION, "0 0 1 180 0 3000 ease"); 852 * @endcode 853 */ 854 NODE_ROTATE_TRANSITION, 855 /** 856 * @brief 通过<b>setAttribute</b>为当前组件设置转场时的缩放效果。 857 * 858 * @note 入参: x: number,y: number,z: number，duration: number, 859 * curve: String("linear","ease","easein","easeout","easeinout","fastoutslowin","linearoutslowin", 860 * "fastoutlinearin"，"extremedeceleration"，"sharp"，"rhythm"，"smooth"，"friction")，delay: number，iterations: 861 * number，playmode: String("normal"，"alternate"，"reverse"，"alternate_reverse")，tempo: number 862 * 其中x表示横向放大倍数，y表示纵向的放大倍数，z表示竖向的放大倍数。 863 * duration表示动画播放时长，单位毫秒。curve表示动画曲线。 864 * delay表示动画延迟播放时间，单位毫秒。 865 * iterations表示动画播放次数，默认1次。 866 * playmode表示动画播放模式，默认播放完从头开始播放。 867 * tempo表示动画播放速度，值越大播放越快，默认值1，0表示无动画。 868 * @code {.c} 869 * basicNodeApi->setAttribute(nodeHandle, NODE_SCALE_TRANSITION, "0 0 0 3000 ease"); 870 * @endcode 871 */ 872 NODE_SCALE_TRANSITION, 873 /** 874 * @brief 通过<b>setAttribute</b>为当前组件设置转场时的平移效果。 875 * 876 * @note 入参: x: number，y: number，z: number，duration: number, 877 * curve: String("linear"，"ease"，"easein"，"easeout"，"easeinout"，"fastoutslowin"，"linearoutslowin", 878 * "fastoutlinearin"，"extremedeceleration"，"sharp"，"rhythm"，"smooth"，"friction")，delay: number，iterations: 879 * number，playmode: String("normal"，"alternate"，"reverse"，"alternate_reverse")，tempo: number 880 * x表示横向的平移距离，y表示纵向的平移距离，z表示竖向的平移距离。 881 * duration表示动画播放时长，单位毫秒。curve表示动画曲线。 882 * delay表示动画延迟播放时间，单位毫秒。 883 * iterations表示动画播放次数，默认1次。 884 * playmode表示动画播放模式，默认播放完从头开始播放。 885 * tempo表示动画播放速度，值越大播放越快，默认值1，0表示无动画。 886 * @code {.c} 887 * basicNodeApi->setAttribute(nodeHandle, NODE_TRANSLATE_TRANSITION, "12 50 0 3000 ease"); 888 * @endcode 889 */ 890 NODE_TRANSLATE_TRANSITION, 891 892 /** 893 * @brief 获焦属性，支持属性设置，属性重置和属性获取。 894 * 895 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 896 * .value[0].i32：参数类型为1或者0。 897 * \n 898 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 899 * .value[0].i32：参数类型为1或者0。 900 * 901 * @code {.c} 902 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 903 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 904 * ArkUI_NumberValue value[] = { { .i32 = 1 } }; 905 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 906 * nativeNodeApi->setAttribute(nodeHandle, NODE_FOCUSABLE, &item); 907 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_FOCUSABLE); 908 * auto value = item->value[0].i32; 909 * @endcode 910 * 911 */ 912 NODE_FOCUSABLE, 913 914 /** 915 * @brief 无障碍组属性, 支持属性设置，属性重置和属性获取。 916 * 917 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 918 * .value[0].i32：为1时表示该组件及其所有子组件为一整个可以选中的组件 919 * 无障碍服务将不再关注其子组件内容。参数类型为1或者0。 920 * \n 921 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 922 * .value[0].i32：为1时表示该组件及其所有子组件为一整个可以选中的组件 923 * 无障碍服务将不再关注其子组件内容。参数类型为1或者0。 924 * 925 * @code {.c} 926 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 927 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 928 * ArkUI_NumberValue value[] = { { .i32 = 1 } }; 929 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 930 * nativeNodeApi->setAttribute(nodeHandle, NODE_ACCESSIBILITY_GROUP, &item); 931 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_ACCESSIBILITY_GROUP); 932 * auto value = item->value[0].i32; 933 * @endcode 934 * 935 */ 936 NODE_ACCESSIBILITY_GROUP, 937 938 /** 939 * @brief 无障碍文本属性，支持属性设置，属性重置和属性获取。 940 * 941 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 942 * .string：无障碍文本。 943 * \n 944 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 945 * .value[0].i32：为1时表示该组件及其所有子组件为一整个可以选中的组件 946 * 无障碍服务将不再关注其子组件内容。参数类型为1或者0。 947 * 948 * @code {.c} 949 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 950 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 951 * ArkUI_AttributeItem item = {.string = "test"}; 952 * nativeNodeApi->setAttribute(nodeHandle, NODE_ACCESSIBILITY_TEXT, &item); 953 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_ACCESSIBILITY_TEXT); 954 * auto value = item->string; 955 * @endcode 956 * 957 */ 958 NODE_ACCESSIBILITY_TEXT, 959 960 /** 961 * @brief 无障碍重要性属性，支持属性设置，属性重置和属性获取。 962 * 963 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 964 * .value[0].i32：障碍重要性，参数类型{@link ArkUI_AccessibilityLevel}。 965 * \n 966 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 967 * .value[0].i32：障碍重要性，参数类型{@link ArkUI_AccessibilityLevel}。 968 * 969 * @code {.c} 970 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 971 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 972 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_ACCESSIBILITY_LEVEL_AUTO } }; 973 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 974 * nativeNodeApi->setAttribute(nodeHandle, NODE_ACCESSIBILITY_LEVEL, &item); 975 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_ACCESSIBILITY_LEVEL); 976 * auto value = item->value[0].i32; 977 * @endcode 978 * 979 */ 980 NODE_ACCESSIBILITY_LEVEL, 981 982 /** 983 * @brief 无障碍说明属性，支持属性设置，属性重置和属性获取。 984 * 985 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 986 * .string：无障碍说明。 987 * \n 988 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 989 * .string：无障碍说明。 990 * 991 * @code {.c} 992 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 993 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 994 * ArkUI_AttributeItem item = { .string = "test" }; 995 * nativeNodeApi->setAttribute(nodeHandle, NODE_ACCESSIBILITY_DESCRIPTION, &item); 996 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_ACCESSIBILITY_DESCRIPTION); 997 * auto value = item->string; 998 * @endcode 999 * 1000 */ 1001 NODE_ACCESSIBILITY_DESCRIPTION, 1002 1003 /** 1004 * @brief 默认焦点属性，支持属性设置，属性重置和属性获取。 1005 * 1006 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 1007 * value[0].i32：参数类型为1或者0。 1008 * \n 1009 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 1010 * value[0].i32：参数类型为1或者0。 1011 * 1012 * @code {.c} 1013 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 1014 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1015 * ArkUI_NumberValue value[] = { { .i32 = 1 } }; 1016 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 1017 * nativeNodeApi->setAttribute(nodeHandle, NODE_DEFAULT_FOCUS, &item); 1018 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_DEFAULT_FOCUS); 1019 * auto value = item->value[0].i32; 1020 * @endcode 1021 * 1022 */ 1023 NODE_DEFAULT_FOCUS, 1024 1025 /** 1026 * @brief 触摸热区属性，支持属性设置，属性重置和属性获取。 1027 * 1028 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 1029 * .data[0].f32：触摸点相对于组件左上角的x轴坐标,单位为vp。 \n 1030 * .data[1].f32：触摸点相对于组件左上角的y轴坐标,单位为vp。 \n 1031 * .data[2].f32：触摸热区的宽度 ，单位为%。 \n 1032 * .data[3].f32：触摸热区的高度，单位为%。 \n 1033 * .data[4...].f32:可以设置多个手势响应区域，顺序和上述一致。 1034 * \n 1035 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 1036 * .data[0].f32：触摸点相对于组件左上角的x轴坐标,单位为vp。 \n 1037 * .data[1].f32：触摸点相对于组件左上角的y轴坐标,单位为vp。 \n 1038 * .data[2].f32：触摸热区的宽度 ，单位为%。 \n 1039 * .data[3].f32：触摸热区的高度，单位为%。 \n 1040 * .data[4...].f32:可以设置多个手势响应区域，顺序和上述一致。 1041 * 1042 * @code {.c} 1043 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 1044 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1045 * ArkUI_NumberValue value[] = { 0, 0, 100, 100 }; 1046 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 1047 * nativeNodeApi->setAttribute(nodeHandle, NODE_RESPONSE_REGION, &item); 1048 * 1049 * ArkUI_NumberValue value[] = { 0, 0, 100, 100, 0, 0, 100, 100 }; 1050 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 1051 * nativeNodeApi->setAttribute(nodeHandle, NODE_RESPONSE_REGION, &item); 1052 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_RESPONSE_REGION); 1053 * auto x = item->value[0].f32; 1054 * auto y = item->value[1].f32; 1055 * auto width = item->value[2].f32; 1056 * auto height = item->value[3].f32; 1057 * @endcode 1058 * 1059 */ 1060 NODE_RESPONSE_REGION, 1061 1062 /** 1063 * @brief 遮罩文本属性，支持属性设置，属性重置和属性获取。 1064 * 1065 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 1066 * .string 遮罩文本；\n 1067 * .value[0]?.i32：可选值，浮层相对于组件的位置，参数类型{@link ArkUI_Alignment}， 1068 * 默认值为ARKUI_ALIGNMENT_TOP_START。 \n 1069 * .value[1]?.i32：可选值，浮层基于自身左上角的偏移量X，单位为vp。 \n 1070 * .value[2]?.i32：可选值，浮层基于自身左上角的偏移量Y，单位为vp。 1071 * \n 1072 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 1073 * .string 遮罩文本； \n 1074 * .value[0]?.i32：可选值，浮层相对于组件的位置，参数类型{@link ArkUI_Alignment}， 1075 * 默认值为ARKUI_ALIGNMENT_TOP_START。 \n 1076 * .value[1]?.i32：可选值，浮层基于自身左上角的偏移量X，单位为vp。 \n 1077 * .value[2]?.i32：可选值，浮层基于自身左上角的偏移量Y，单位为vp。 1078 * 1079 * @code {.c} 1080 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 1081 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1082 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_ALIGNMENT_TOP_START }, 1.2, 0.3 }; 1083 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue), "test"}; 1084 * nativeNodeApi->setAttribute(nodeHandle, NODE_OVERLAY, &item); 1085 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_OVERLAY); 1086 * auto text = item->string; 1087 * @endcode 1088 * 1089 */ 1090 NODE_OVERLAY, 1091 1092 /** 1093 * @brief 通过<b>setAttribute</b>为当前text组件设置内容。 1094 * 1095 * @note 入参:value: String 1096 * @code {.c} 1097 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_CONTENT, "一段文本。"); 1098 * @endcode 1099 */ 1100 NODE_TEXT_CONTENT = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TEXT, 1101 /** 1102 * @brief 组件字体颜色属性，支持属性设置，属性重置和属性获取接口。 1103 * 1104 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1105 * .value[0].u32：字体颜色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 1106 * \n 1107 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1108 * .value[0].u32：字体颜色数值，0xargb格式；\n 1109 * 1110 * @code {.cpp} 1111 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1112 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 1113 * ArkUI_AttributeItem item = { value, 1 }; 1114 * nativeNodeApi->setAttribute(nodeHandle, NODE_FONT_COLOR, &item); 1115 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_FONT_COLOR); 1116 * auto nodeFontColor = item->value[0].u32; 1117 * @endcode 1118 * 1119 */ 1120 NODE_FONT_COLOR, 1121 /** 1122 * @brief 组件字体大小属性，支持属性设置，属性重置和属性获取接口。 1123 * 1124 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1125 * .value[0].f32：字体大小数值，单位为fp；\n 1126 * \n 1127 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1128 * .value[0].f32：字体大小数值，单位为fp；\n 1129 * 1130 * @code {.cpp} 1131 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1132 * ArkUI_NumberValue value[] = { 10 }; 1133 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 1134 * nativeNodeApi->setAttribute(nodeHandle, NODE_FONT_SIZE, &item); 1135 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_FONT_SIZE); 1136 * auto nodeFontSize = item->value[0].f32; 1137 * @endcode 1138 * 1139 */ 1140 NODE_FONT_SIZE, 1141 /** 1142 * @brief 组件字体样式属性，支持属性设置，属性重置和属性获取接口。 1143 * 1144 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1145 * .value[0].i32：字体样式{@link ArkUI_FontStyle}，默认值为ARKUI_FONT_STYLE_NORMAL；\n 1146 * \n 1147 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1148 * .value[0].i32：字体样式{@link ArkUI_FontStyle}；\n 1149 * 1150 * @code {.cpp} 1151 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1152 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_FONT_STYLE_NORMAL} }; 1153 * ArkUI_AttributeItem item = { value, 1 }; 1154 * nativeNodeApi->setAttribute(nodeHandle, NODE_FONT_STYLE, &item); 1155 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_FONT_STYLE); 1156 * auto nodeFontStyle = item->value[0].i32; 1157 * @endcode 1158 * 1159 */ 1160 NODE_FONT_STYLE, 1161 /** 1162 * @brief 组件字体粗细属性，支持属性设置，属性重置和属性获取接口。 1163 * 1164 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1165 * .value[0].i32：字体粗细样式{@link ArkUI_FontWeight}，默认值为ARKUI_FONT_WEIGHT_NORMAL；\n 1166 * \n 1167 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1168 * .value[0].i32：字体粗细样式{@link ArkUI_FontWeight}；\n 1169 * 1170 * @code {.cpp} 1171 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1172 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_FONT_WEIGHT_NORMAL} }; 1173 * ArkUI_AttributeItem item = { value, 1 }; 1174 * nativeNodeApi->setAttribute(nodeHandle, NODE_FONT_WEIGHT, &item); 1175 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_FONT_WEIGHT); 1176 * auto nodeFontWeight = item->value[0].i32; 1177 * @endcode 1178 * 1179 */ 1180 NODE_FONT_WEIGHT, 1181 /** 1182 * @brief 通过<b>setAttribute</b>为当前组件提供设置文本行高的能力。 1183 * 1184 * @note 入参格式为value：number,默认单位vp。 1185 * @code {.c} 1186 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_LINE_HEIGHT, "20"); 1187 * @endcode 1188 */ 1189 NODE_TEXT_LINE_HEIGHT, 1190 /** 1191 * @brief 置文本装饰线样式及其颜色属性，支持属性设置，属性重置和属性获取接口。 1192 * 1193 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1194 * .value[0].i32：文本装饰线样式{@link ArkUI_TextDecorationType}，默认值为ARKUI_TEXT_DECORATION_TYPE_NONE；\n 1195 * .value[1]?.u32：可选值，装饰线颜色，0xargb格式，形如 0xFFFF0000 表示红色；\n 1196 * \n 1197 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1198 * .value[0].i32：文本装饰线样式{@link ArkUI_TextDecorationType}；\n 1199 * .value[1].u32：装饰线颜色，0xargb格式。\n 1200 * 1201 * @code {.cpp} 1202 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1203 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_TEXT_DECORATION_TYPE_NONE}, {.u32=0xFFFF0000} }; 1204 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 1205 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_DECORATION, &item); 1206 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_DECORATION); 1207 * auto nodeDecorationStyle = item->value[0].i32; 1208 * auto nodeDecorationColor = item->value[1].u32; 1209 * @endcode 1210 * 1211 */ 1212 NODE_TEXT_DECORATION, 1213 /** 1214 * @brief 文本大小写属性，支持属性设置，属性重置和属性获取接口。 1215 * 1216 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1217 * .value[0].i32：文本大小写样式{@link ArkUI_TextCase}，默认值为ARKUI_TEXT_CASE_NORMAL；\n 1218 * \n 1219 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1220 * .value[0].i32：文本大小写样式{@link ArkUI_TextCase}。\n 1221 * 1222 * @code {.cpp} 1223 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1224 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_TEXT_CASE_NORMAL} }; 1225 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 1226 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_CASE, &item); 1227 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_CASE); 1228 * auto nodeTextCase = item->value[0].i32; 1229 * @endcode 1230 * 1231 */ 1232 NODE_TEXT_CASE, 1233 /** 1234 * @brief 文本字符间距属性，支持属性设置，属性重置和属性获取接口。 1235 * 1236 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1237 * .value[0].f32：文本字符间距数值，单位为fp；\n 1238 * \n 1239 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1240 * .value[0].f32：文本字符间距数值，单位为fp。\n 1241 * 1242 * @code {.cpp} 1243 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1244 * ArkUI_NumberValue value[] = { 10 }; 1245 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 1246 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_LETTER_SPACING, &item); 1247 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_LETTER_SPACING); 1248 * auto nodeTextLetterSpacing = item->value[0].f32; 1249 * @endcode 1250 * 1251 */ 1252 NODE_TEXT_LETTER_SPACING, 1253 /** 1254 * @brief 通过<b>setAttribute</b>为当前组件提供设置文本最大行数。 1255 * 1256 * @note 入参:value：number 1257 * @code {.c} 1258 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_MAX_LINES, "1"); 1259 * @endcode 1260 */ 1261 NODE_TEXT_MAX_LINES, 1262 /** 1263 * @brief 字体水平对齐属性，支持属性设置，属性重置和属性获取接口。 1264 * 1265 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1266 * .value[0].i32：水平对齐方式{@link ArkUI_TextAlign}，默认值为ARKUI_TEXT_ALIGN_START；\n 1267 * \n 1268 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1269 * .value[0].i32：水平对齐方式{@link ArkUI_TextAlign}。\n 1270 * 1271 * @code {.cpp} 1272 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1273 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_TEXT_ALIGN_START} }; 1274 * ArkUI_AttributeItem item = { value, 1 }; 1275 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_ALIGN, &item); 1276 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_ALIGN); 1277 * auto nodeTextAlign = item->value[0].i32; 1278 * @endcode 1279 * 1280 */ 1281 NODE_TEXT_ALIGN, 1282 /** 1283 * @brief 通过<b>setAttribute</b>为当前组件提供设置文本超长时的显示方式。 1284 * 1285 * @note 入参:value: String("none"，"clip"，"ellipsis"，"marquee") 1286 * @code {.c} 1287 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_OVER_FLOW, "ellipsis"); 1288 * @endcode 1289 */ 1290 NODE_TEXT_OVER_FLOW, 1291 /** 1292 * @brief Text字体列表属性，支持属性设置，属性重置和属性获取。 1293 * 1294 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 1295 * .string：字体字符串，多个用,分隔。 1296 * \n 1297 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 1298 * .string：字体字符串，多个用,分隔。 1299 * 1300 * @code {.c} 1301 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 1302 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1303 * ArkUI_AttributeItem item = {.string = "HarmonyOS Sans"}; 1304 * nativeNodeApi->setAttribute(nodeHandle, NODE_FONT_FAMILY, &item); 1305 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_FONT_FAMILY); 1306 * auto font = item->string; 1307 * @endcode 1308 * 1309 */ 1310 NODE_FONT_FAMILY, 1311 /** 1312 * @brief 文本复制粘贴属性，支持属性设置，属性重置和属性获取接口。 1313 * 1314 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1315 * .value[0].i32：复制粘贴方式{@link ArkUI_CopyOptions}，默认值为ARKUI_COPY_OPTIONS_NONE；\n 1316 * \n 1317 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1318 * .value[0].i32：复制粘贴方式{@link ArkUI_CopyOptions}。\n 1319 * 1320 * @code {.cpp} 1321 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1322 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_COPY_OPTIONS_NONE} }; 1323 * ArkUI_AttributeItem item = { value, 1 }; 1324 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_COPY_OPTION, &item); 1325 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_COPY_OPTION); 1326 * auto nodeTextCopyOption = item->value[0].i32; 1327 * @endcode 1328 * 1329 */ 1330 NODE_TEXT_COPY_OPTION, 1331 /** 1332 * @brief 文本基线的偏移量属性，支持属性设置，属性重置和属性获取接口。 1333 * 1334 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1335 * .value[0].f32：偏移量数值，单位为fp；\n 1336 * \n 1337 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1338 * .value[0].f32：偏移量数值，单位为fp。\n 1339 * 1340 * @code {.cpp} 1341 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1342 * ArkUI_NumberValue value[] = { 10 }; 1343 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 1344 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_BASELINE_OFFSET, &item); 1345 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_BASELINE_OFFSET); 1346 * auto nodeTextBaselineOffset = item->value[0].f32; 1347 * @endcode 1348 * 1349 */ 1350 NODE_TEXT_BASELINE_OFFSET, 1351 /** 1352 * @brief 文字阴影效果属性，支持属性设置，属性重置和属性获取接口。 1353 * 1354 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1355 * .value[0].f32：阴影模糊半径，单位为vp；\n 1356 * .value[1].i32：阴影类型{@link ArkUI_ShadowType}，默认值为ARKUI_SHADOW_TYPE_COLOR；\n 1357 * .value[2].u32：阴影颜色，0xargb格式，形如 0xFFFF0000 表示红色；\n 1358 * .value[3].f32：阴影X轴偏移量，单位为vp；\n 1359 * .value[4].f32：阴影Y轴偏移量，单位为vp；\n 1360 * \n 1361 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1362 * .value[0].f32：阴影模糊半径，单位为vp；\n 1363 * .value[1].i32：阴影类型{@link ArkUI_ShadowType}；\n 1364 * .value[2].u32：阴影颜色，0xargb格式；\n 1365 * .value[3].f32：阴影X轴偏移量，单位为vp；\n 1366 * .value[4].f32：阴影Y轴偏移量，单位为vp；\n 1367 * 1368 * @code {.cpp} 1369 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1370 * ArkUI_NumberValue value[] = { 10, {.i32=ARKUI_SHADOW_TYPE_COLOR}, {.u32=0xFFFF0000}, 10, 10 }; 1371 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 1372 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_TEXT_SHADOW, &item); 1373 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_TEXT_SHADOW); 1374 * auto nodeTextShadowRadius = item->value[0].f32; 1375 * auto nodeTextShadowType = item->value[1].i32; 1376 * auto nodeTextShadowColor = item->value[2].u32; 1377 * auto nodeTextShadowOffsetX = item->value[3].f32; 1378 * auto nodeTextShadowOffsetY = item->value[4].f32; 1379 * @endcode 1380 * 1381 */ 1382 NODE_TEXT_TEXT_SHADOW, 1383 1384 /** 1385 * @brief Text最小显示字号，支持属性设置，属性重置和属性获取。 1386 * 1387 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 1388 * .value[0].f32：文本最小显示字号，单位FP。 1389 * \n 1390 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 1391 * .value[0].f32：文本最小显示字号，单位FP。 1392 * 1393 * @code {.c} 1394 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 1395 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1396 * ArkUI_NumberValue value[] = { 20 }; 1397 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 1398 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_MIN_FONT_SIZE, &item); 1399 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_TEXT_MIN_FONT_SIZE); 1400 * auto value = item->value[0].f32; 1401 * @endcode 1402 * 1403 */ 1404 NODE_TEXT_MIN_FONT_SIZE, 1405 1406 /** 1407 * @brief Text最大显示字号，支持属性设置，属性重置和属性获取。 1408 * 1409 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 1410 * .value[0].f32：文本最大显示字号 单位FP。 1411 * \n 1412 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 1413 * .value[0].f32：文本最大显示字号 单位FP。 1414 * 1415 * @code {.c} 1416 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 1417 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1418 * ArkUI_NumberValue value[] = { 20 }; 1419 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 1420 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_MAX_FONT_SIZE, &item); 1421 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_TEXT_MAX_FONT_SIZE); 1422 * auto value = item->value[0].f32; 1423 * @endcode 1424 * 1425 */ 1426 NODE_TEXT_MAX_FONT_SIZE, 1427 1428 /** 1429 * @brief Text样式，支持属性设置，属性重置和属性获取。 1430 * 1431 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 1432 * .string?：可选值 字体列表，使用多个字体，使用','进行分割。 \n 1433 * .value[0].f32：文本尺寸 单位FP。 \n 1434 * .value[1]?.i32：可选值，文本的字体粗细，参数类型{@link ArkUI_FontWeight}。 1435 * 默认值为ARKUI_FONT_WEIGHT_NORMAL。 \n 1436 * .value[2]?.i32：可选值，字体样式，参数类型{@link ArkUI_FontStyle}。 1437 * 默认值为ARKUI_TEXT_FONT_STYLE_NORMAL。 1438 * \n 1439 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 1440 * .string?：可选值 字体列表，使用多个字体，使用','进行分割。 \n 1441 * .value[0].f32：文本尺寸 单位FP。 \n 1442 * .value[1]?.i32：可选值，文本的字体粗细，参数类型{@link ArkUI_FontWeight}。 1443 * 默认值为ARKUI_FONT_WEIGHT_NORMAL。 \n 1444 * .value[2]?.i32：可选值，字体样式，参数类型{@link ArkUI_FontStyle}。 1445 * 默认值为ARKUI_TEXT_FONT_STYLE_NORMAL。 1446 * 1447 * @code {.c} 1448 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 1449 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1450 * ArkUI_NumberValue value[] = { 16, { .i32 = ARKUI_FONT_STYLE_NORMAL }, 1451 * { .i32 = ARKUI_TEXT_FONT_STYLE_NORMAL } }; 1452 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 1453 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_FONT, &item); 1454 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_TEXT_FONT); 1455 * auto size = item->value[0].f32; 1456 * @endcode 1457 * 1458 */ 1459 NODE_TEXT_FONT, 1460 1461 /** 1462 * @brief Text自适应高度的方式，支持属性设置，属性重置和属性获取。 1463 * 1464 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 1465 * .value[0].i32：参数类型{@link ArkUI_TextHeightAdaptivePolicy}。 1466 * \n 1467 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 1468 * .value[0].i32：参数类型{@link ArkUI_TextHeightAdaptivePolicy}。 1469 * 1470 * @code {.c} 1471 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 1472 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1473 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_TEXT_HEIGHT_ADAPTIVE_POLICY_MAX_LINES_FIRST } }; 1474 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 1475 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY, &item); 1476 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY); 1477 * auto size = item->value[0].i32; 1478 * @endcode 1479 * 1480 */ 1481 NODE_TEXT_HEIGHT_ADAPTIVE_POLICY, 1482 1483 /** 1484 * @brief 通过<b>setAttribute</b>为当前span组件设置文本内容。 1485 * 1486 * @note 入参:value: String。 1487 * @code {.c} 1488 * basicNodeApi->setAttribute(nodeHandle, NODE_SPAN_CONTENT, "一段文本。"); 1489 * @endcode 1490 */ 1491 NODE_SPAN_CONTENT = MAX_NODE_SCOPE_NUM * ARKUI_NODE_SPAN, 1492 /** 1493 * @brief 通过<b>setAttribute</b>为当前imageSpan组件设置图片地址。 1494 * 1495 * @note 入参:value: String。 1496 * @code {.c} 1497 * basicNodeApi->setAttribute(nodeHandle, NODE_IMAGE_SPAN_SRC, "https://www.example.com/xxx.png"); 1498 * @endcode 1499 */ 1500 NODE_IMAGE_SPAN_SRC = MAX_NODE_SCOPE_NUM * ARKUI_NODE_IMAGE_SPAN, 1501 /** 1502 * @brief 通过<b>setAttribute</b>为当前imageSpan组件设置图片基于文本的对齐方式。 1503 * 1504 * @note 入参:value: String("top","center","bottom","baseline","none")。 1505 * @code {.c} 1506 * basicNodeApi->setAttribute(nodeHandle, NODE_IMAGE_SPAN_VERTICAL_ALIGN, "center"); 1507 * @endcode 1508 */ 1509 NODE_IMAGE_SPAN_VERTICAL_ALIGN, 1510 /** 1511 * @brief 通过<b>setAttribute</b>为当前image组件设置图片地址。 1512 * 1513 * @note 入参:value: String。 1514 * @code {.c} 1515 * basicNodeApi->setAttribute(nodeHandle, NODE_IMAGE_SRC, "https://www.example.com/xxx.png"); 1516 * @endcode 1517 */ 1518 NODE_IMAGE_SRC = MAX_NODE_SCOPE_NUM * ARKUI_NODE_IMAGE, 1519 /** 1520 * @brief 通过<b>setAttribute</b>为当前image组件设置图片填充效果。 1521 * 1522 * @note 入参:value: String("fill"，"contain"，"cover"，"fitwidth"，"fitheight"，"none", 1523 * "scale_down"，"top_left" )。 1524 * @code {.c} 1525 * basicNodeApi->setAttribute(nodeHandle, NODE_IMAGE_OBJECT_FIT, "fill"); 1526 * @endcode 1527 */ 1528 NODE_IMAGE_OBJECT_FIT, 1529 /** 1530 * @brief 通过<b>setAttribute</b>为当前image组件设置图片插值效果效果,缓解图片缩放时的锯齿问题。 1531 * 1532 * @note 入参:value: String("none"，"low"，"medium"，"high")。 1533 * @code {.c} 1534 * basicNodeApi->setAttribute(nodeHandle, NODE_IMAGE_INTERPOLATION, "low"); 1535 * @endcode 1536 */ 1537 NODE_IMAGE_INTERPOLATION, 1538 /** 1539 * @brief 通过<b>setAttribute</b>为当前image组件设置图片重复样式。 1540 * 1541 * @note 入参:value: String("no_repeat"，"repeat_x"，"repeat_y"，"repeat" ) 1542 * @code {.c} 1543 * basicNodeApi->setAttribute(nodeHandle, NODE_IMAGE_OBJECT_REPEAT, "repeat"); 1544 * @endcode 1545 */ 1546 NODE_IMAGE_OBJECT_REPEAT, 1547 /** 1548 * @brief 通过<b>setAttribute</b>为当前image组件设置图片滤镜效果。 1549 * 1550 * @note 入参:colorFilter: String(4*5的转换矩阵)。 1551 * @code {.c} 1552 * basicNodeApi->setAttribute(nodeHandle, NODE_IMAGE_COLOR_FILTER, "1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0"); 1553 * @endcode 1554 */ 1555 NODE_IMAGE_COLOR_FILTER, 1556 1557 /** 1558 * @brief 组件打开状态的背景颜色属性，支持属性设置，属性重置和属性获取接口。 1559 * 1560 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1561 * .value[0].u32：背景色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 1562 * \n 1563 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1564 * .value[0].u32：背景色数值，0xargb格式。\n 1565 * 1566 * @code {.cpp} 1567 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1568 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 1569 * ArkUI_AttributeItem item = { value, 1 }; 1570 * basicNodeApi->setAttribute(nodeHandle, NODE_TOGGLE_SELECTED_COLOR, &item); 1571 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TOGGLE_SELECTED_COLOR); 1572 * auto nodeToggleSelectedColor = item->value[0].u32; 1573 * @endcode 1574 * 1575 */ 1576 NODE_TOGGLE_SELECTED_COLOR = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TOGGLE, 1577 /** 1578 * @brief Switch类型的圆形滑块颜色属性，支持属性设置，属性重置和属性获取接口。 1579 * 1580 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1581 * .value[0].u32：圆形滑块颜色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 1582 * \n 1583 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1584 * .value[0].u32：圆形滑块颜色数值，0xargb格式。\n 1585 * 1586 * @code {.cpp} 1587 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1588 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 1589 * ArkUI_AttributeItem item = { value, 1 }; 1590 * nativeNodeApi->setAttribute(nodeHandle, NODE_TOGGLE_SWITCH_POINT_COLOR, &item); 1591 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TOGGLE_SWITCH_POINT_COLOR); 1592 * auto nodeSwitchPointColor = item->value[0].u32; 1593 * @endcode 1594 * 1595 */ 1596 NODE_TOGGLE_SWITCH_POINT_COLOR, 1597 1598 /** 1599 * @brief 加载进度条前景色属性，支持属性设置，属性重置和属性获取接口。 1600 * 1601 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1602 * .value[0].u32：前景颜色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 1603 * \n 1604 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1605 * .value[0].u32：前景颜色数值，0xargb格式。\n 1606 * 1607 * @code {.cpp} 1608 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1609 * ArkUI_NumberValue value[] = { { .u32 = 0x99666666 } }; 1610 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 1611 * nativeNodeApi->setAttribute(nodeHandle, NODE_LOADING_PROGRESS_COLOR, &item); 1612 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_LOADING_PROGRESS_COLOR); 1613 * auto nodeLoadingProgressColor = item->value[0].u32; 1614 * @endcode 1615 * 1616 */ 1617 NODE_LOADING_PROGRESS_COLOR = MAX_NODE_SCOPE_NUM * ARKUI_NODE_LOADING_PROGRESS, 1618 /** 1619 * @brief LoadingProgress动画显示属性，支持属性设置，属性重置和属性获取接口。 1620 * 1621 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1622 * .value[0].i32：false时不显示动画，true时可以显示动画；\n 1623 * \n 1624 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1625 * .value[0].i32：0时不显示动画，1时可以显示动画。\n 1626 * 1627 * @code {.cpp} 1628 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1629 * ArkUI_NumberValue value[] = { { .i32 = true } }; 1630 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 1631 * nativeNodeApi->setAttribute(nodeHandle, NODE_LOADING_PROGRESS_ENABLE_LOADING, &item); 1632 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_LOADING_PROGRESS_ENABLE_LOADING); 1633 * auto nodeLoadingProgressEnableLoading = item->value[0].i32; 1634 * @endcode 1635 */ 1636 NODE_LOADING_PROGRESS_ENABLE_LOADING, 1637 1638 /** 1639 * @brief 单行文本输入框的默认提示文本内容属性，支持属性设置，属性重置和属性获取接口。 1640 * 1641 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1642 * .string：默认提示文本的内容；\n 1643 * \n 1644 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1645 * .string：默认提示文本的内容。\n 1646 * 1647 * @code {.cpp} 1648 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1649 * ArkUI_AttributeItem item = { .string="input" }; 1650 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_PLACEHOLDER, &item); 1651 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_PLACEHOLDER); 1652 * auto nodeTextInputPlaceholder = item->string; 1653 * @endcode 1654 * 1655 */ 1656 NODE_TEXT_INPUT_PLACEHOLDER = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TEXT_INPUT, 1657 /** 1658 * @brief 单行文本输入框的默认文本内容属性，支持属性设置，属性重置和属性获取接口。 1659 * 1660 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1661 * .string：默认文本的内容；\n 1662 * \n 1663 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1664 * .string：默认文本的内容。\n 1665 * 1666 * @code {.cpp} 1667 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1668 * ArkUI_AttributeItem item = { .string="input" }; 1669 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_TEXT, &item); 1670 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_TEXT); 1671 * auto nodeTextInputText = item->string; 1672 * @endcode 1673 * 1674 */ 1675 NODE_TEXT_INPUT_TEXT, 1676 /** 1677 * @brief 光标颜色属性，支持属性设置，属性重置和属性获取接口。 1678 * 1679 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1680 * .value[0].u32：背景色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 1681 * \n 1682 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1683 * .value[0].u32：背景色数值，0xargb格式。\n 1684 * 1685 * @code {.cpp} 1686 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1687 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 1688 * ArkUI_AttributeItem item = { value, 1 }; 1689 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_CARET_COLOR, &item); 1690 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_CARET_COLOR); 1691 * auto nodeTextInputCaretColor = item->value[0].u32; 1692 * @endcode 1693 * 1694 */ 1695 NODE_TEXT_INPUT_CARET_COLOR, 1696 /** 1697 * @brief 光标风格属性，支持属性设置，属性重置和属性获取接口。 1698 * 1699 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1700 * .value[0].f32：光标宽度数值，单位为vp；\n 1701 * \n 1702 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1703 * .value[0].f32：光标宽度数值，单位为vp。\n 1704 * 1705 * @code {.cpp} 1706 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1707 * ArkUI_NumberValue value[] = { 100 }; 1708 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 1709 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_CARET_STYLE, &item); 1710 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_CARET_STYLE); 1711 * auto nodeTextInputCaretStyle = item->value[0].f32; 1712 * @endcode 1713 * 1714 */ 1715 NODE_TEXT_INPUT_CARET_STYLE, 1716 /** 1717 * @brief 单行文本输入框下划线属性，支持属性设置，属性重置和属性获取接口。 1718 * 1719 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1720 * .value[0].i32：false表示不展示下划线，true表示展示下划线；\n 1721 * \n 1722 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1723 * .value[0].i32：0表示不展示下划线，1表示展示下划线。\n 1724 * 1725 * @code {.cpp} 1726 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1727 * ArkUI_NumberValue value[] = { {.i32 = true} }; 1728 * ArkUI_AttributeItem item = { value, 1 }; 1729 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_SHOW_UNDERLINE, &item); 1730 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_SHOW_UNDERLINE); 1731 * auto nodeTextInputUnderline = item->value[0].i32; 1732 * @endcode 1733 * 1734 */ 1735 NODE_TEXT_INPUT_SHOW_UNDERLINE, 1736 /** 1737 * @brief 输入框支持的最大文本数属性，支持属性设置，属性重置和属性获取接口。 1738 * 1739 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1740 * .value[0].i32：最大文本数的数字，无单位；\n 1741 * \n 1742 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1743 * .value[0].i32：最大文本数的数字。\n 1744 * 1745 * @code {.cpp} 1746 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1747 * ArkUI_NumberValue value[] = { { .i32 = 50 } }; 1748 * ArkUI_AttributeItem item = { value, 1 }; 1749 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_MAX_LENGTH, &item); 1750 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_MAX_LENGTH); 1751 * auto nodeTextInputMaxlength = item->value[0].i32; 1752 * @endcode 1753 * 1754 */ 1755 NODE_TEXT_INPUT_MAX_LENGTH, 1756 /** 1757 * @brief 回车键类型属性，支持属性设置，属性重置和属性获取接口。 1758 * 1759 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1760 * .value[0].i32：回车键类型枚举{@link ArkUI_EnterKeyType}，默认值为ARKUI_ENTER_KEY_TYPE_DONE；\n 1761 * \n 1762 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1763 * .value[0].i32：回车键类型枚举{@link ArkUI_EnterKeyType}。\n 1764 * 1765 * @code {.cpp} 1766 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1767 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_ENTER_KEY_TYPE_DONE} }; 1768 * ArkUI_AttributeItem item = { value, 1 }; 1769 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_ENTER_KEY_TYPE, &item); 1770 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_ENTER_KEY_TYPE); 1771 * auto nodeTextInputMaxlength = item->value[0].i32; 1772 * @endcode 1773 * 1774 */ 1775 NODE_TEXT_INPUT_ENTER_KEY_TYPE, 1776 /** 1777 * @brief 无输入时默认提示文本的颜色属性，支持属性设置，属性重置和属性获取接口。 1778 * 1779 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1780 * .value[0].u32：颜色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 1781 * \n 1782 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1783 * .value[0].u32：颜色数值，0xargb格式。\n 1784 * 1785 * @code {.cpp} 1786 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1787 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 1788 * ArkUI_AttributeItem item = { value, 1 }; 1789 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_PLACEHOLDER_COLOR, &item); 1790 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_PLACEHOLDER_COLOR); 1791 * auto nodeTextInputPlaceholderColor = item->value[0].u32; 1792 * @endcode 1793 * 1794 */ 1795 NODE_TEXT_INPUT_PLACEHOLDER_COLOR, 1796 /** 1797 * @brief 无输入时默认提示文本的字体配置（包括大小、字重、样式、字体列表）属性，支持属性设置，属性重置和属性获取接口。 1798 * 1799 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1800 * .value[0]?.f32：可选字体大小数值，默认值16.0，单位为fp；\n 1801 * .value[1]?.i32：可选字体样式{@link ArkUI_FontStyle}，默认值为ARKUI_FONT_STYLE_NORMAL；\n 1802 * .value[2]?.i32：可选字体粗细样式{@link ArkUI_FontWeight}，默认值为ARKUI_FONT_WEIGHT_NORMAL；\n 1803 * ?.string: 字体族内容，多个字体族之间使用逗号分隔，形如“字重；字体族1，字体族2”；\n 1804 * \n 1805 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1806 * .value[0].f32：字体大小数值，单位为fp；\n 1807 * .value[1].i32：字体样式{@link ArkUI_FontStyle}；\n 1808 * .value[2].i32：字体粗细样式{@link ArkUI_FontWeight}；\n 1809 * .string: 字体族内容，多个字体族之间使用逗号分隔。\n 1810 * 1811 * @code {.cpp} 1812 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1813 * ArkUI_NumberValue value[] = \n 1814 * { 16.0, {.i32=ARKUI_FONT_STYLE_NORMAL}, {.i32=ARKUI_FONT_WEIGHT_NORMAL} }; 1815 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue), "Arial" }; 1816 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &item); 1817 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_PLACEHOLDER_FONT); 1818 * auto nodeTextInputPlaceholderFontSize = item->value[0].f32; 1819 * auto nodeTextInputPlaceholderFontStyle = item->value[1].i32; 1820 * auto nodeTextInputPlaceholderFontWeight = item->value[2].i32; 1821 * auto nodeTextInputPlaceholderFontFamily = item->string; 1822 * @endcode 1823 * 1824 */ 1825 NODE_TEXT_INPUT_PLACEHOLDER_FONT, 1826 /** 1827 * @brief 聚焦时是否绑定输入法属性，支持属性设置，属性重置和属性获取接口。 1828 * 1829 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1830 * .value[0].i32：false表示聚焦不拉起输入法，true表示拉起；\n 1831 * \n 1832 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1833 * .value[0].i32：0表示聚焦不拉起输入法，1表示拉起。\n 1834 * 1835 * @code {.cpp} 1836 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1837 * ArkUI_NumberValue value[] = { {.i32 = true} }; 1838 * ArkUI_AttributeItem item = { value, 1 }; 1839 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, &item); 1840 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS); 1841 * auto nodeTextInputFocusKeyboard = item->value[0].i32; 1842 * @endcode 1843 * 1844 */ 1845 NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, 1846 /** 1847 * @brief 输入框的类型属性，支持属性设置，属性重置和属性获取接口。 1848 * 1849 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1850 * .value[0].i32：输入框类型枚举{@link ArkUI_TextInputType}，默认值为ARKUI_TEXTINPUT_TYPE_NORMAL；\n 1851 * \n 1852 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1853 * .value[0].i32：输入框类型枚举{@link ArkUI_TextInputType}。\n 1854 * 1855 * @code {.cpp} 1856 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1857 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_TEXTINPUT_TYPE_NORMAL} }; 1858 * ArkUI_AttributeItem item = { value, 1 }; 1859 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_TYPE, &item); 1860 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_TYPE); 1861 * auto nodeTextInputType = item->value[0].i32; 1862 * @endcode 1863 * 1864 */ 1865 NODE_TEXT_INPUT_TYPE, 1866 /** 1867 * @brief 输入框文本选中时的背景色属性，支持属性设置，属性重置和属性获取接口。 1868 * 1869 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1870 * .value[0].u32：颜色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 1871 * \n 1872 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1873 * .value[0].u32：颜色数值，0xargb格式。\n 1874 * 1875 * @code {.cpp} 1876 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1877 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 1878 * ArkUI_AttributeItem item = { value, 1 }; 1879 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_SELECTED_BACKGROUND_COLOR, &item); 1880 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_SELECTED_BACKGROUND_COLOR); 1881 * auto nodeTextInputSelectedColor = item->value[0].u32; 1882 * @endcode 1883 * 1884 */ 1885 NODE_TEXT_INPUT_SELECTED_BACKGROUND_COLOR, 1886 /** 1887 * @brief 密码输入模式时是否显示末尾图标属性，支持属性设置，属性重置和属性获取接口。 1888 * 1889 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1890 * .value[0].i32：false表示不显示图标，true表示显示图标；\n 1891 * \n 1892 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1893 * .value[0].i32：0表示不显示图标，1表示显示图标。\n 1894 * 1895 * @code {.cpp} 1896 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1897 * ArkUI_NumberValue value[] = { {.i32 = true} }; 1898 * ArkUI_AttributeItem item = { value, 1 }; 1899 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, &item); 1900 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON); 1901 * auto nodeTextInputPasswordIcon = item->value[0].i32; 1902 * @endcode 1903 * 1904 */ 1905 NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, 1906 /** 1907 * @brief 控制单行文本输入框编辑态属性，支持属性设置。 1908 * 1909 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1910 * .value[0].i32：false表示退出编辑态，true表示维持现状。 1911 * 1912 * @code {.cpp} 1913 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1914 * ArkUI_NumberValue value[] = { {.i32 = false} }; 1915 * ArkUI_AttributeItem item = { value, 1 }; 1916 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_EDITING, &item); 1917 * @endcode 1918 * 1919 */ 1920 NODE_TEXT_INPUT_EDITING, 1921 /** 1922 * @brief 单行文本右侧清除按钮样式属性，支持属性设置，属性重置和属性获取接口。 1923 * 1924 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 1925 * .value[0].i32：按钮样式{@link ArkUI_CancelButtonStyle}，默认值为ARKUI_CANCELBUTTON_STYLE_INPUT；\n 1926 * .value[1]?.f32：图标大小数值，单位为vp；\n 1927 * .value[2]?.u32：按钮图标颜色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 1928 * ?.string：按钮图标地址，入参内容为图片本地地址，例如 /pages/icon.png；\n 1929 * \n 1930 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 1931 * .value[0].i32：按钮样式{@link ArkUI_CancelButtonStyle}；\n 1932 * .value[1].f32：图标大小数值，单位为vp；\n 1933 * .value[2].u32：按钮图标颜色数值，0xargb格式；\n 1934 * .string：按钮图标地址；\n 1935 * 1936 * @code {.cpp} 1937 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 1938 * ArkUI_NumberValue value[] = { {.i32=ARKUI_CANCELBUTTON_STYLE_INPUT}, 10.0, {.u32=0xFFFF0000} }; 1939 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue), "/pages/icon.png" }; 1940 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_INPUT_CANCEL_BUTTON, &item); 1941 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_INPUT_CANCEL_BUTTON); 1942 * auto nodeCancelButtonStyle = item->value[0].i32; 1943 * auto nodeCancelButtonSize = item->value[1].f32; 1944 * auto nodeCancelButtonColor = item->value[2].u32; 1945 * auto nodeCancelButtonImage = item->string; 1946 * @endcode 1947 * 1948 */ 1949 NODE_TEXT_INPUT_CANCEL_BUTTON, 1950 1951 /** 1952 * @brief 通过{@link setAttribute}方法设置子组件在容器内的对齐方式。 1953 * 1954 * {@link ArkUI_AttributeItem}参数类型：\n 1955 * .value[0].i32： 对齐方式，数据类型{@link ArkUI_Alignment}，默认值ARKUI_ALIGNMENT_CENTER。 1956 * 1957 * @code {.c} 1958 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_ALIGNMENT_CENTER } }; 1959 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 1960 * basicNodeApi->setAttribute(nodeHandle, NODE_STACK_ALIGN_CONTENT, &item); 1961 * @endcode 1962 */ 1963 NODE_STACK_ALIGN_CONTENT = MAX_NODE_SCOPE_NUM * ARKUI_NODE_STACK, 1964 1965 /** 1966 * @brief 通过{@link setAttribute}方法设置滚动条状态。 1967 * 1968 * {@link ArkUI_AttributeItem}参数类型：\n 1969 * .value[0].i32： 滚动条状态，数据类型{@link 1970 * ArkUI_ScrollBarDisplayMode}，默认值ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO。 1971 * 1972 * @code {.c} 1973 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO } }; 1974 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 1975 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_BAR_DISPLAY_MODE, &item); 1976 * @endcode 1977 * 1978 */ 1979 NODE_SCROLL_BAR_DISPLAY_MODE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_SCROLL, 1980 /** 1981 * @brief 通过{@link setAttribute}方法设置滚动条的宽度。 1982 * 1983 * {@link ArkUI_AttributeItem}参数类型：\n 1984 * .value[0].f32： 滚动条宽度，单位vp，默认值4。 1985 * 1986 * @code {.c} 1987 * ArkUI_NumberValue value[] = { 20 }; 1988 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 1989 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_BAR_WIDTH, &item); 1990 * @endcode 1991 * 1992 */ 1993 NODE_SCROLL_BAR_WIDTH, 1994 /** 1995 * @brief 通过{@link setAttribute}方法设置滚动条的颜色。 1996 * 1997 * {@link ArkUI_AttributeItem}参数类型：\n 1998 * .data[0].i32： 滚动条颜色，0xargb类型。 1999 * 2000 * @code {.c} 2001 * ArkUI_NumberValue value[] = { { .i32 = 0xFFFFFFFF } }; 2002 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2003 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_BAR_COLOR, &item); 2004 * @endcode 2005 * 2006 */ 2007 NODE_SCROLL_BAR_COLOR, 2008 /** 2009 * @brief 通过{@link setAttribute}方法设置滚动方向。 2010 * 2011 * {@link ArkUI_AttributeItem}参数类型：\n 2012 * .value[0].i32：滚动方向，数据类型{@link ArkUI_Axis}，默认值ARKUI_AXIS_VERTICAL。 2013 * 2014 * @code {.c} 2015 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_AXIS_VERTICAL } }; 2016 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2017 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_SCROLL_DIRECTION, &item); 2018 * @endcode 2019 * 2020 */ 2021 NODE_SCROLL_SCROLL_DIRECTION, 2022 /** 2023 * @brief 通过{@link setAttribute}方法设置边缘滑动效果。 2024 * 2025 * {@link ArkUI_AttributeItem}参数类型：\n 2026 * .value[0].i32： 边缘滑动效果，参数类型{@link ArkUI_EdgeEffect}，默认值ARKUI_EDGE_EFFECT_NONE；\n 2027 * .value[1]?.i32： 可选值，组件内容大小小于组件自身时，设置是否开启滑动效果，开启为1，关闭为0，默认值1。 2028 * 2029 * @code {.c} 2030 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_EDGE_EFFECT_NONE }, { .i32 = 1 } }; 2031 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2032 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_EDGE_EFFECT, &item); 2033 * @endcode 2034 * 2035 */ 2036 NODE_SCROLL_EDGE_EFFECT, 2037 /** 2038 * @brief 2039 * 通过{@link 2040 * setAttribute}方法设置是否支持滚动手势，当设置为false时，无法通过手指或者鼠标滚动，但不影响控制器的滚动接口。 2041 * 2042 * {@link ArkUI_AttributeItem}参数类型：\n 2043 * .value[0].i32： 是否支持滚动手势，默认值true。 2044 * 2045 * @code {.c} 2046 * ArkUI_NumberValue value[] = { { .i32 = true } }; 2047 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2048 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item); 2049 * @endcode 2050 * 2051 */ 2052 NODE_SCROLL_ENABLE_SCROLL_INTERACTION, 2053 /** 2054 * @brief 2055 * 通过{@link 2056 * setAttribute}方法设置摩擦系数，手动划动滚动区域时生效，只对惯性滚动过程有影响，对惯性滚动过程中的链式效果有间接影响。 2057 * 2058 * {@link ArkUI_AttributeItem}参数类型：\n 2059 * .value[0].f32： 摩擦系数，默认值：非可穿戴设备为0.6，可穿戴设备为0.9。 2060 * 2061 * @code {.c} 2062 * ArkUI_NumberValue value[] = { 0.6 }; 2063 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2064 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_FRICTION, &item); 2065 * @endcode 2066 * 2067 */ 2068 NODE_SCROLL_FRICTION, 2069 /** 2070 * @brief 通过{@link setAttribute}方法设置Scroll组件的限位滚动模式。 2071 * 2072 * {@link ArkUI_AttributeItem}参数类型：\n 2073 * .value[0].i32： Scroll组件限位滚动时的对其方式，数据类型{@link ArkUI_ScrollSnapAlign}，默认值ARKUI_SCROLL_SNAP_ALIGN_NONE；\n 2074 * .value[1].i32： 在Scroll组件限位滚动模式下，该属性设置为false后，运行Scroll在开头和第一个限位点间自由滑动。默认值true，仅在限位点为多个时生效；\n 2075 * .value[2].i32： 在Scroll组件限位滚动模式下，该属性设置为false后，运行Scroll在最后一个限位点和末尾间自由滑动。默认值true，仅在限位点为多个时生效；\n 2076 * 2077 * @code {.c} 2078 * ArkUI_NumberValue value[] = { 2079 * { .i32=ARKUI_SCROLL_SNAP_ALIGN_NONE }, { .i32=true }, { .i32=true }, 2080 * { .f32=0 }, { .f32=500 }, { .f32=1000 }, { .f32=1500 } 2081 * }; 2082 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2083 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_SNAP, &item); 2084 * @endcode 2085 * 2086 */ 2087 NODE_SCROLL_SNAP, 2088 2089 /** 2090 * @brief Scroll嵌套滚动选项，支持属性设置，属性重置和属性获取。 2091 * 2092 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 2093 * .value[0]?.i32：可滚动组件往末尾端滚动时的嵌套滚动，参数类型{@link ArkUI_ScrollNestedMode}。\n 2094 * .value[1]?.i32：可滚动组件往起始端滚动时的嵌套滚动，参数类型{@link ArkUI_ScrollNestedMode}。 2095 * \n 2096 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2097 * .value[0]?.i32：可滚动组件往末尾端滚动时的嵌套滚动，参数类型{@link ArkUI_ScrollNestedMode}。\n 2098 * .value[1]?.i32：可滚动组件往起始端滚动时的嵌套滚动，参数类型{@link ArkUI_ScrollNestedMode}。 2099 * 2100 * @code {.c} 2101 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2102 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2103 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY }, 2104 * { .i32 = ARKUI_SCROLL_NESTED_OPTIONS_SELF_ONLY } }; 2105 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 2106 * nativeNodeApi->setAttribute(nodeHandle, NODE_SCROLL_NESTED_SCROLL, &item); 2107 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SCROLL_NESTED_SCROLL); 2108 * auto first = item->value[0].i32; 2109 * auto second = item->value[1].i32; 2110 * @endcode 2111 * 2112 */ 2113 NODE_SCROLL_NESTED_SCROLL, 2114 /** 2115 * @brief Scroll滑动到指定位置，支持属性设置，属性重置和属性获取。 2116 * 2117 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 2118 * .value[0].f32：水平滑动偏移，单位为vp。\n 2119 * .value[1].f32：垂直滑动偏移，单位为vp。\n 2120 * .value[2]?.i32：可选值，滚动时长，单位为毫秒。\n 2121 * .value[3]?.i32：可选值，滚动曲线，参数类型{@link ArkUI_AnimationCurve}。默认值为ARKUI_CURVE_EASE。\n 2122 * .value[4]?.i32：可选值，是否使能默认弹簧动效，默认值为0不使能。 2123 * \n 2124 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2125 * .value[0].f32：水平滑动偏移，单位为vp。\n 2126 * .value[1].f32：垂直滑动偏移，单位为vp。\n 2127 * 2128 * @code {.c} 2129 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2130 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2131 * ArkUI_NumberValue value[] = { 10, 100, { .i32 = 1000 }, { .i32 = ARKUI_CURVE_EASE }, 2132 * { .i32 = 1 } }; 2133 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 2134 * nativeNodeApi->setAttribute(nodeHandle, NODE_SCROLL_OFFSET, &item); 2135 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SCROLL_OFFSET); 2136 * auto x = item->value[0].f32; 2137 * auto y = item->value[1].f32; 2138 * @endcode 2139 * 2140 */ 2141 NODE_SCROLL_OFFSET, 2142 2143 /** 2144 * @brief Scroll滚动到容器边缘，支持属性设置，属性重置和属性获取。 2145 * 2146 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 2147 * .value[0].i32：容器边缘，参数类型{@link ArkUI_ScrollEdge}。 2148 * \n 2149 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2150 * .value[0].i32：容器边缘，参数类型{@link ArkUI_ScrollEdge}。 2151 * 2152 * @code {.c} 2153 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2154 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2155 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_SCROLL_EDGE_TOP } }; 2156 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 2157 * nativeNodeApi->setAttribute(nodeHandle, NODE_SCROLL_EDGE, &item); 2158 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SCROLL_EDGE); 2159 * auto value = item->value[0].i32; 2160 * @endcode 2161 * 2162 */ 2163 NODE_SCROLL_EDGE, 2164 2165 /** 2166 * @brief 通过{@link setAttribute}方法设置是否支持滑动翻页。 2167 * @note 如果同时设置了划动翻页 enablePaging 和限位滚动 scrollSnap，则 scrollSnap 优先生效，enablePaging 不生效。 2168 * 2169 * {@link ArkUI_AttributeItem}参数类型：\n 2170 * .value[0].i32： 是否支持划动翻页，默认值false。 2171 * 2172 * @code {.c} 2173 * ArkUI_NumberValue value[] = { { .i32 = true } }; 2174 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2175 * basicNodeApi->setAttribute(nodeHandle, NODE_SCROLL_ENABLE_PAGING, &item); 2176 * @endcode 2177 * 2178 */ 2179 NODE_SCROLL_ENABLE_PAGING, 2180 2181 /** 2182 * @brief 通过{@link setAttribute}方法设置List组件排列方向。 2183 * 2184 * {@link ArkUI_AttributeItem}参数类型：\n 2185 * .value[0].i32：List组件排列方向，数据类型{@link ArkUI_Axis}，默认值ARKUI_AXIS_VERTICAL。 2186 * 2187 * @code {.c} 2188 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_AXIS_VERTICAL } }; 2189 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2190 * basicNodeApi->setAttribute(nodeHandle, NODE_LIST_LIST_DIRECTION, &item); 2191 * @endcode 2192 * 2193 */ 2194 NODE_LIST_LIST_DIRECTION = MAX_NODE_SCOPE_NUM * ARKUI_NODE_LIST, 2195 /** 2196 * @brief 通过{@link setAttribute}方法配合ListItemGroup组件使用，设置 ListItemGroup 中 header 和 footer 是否要吸顶或吸底。 2197 * 2198 * {@link ArkUI_AttributeItem}参数类型：\n 2199 * .value[0].i32：配合ListItemGroup组件使用，设置ListItemGroup中header和footer是否要吸顶或吸底。数据类型{@link ArkUI_StickyStyle}，默认值 2200 * ARKUI_STICKYSTYLE_NONE。 2201 * 2202 * @code {.c} 2203 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_STICKYSTYLE_NONE } }; 2204 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2205 * basicNodeApi->setAttribute(nodeHandle, NODE_LIST_STICKY, &item); 2206 * @endcode 2207 * 2208 */ 2209 NODE_LIST_STICKY, 2210 /** 2211 * @brief 通过{@link setAttribute}方法设置列表项间距。 2212 * 2213 * {@link ArkUI_AttributeItem}参数类型：\n 2214 * .value[0].f32： 子组件主轴方向的间隔。默认值0。 2215 * 2216 * @code {.c} 2217 * ArkUI_NumberValue value[] = { 10 }; 2218 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2219 * basicNodeApi->setAttribute(nodeHandle, NODE_LIST_SPACE, &item); 2220 * @endcode 2221 * 2222 */ 2223 NODE_LIST_SPACE, 2224 2225 /** 2226 * @brief Swiper是否开启循环，支持属性设置，属性重置和属性获取接口。 2227 * 2228 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2229 * .value[0].i32：控制是否开启循环，0表示不循环，1表示循环，默认值为1。 \n 2230 * \n 2231 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2232 * .value[0].i32：控制是否开启循环，0表示不循环，1表示循环，默认值为1。 \n 2233 * 2234 * @code {.cpp} 2235 * ArkUI_NumberValue value[] = { {.i32 = 0} }; 2236 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2237 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_LOOP, &item); 2238 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_LOOP); 2239 * auto nodeSwiperLoop = item->value[0].i32; 2240 * @endcode 2241 * 2242 */ 2243 NODE_SWIPER_LOOP = MAX_NODE_SCOPE_NUM * ARKUI_NODE_SWIPER, 2244 /** 2245 * @brief Swiper子组件是否自动播放，支持属性设置，属性重置和属性获取接口。 2246 * 2247 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2248 * .value[0].i32：控制子组件是否自动播放，0表示不自动播放，1表示自动播放，默认值为0。 \n 2249 * \n 2250 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2251 * .value[0].i32：控制子组件是否自动播放，0表示不自动播放，1表示自动播放，默认值为0。 \n 2252 * 2253 * @code {.cpp} 2254 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2255 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2256 * ArkUI_NumberValue value[] = { {.i32 = 1} }; 2257 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2258 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_AUTO_PLAY, &item); 2259 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_AUTO_PLAY); 2260 * auto nodeSwiperLoop = item->value[0].i32; 2261 * @endcode 2262 * 2263 */ 2264 NODE_SWIPER_AUTO_PLAY, 2265 /** 2266 * @brief Swiper是否显示导航点指示器，支持属性设置，属性重置和属性获取接口。 2267 * 2268 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2269 * .value[0].i32：是否显示导航点指示器，0表示不显示导航点指示器，1表示显示导航点指示器，默认值为1。 \n 2270 * \n 2271 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2272 * .value[0].i32：是否显示导航点指示器，0表示不显示导航点指示器，1表示显示导航点指示器，默认值为1。 \n 2273 * 2274 * @code {.cpp} 2275 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2276 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2277 * ArkUI_NumberValue value[] = { {.i32 = 0} }; 2278 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2279 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_SHOW_INDICATOR, &item); 2280 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_SHOW_INDICATOR); 2281 * auto nodeSwiperShowIndicator = item->value[0].i32; 2282 * @endcode 2283 * 2284 */ 2285 NODE_SWIPER_SHOW_INDICATOR, 2286 /** 2287 * @brief 设置Swiper自动播放时播放的时间间隔，支持属性设置，属性重置和属性获取接口。 2288 * 2289 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2290 * .value[0].f32：使用自动播放时播放的时间间隔，单位为毫秒。 \n 2291 * \n 2292 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2293 * .value[0].f32：使用自动播放时播放的时间间隔，单位为毫秒。 \n 2294 * 2295 * @code {.cpp} 2296 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2297 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2298 * ArkUI_NumberValue value[] = { 3000 }; 2299 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2300 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_INTERVAL, &item); 2301 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_INTERVAL); 2302 * auto nodeSwiperInterval = item->value[0].f32; 2303 * @endcode 2304 * 2305 */ 2306 NODE_SWIPER_INTERVAL, 2307 /** 2308 * @brief 设置Swiper是否为纵向滑动，支持属性设置，属性重置和属性获取接口。 2309 * 2310 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2311 * .value[0].i32：是否为纵向滑动，0表示横向滑动，1表示纵向滑动，默认值为0。 \n 2312 * \n 2313 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2314 * .value[0].i32：是否为纵向滑动，0表示横向滑动，1表示纵向滑动，默认值为0。 \n 2315 * 2316 * @code {.cpp} 2317 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2318 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2319 * ArkUI_NumberValue value[] = { {.i32 = 1} }; 2320 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2321 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_VERTICAL, &item); 2322 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_VERTICAL); 2323 * auto nodeSwiperVertical = item->value[0].i32; 2324 * @endcode 2325 * 2326 */ 2327 NODE_SWIPER_VERTICAL, 2328 2329 /** 2330 * @brief 设置Swiper子组件切换的动画时长，支持属性设置，属性重置和属性获取接口。 2331 * 2332 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2333 * .value[0].f32：子组件切换的动画时长，单位为毫秒, 默认值为400。 \n 2334 * \n 2335 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2336 * .value[0].f32：子组件切换的动画时长，单位为毫秒, 默认值为400。 \n 2337 * 2338 * @code {.cpp} 2339 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2340 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2341 * ArkUI_NumberValue value[] = { 1000 }; 2342 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2343 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_DURATION, &item); 2344 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_DURATION); 2345 * auto nodeSwiperVertical = item->value[0].f32; 2346 * @endcode 2347 * 2348 */ 2349 NODE_SWIPER_DURATION, 2350 2351 /** 2352 * @brief 设置Swiper的动画曲线，支持属性设置，属性重置和属性获取接口。 2353 * 2354 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2355 * .value[0].i32：设置动画曲线参数，参数类型{@link ArkUI_AnimationCurve}，默认值为ARKUI_CURVE_LINEAR。 \n 2356 * \n 2357 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2358 * .value[0].i32：设置动画曲线参数，参数类型{@link ArkUI_AnimationCurve}，默认值为ARKUI_CURVE_LINEAR。 \n 2359 * 2360 * @code {.cpp} 2361 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2362 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2363 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_CURVE_SHARP} }; 2364 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2365 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_CURVE, &item); 2366 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_CURVE); 2367 * auto nodeSwiperVertical = item->value[0].i32; 2368 * @endcode 2369 * 2370 */ 2371 NODE_SWIPER_CURVE, 2372 2373 /** 2374 * @brief 设置Swiper子组件与子组件之间间隙，支持属性设置，属性重置和属性获取接口。 2375 * 2376 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2377 * .value[0].f32：子组件与子组件之间间隙数值。 \n 2378 * \n 2379 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2380 * .value[0].f32：子组件与子组件之间间隙数值。 \n 2381 * 2382 * @code {.cpp} 2383 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2384 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2385 * ArkUI_NumberValue value[] = { 10 }; 2386 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2387 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_ITEM_SPACE, &item); 2388 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_ITEM_SPACE); 2389 * auto nodeSwiperVertical = item->value[0].f32; 2390 * @endcode 2391 * 2392 */ 2393 NODE_SWIPER_ITEM_SPACE, 2394 2395 /** 2396 * @brief 设置Swiper当前在容器中显示的子组件的索引值，支持属性设置，属性重置和属性获取接口。 2397 * 2398 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2399 * .value[0].i32：子组件的索引值。 \n 2400 * \n 2401 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2402 * .value[0].i32：子组件的索引值。 \n 2403 * 2404 * @code {.cpp} 2405 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2406 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2407 * ArkUI_NumberValue value[] = { {i32 = 3} }; 2408 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2409 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_INDEX, &item); 2410 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_ITEM_SPACE); 2411 * auto nodeSwiperIndex = item->value[0].i32; 2412 * @endcode 2413 * 2414 */ 2415 NODE_SWIPER_INDEX, 2416 2417 /** 2418 * @brief 设置Swiper一页内元素显示个数，支持属性设置，属性重置和属性获取接口。 2419 * 2420 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2421 * .value[0].i32：子组件的索引值。 \n 2422 * \n 2423 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2424 * .value[0].i32：子组件的索引值。 \n 2425 * 2426 * @code {.cpp} 2427 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2428 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2429 * ArkUI_NumberValue value[] = { {i32 = 3} }; 2430 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2431 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_DISPLAY_COUNT, &item); 2432 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_ITEM_SPACE); 2433 * auto nodeSwiperDisplayCount = item->value[0].i32; 2434 * @endcode 2435 * 2436 */ 2437 NODE_SWIPER_DISPLAY_COUNT, 2438 2439 /** 2440 * @brief 设置Swiper禁用组件滑动切换功能，支持属性设置，属性重置和属性获取接口。 2441 * 2442 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2443 * .value[0].i32：是否禁用组件滑动切换功能，0表示不禁用滑动切换功能，1表示禁用滑动切换功能，默认值为0。 \n 2444 * \n 2445 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2446 * .value[0].i32：是否禁用组件滑动切换功能，0表示不禁用滑动切换功能，1表示禁用滑动切换功能，默认值为0。 \n 2447 * 2448 * @code {.cpp} 2449 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2450 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2451 * ArkUI_NumberValue value[] = { {.i32 = 1} }; 2452 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2453 * basicNodeApi->setAttribute(nodeHandle, NODE_SWIPER_DISABLE_SWIPE, &item); 2454 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_DISABLE_SWIPE); 2455 * auto nodeSwiperDisplayCount = item->value[0].i32; 2456 * @endcode 2457 * 2458 */ 2459 NODE_SWIPER_DISABLE_SWIPE, 2460 2461 /** 2462 * @brief 设置Swiper是否显示导航点箭头，支持属性设置，属性重置和属性获取接口。 2463 * 2464 * 属性设置方法参数{@link ArkUI_AttributeItem}格式： \n 2465 * .value[0].i32：设置是否显示导航点箭头，参数类型{@link ArkUI_SwiperDisplayArrow}， \n 2466 * 默认值为ARKUI_SWIPER_ARROW_FALSE。 \n 2467 * \n 2468 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 2469 * .value[0].i32：设置是否显示导航点箭头，参数类型{@link ArkUI_SwiperDisplayArrow}， \n 2470 * 默认值为ARKUI_SWIPER_ARROW_FALSE。 \n 2471 * 2472 * @code {.cpp} 2473 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 2474 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2475 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_SWIPER_ARROW_SHOW_ON_HOVER} }; 2476 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2477 * nativeNodeApi->setAttribute(nodeHandle, NODE_SWIPER_SHOW_DISPLAY_ARROW, &item); 2478 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SWIPER_SHOW_DISPLAY_ARROW); 2479 * auto nodeSwiperDisplayCount = item->value[0].i32; 2480 * @endcode 2481 * 2482 */ 2483 NODE_SWIPER_SHOW_DISPLAY_ARROW, 2484 2485 /** 2486 * @brief 多行文本输入框的默认提示文本内容属性，支持属性设置，属性重置和属性获取接口。 2487 * 2488 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2489 * .string：默认提示文本的内容；\n 2490 * \n 2491 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2492 * .string：默认提示文本的内容。\n 2493 * 2494 * @code {.cpp} 2495 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2496 * ArkUI_AttributeItem item = { .string="input" }; 2497 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_AREA_PLACEHOLDER, &item); 2498 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_AREA_PLACEHOLDER); 2499 * auto nodeTextAreaPlaceholder = item->string; 2500 * @endcode 2501 * 2502 */ 2503 NODE_TEXT_AREA_PLACEHOLDER = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TEXT_AREA, 2504 /** 2505 * @brief 多行文本输入框的默认文本内容属性，支持属性设置，属性重置和属性获取接口。 2506 * 2507 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2508 * .string：默认文本的内容；\n 2509 * \n 2510 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2511 * .string：默认文本的内容。\n 2512 * 2513 * @code {.cpp} 2514 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2515 * ArkUI_AttributeItem item = { .string="input" }; 2516 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_AREA_TEXT, &item); 2517 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_AREA_TEXT); 2518 * auto nodeTextAreaText = item->string; 2519 * @endcode 2520 * 2521 */ 2522 NODE_TEXT_AREA_TEXT, 2523 /** 2524 * @brief 输入框支持的最大文本数属性，支持属性设置，属性重置和属性获取接口。 2525 * 2526 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2527 * .value[0].i32：最大文本数的数字，无单位；\n 2528 * \n 2529 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2530 * .value[0].i32：最大文本数的数字。\n 2531 * 2532 * @code {.cpp} 2533 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2534 * ArkUI_NumberValue value[] = { { .i32 = 50 } }; 2535 * ArkUI_AttributeItem item = { value, 1 }; 2536 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_AREA_MAX_LENGTH, &item); 2537 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_AREA_MAX_LENGTH); 2538 * auto nodeTextAreaMaxlength = item->value[0].i32; 2539 * @endcode 2540 * 2541 */ 2542 NODE_TEXT_AREA_MAX_LENGTH, 2543 /** 2544 * @brief 无输入时默认提示文本的颜色属性，支持属性设置，属性重置和属性获取接口。 2545 * 2546 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2547 * .value[0].u32：颜色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 2548 * \n 2549 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2550 * .value[0].u32：颜色数值，0xargb格式。\n 2551 * 2552 * @code {.cpp} 2553 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2554 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 2555 * ArkUI_AttributeItem item = { value, 1 }; 2556 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_AREA_PLACEHOLDER_COLOR, &item); 2557 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_AREA_PLACEHOLDER_COLOR); 2558 * auto nodeTextAreaPlaceholderColor = item->value[0].u32; 2559 * @endcode 2560 * 2561 */ 2562 NODE_TEXT_AREA_PLACEHOLDER_COLOR, 2563 /** 2564 * @brief 无输入时默认提示文本的字体配置（包括大小、字重、样式、字体列表）属性，支持属性设置，属性重置和属性获取接口。 2565 * 2566 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2567 * .value[0]?.f32：可选字体大小数值，默认值16.0，单位为fp；\n 2568 * .value[1]?.i32：可选字体样式{@link ArkUI_FontStyle}，默认值为ARKUI_FONT_STYLE_NORMAL；\n 2569 * .value[2]?.i32：可选字体粗细样式{@link ArkUI_FontWeight}，默认值为ARKUI_FONT_WEIGHT_NORMAL；\n 2570 * ?.string: 字体族内容，多个字体族之间使用逗号分隔，形如“字重；字体族1，字体族2”；\n 2571 * \n 2572 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2573 * .value[0].f32：字体大小数值，单位为fp；\n 2574 * .value[1].i32：字体样式{@link ArkUI_FontStyle}；\n 2575 * .value[2].i32：字体粗细样式{@link ArkUI_FontWeight}；\n 2576 * .string: 字体族内容，多个字体族之间使用逗号分隔。\n 2577 * 2578 * @code {.cpp} 2579 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2580 * ArkUI_NumberValue value[] = { 16.0, {.i32=ARKUI_FONT_STYLE_NORMAL}, {.i32=ARKUI_FONT_WEIGHT_NORMAL} }; 2581 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue), "Arial" }; 2582 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item); 2583 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_AREA_PLACEHOLDER_FONT); 2584 * auto nodeTextAreaPlaceholderFontSize = item->value[0].f32; 2585 * auto nodeTextAreaPlaceholderFontStyle = item->value[1].i32; 2586 * auto nodeTextAreaPlaceholderFontWeight = item->value[2].i32; 2587 * auto nodeTextAreaPlaceholderFontFamily = item->string; 2588 * @endcode 2589 * 2590 */ 2591 NODE_TEXT_AREA_PLACEHOLDER_FONT, 2592 /** 2593 * @brief 光标颜色属性，支持属性设置，属性重置和属性获取接口。 2594 * 2595 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2596 * .value[0].u32：背景色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 2597 * \n 2598 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2599 * .value[0].u32：背景色数值，0xargb格式。\n 2600 * 2601 * @code {.cpp} 2602 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2603 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 2604 * ArkUI_AttributeItem item = { value, 1 }; 2605 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_AREA_CARET_COLOR, &item); 2606 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_AREA_CARET_COLOR); 2607 * auto nodeTextAreaCaretColor = item->value[0].u32; 2608 * @endcode 2609 * 2610 */ 2611 NODE_TEXT_AREA_CARET_COLOR, 2612 /** 2613 * @brief 控制多行文本输入框编辑态属性，支持属性设置。 2614 * 2615 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2616 * .value[0].i32：false表示退出编辑态，true表示维持现状。 2617 * 2618 * @code {.cpp} 2619 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2620 * ArkUI_NumberValue value[] = { {.i32 = false} }; 2621 * ArkUI_AttributeItem item = { value, 1 }; 2622 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_AREA_EDITING, &item); 2623 * @endcode 2624 * 2625 */ 2626 NODE_TEXT_AREA_EDITING, 2627 2628 /** 2629 * @brief button按钮的文本内容属性，支持属性设置，属性重置和属性获取接口。 2630 * 2631 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2632 * .string：默认文本的内容；\n 2633 * \n 2634 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2635 * .string：默认文本的内容。\n 2636 * 2637 * @code {.cpp} 2638 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2639 * ArkUI_AttributeItem item = { .string="click" }; 2640 * nativeNodeApi->setAttribute(nodeHandle, NODE_BUTTON_LABEL, &item); 2641 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_BUTTON_LABEL); 2642 * auto nodeButtonLabelr = item->string; 2643 * @endcode 2644 * 2645 */ 2646 NODE_BUTTON_LABEL = MAX_NODE_SCOPE_NUM * ARKUI_NODE_BUTTON, 2647 2648 /** 2649 * @brief 进度条的当前进度值属性，支持属性设置，属性重置和属性获取接口。 2650 * 2651 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2652 * .value[0].f32：进度条当前值；\n 2653 * \n 2654 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2655 * .value[0].f32：进度条当前值。\n 2656 * 2657 * @code {.cpp} 2658 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2659 * ArkUI_NumberValue value[] = { 10 }; 2660 * ArkUI_AttributeItem item = { value, 1 }; 2661 * nativeNodeApi->setAttribute(nodeHandle, NODE_PROGRESS_VALUE, &item); 2662 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_PROGRESS_VALUE); 2663 * auto nodeProgressValue = item->value[0].f32; 2664 * @endcode 2665 * 2666 */ 2667 NODE_PROGRESS_VALUE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_PROGRESS, 2668 /** 2669 * @brief 进度条的总长属性，支持属性设置，属性重置和属性获取接口。 2670 * 2671 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2672 * .value[0].f32：进度条总长；\n 2673 * \n 2674 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2675 * .value[0].f32：进度条总长。\n 2676 * 2677 * @code {.cpp} 2678 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2679 * ArkUI_NumberValue value[] = { 100 }; 2680 * ArkUI_AttributeItem item = { value, 1 }; 2681 * nativeNodeApi->setAttribute(nodeHandle, NODE_PROGRESS_TOTAL, &item); 2682 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_PROGRESS_TOTAL); 2683 * auto nodeProgressTotal = item->value[0].f32; 2684 * @endcode 2685 * 2686 */ 2687 NODE_PROGRESS_TOTAL, 2688 /** 2689 * @brief 进度条显示进度值的颜色属性，支持属性设置，属性重置和属性获取接口。 2690 * 2691 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2692 * .value[0].u32：颜色数值，0xargb格式，形如 0xFFFF0000 表示红色；\n 2693 * \n 2694 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2695 * .value[0].u32：颜色数值，0xargb格式。\n 2696 * 2697 * @code {.cpp} 2698 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2699 * ArkUI_NumberValue value[] = { {.u32=0xFFFF0000} }; 2700 * ArkUI_AttributeItem item = { value, 1 }; 2701 * nativeNodeApi->setAttribute(nodeHandle, NODE_PROGRESS_COLOR, &item); 2702 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_PROGRESS_COLOR); 2703 * auto nodeProgressColor = item->value[0].u32; 2704 * @endcode 2705 * 2706 */ 2707 NODE_PROGRESS_COLOR, 2708 /** 2709 * @brief 进度条的类型属性，支持属性设置，属性重置和属性获取接口。 2710 * 2711 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2712 * .value[0].i32：进度条类型枚举值{@link ArkUI_ProgressType}，默认值为ARKUI_PROGRESS_LINEAR；\n 2713 * \n 2714 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2715 * .value[0].i32：进度条类型枚举值{@link ArkUI_ProgressType}。\n 2716 * 2717 * @code {.c} 2718 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2719 * ArkUI_NumberValue value[] = { {.i32=ARKUI_PROGRESS_LINEAR} }; 2720 * ArkUI_AttributeItem item = { value, 1 }; 2721 * nativeNodeApi->setAttribute(nodeHandle, NODE_PROGRESS_TYPE, &item); 2722 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_PROGRESS_TYPE); 2723 * auto nodeProgressType = item->value[0].i32; 2724 * @endcode 2725 */ 2726 NODE_PROGRESS_TYPE, 2727 2728 /** 2729 * @brief XComponent组件ID属性，支持属性设置和属性获取接口。 2730 * 2731 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2732 * .string: ID的内容；\n 2733 * \n 2734 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2735 * .string: ID的内容。\n 2736 * 2737 * @code {.cpp} 2738 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2739 * ArkUI_AttributeItem item = { .string = "test" }; 2740 * basicNodeApi->setAttribute(nodeHandle, NODE_XCOMPONENT_ID, &item); 2741 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_XCOMPONENT_ID); 2742 * auto nodeXcomponentId = item->string; 2743 * @endcode 2744 * 2745 */ 2746 NODE_XCOMPONENT_ID = MAX_NODE_SCOPE_NUM * ARKUI_NODE_XCOMPONENT, 2747 /** 2748 * @brief XComponent的类型，支持属性设置，属性重置和属性获取接口。 2749 * 2750 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2751 * .value[0].i32：字体样式{@link ArkUI_XComponentType}，默认值为ARKUI_XCOMPONENT_TYPE_SURFACE；\n 2752 * \n 2753 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2754 * .value[0].i32：字体样式{@link ArkUI_XComponentType}。\n 2755 * 2756 * @code {.cpp} 2757 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2758 * ArkUI_NumberValue value[] = { {.i32 = ARKUI_XCOMPONENT_TYPE_SURFACE} }; 2759 * ArkUI_AttributeItem item = { value, 1 }; 2760 * nativeNodeApi->setAttribute(nodeHandle, NODE_XCOMPONENT_TYPE, &item); 2761 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_XCOMPONENT_TYPE); 2762 * auto nodeXcomponentType = item->value[0].i32; 2763 * @endcode 2764 * 2765 */ 2766 NODE_XCOMPONENT_TYPE, 2767 /** 2768 * @brief 设置XComponent的宽高，支持属性设置和获取接口。 2769 * 2770 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 2771 * .value[0].f32：宽数值，单位为vp；\n 2772 * .value[1].f32：高数值，单位为vp；\n 2773 * \n 2774 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 2775 * .value[0].f32：宽数值，单位为vp；\n 2776 * .value[1].f32：高数值，单位为vp；\n 2777 * 2778 * @code {.cpp} 2779 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 2780 * ArkUI_NumberValue value[] = { 300, 50 }; 2781 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 2782 * nativeNodeApi->setAttribute(nodeHandle, NODE_XCOMPONENT_SURFACE_SIZE, &item); 2783 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_XCOMPONENT_SURFACE_SIZE); 2784 * auto nodeXcomponentSurfaceWidth = item->value[0].f32; 2785 * auto nodeXcomponentSurfaceHeight = item->value[1].f32; 2786 * @endcode 2787 * 2788 */ 2789 NODE_XCOMPONENT_SURFACE_SIZE, 2790 2791 /** 2792 * @brief 通过{@link setAttribute}方法设置 ListItemGroup 头部组件。 2793 * 2794 * {@link ArkUI_AttributeItem}参数类型：\n 2795 * .object：使用{@link ArkUI_NodeHandle}对象作为ListItemGroup头部组件。 2796 * 2797 * @code {.c} 2798 * auto header = nodeAPI->createNode(ARKUI_NODE_TEXT); 2799 * ARKUI_AttributeItem item = { .object = header }; 2800 * basicNodeApi->setAttribute(nodeHandle, NODE_LIST_ITEM_GROUP_SET_HEADER, &item); 2801 * @endcode 2802 */ 2803 NODE_LIST_ITEM_GROUP_SET_HEADER = MAX_NODE_SCOPE_NUM * ARKUI_NODE_LIST_ITEM_GROUP, 2804 /** 2805 * @brief 通过{@link setAttribute}方法设置 ListItemGroup 尾部组件。 2806 * 2807 * {@link ArkUI_AttributeItem}参数类型：\n 2808 * .object：使用{@link ArkUI_NodeHandle}对象作为ListItemGroup尾部组件。 2809 * 2810 * @code {.c} 2811 * auto footer = nodeAPI->createNode(ARKUI_NODE_TEXT); 2812 * ARKUI_AttributeItem item = { .object = footer }; 2813 * basicNodeApi->setAttribute(nodeHandle, NODE_LIST_ITEM_GROUP_SET_FOOTER, &item); 2814 * @endcode 2815 */ 2816 NODE_LIST_ITEM_GROUP_SET_FOOTER, 2817 /** 2818 * @brief 通过{@link setAttribute}方法设置ListItem分割线样式，默认无分割线。 2819 * 2820 * {@link ArkUI_AttributeItem}参数类型：\n 2821 * .value[0].i32： 颜色，0xargb类型；\n 2822 * .value[0].f32： 分割线宽，单位vp；\n 2823 * .value[1].f32： 分割线距离列表侧边起始端的距离，单位vp；\n 2824 * .value[2].f32： 分割线距离列表侧边结束端的距离，单位vp。 2825 * 2826 * @code {.c} 2827 * ArkUI_NumberValue value[] = { { .i32 = 0xFFFFFFFF }, 1, 0, 0 }; 2828 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2829 * basicNodeApi->setAttribute(nodeHandle, NODE_XCOMPONENT_SURFACE_SIZE, &item); 2830 * @endcode 2831 */ 2832 NODE_LIST_ITEM_GROUP_SET_DIVIDER, 2833 /** 2834 * @brief 通过{@link setAttribute}方法设置日期选择器组件的日期是否显示农历。 2835 * 2836 * {@link ArkUI_AttributeItem}参数类型：\n 2837 * .value[0].i32： 是否显示农历，默认值false。 2838 * 2839 * @code {.c} 2840 * ArkUI_NumberValue value[] = { { .i32 = true } }; 2841 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2842 * basicNodeApi->setAttribute(nodeHandle, NODE_DATE_PICKER_LUNAR, &item); 2843 * @endcode 2844 */ 2845 NODE_DATE_PICKER_LUNAR = MAX_NODE_SCOPE_NUM * ARKUI_NODE_DATE_PICKER, 2846 /** 2847 * @brief 通过{@link setAttribute}方法设置日期选择器组件选择器的起始日期。 2848 * 2849 * {@link ArkUI_AttributeItem}参数类型：\n 2850 * .string： 日期，默认值"1970-1-1"。 2851 * 2852 * @code {.c} 2853 * ARKUI_AttributeItem item = { .string = "1970-1-1" }; 2854 * basicNodeApi->setAttribute(nodeHandle, NODE_DATE_PICKER_START, &item); 2855 * @endcode 2856 */ 2857 NODE_DATE_PICKER_START, 2858 /** 2859 * @brief 通过{@link setAttribute}方法设置日期选择器组件选择器的结束日期。 2860 * 2861 * {@link ArkUI_AttributeItem}参数类型：\n 2862 * .string： 日期，默认值"2100-12-31"。 2863 * 2864 * @code {.c} 2865 * ARKUI_AttributeItem item = { .string = "2100-12-31" }; 2866 * basicNodeApi->setAttribute(nodeHandle, NODE_DATE_PICKER_END, &item); 2867 * @endcode 2868 */ 2869 NODE_DATE_PICKER_END, 2870 /** 2871 * @brief 通过{@link setAttribute}方法设置日期选择器组件选中项的日期。 2872 * 2873 * {@link ArkUI_AttributeItem}参数类型：\n 2874 * .string： 日期，默认值"2024-01-22"。 2875 * 2876 * @code {.c} 2877 * ARKUI_AttributeItem item = { .string = "2024-01-22" }; 2878 * basicNodeApi->setAttribute(nodeHandle, NODE_DATE_PICKER_SELECTED, &item); 2879 * @endcode 2880 */ 2881 NODE_DATE_PICKER_SELECTED, 2882 /** 2883 * @brief 通过{@link setAttribute}方法设置日期选择器组件的所有选项中最上和最下两个选项的文本颜色、字号、字体粗细。 2884 * 2885 * {@link ArkUI_AttributeItem}参数类型：\n 2886 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 2887 * 入参1： 文本颜色，#argb类型\n 2888 * 入参2： 文本大小，数字类型，单位fp\n 2889 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 2890 * 入参4： 文本字体列表，使用 ',' 进行分割\n 2891 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 2892 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 2893 * @code {.c} 2894 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 2895 * basicNodeApi->setAttribute(nodeHandle, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item); 2896 * @endcode 2897 */ 2898 NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, 2899 /** 2900 * @brief 通过{@link 2901 * setAttribute}方法设置日期选择器组件的所有选项中除了最上、最下及选中项以外的文本颜色、字号、字体粗细。 2902 * 2903 * {@link ArkUI_AttributeItem}参数类型：\n 2904 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 2905 * 入参1： 文本颜色，#argb类型\n 2906 * 入参2： 文本大小，数字类型，单位fp\n 2907 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 2908 * 入参4： 文本字体列表，使用 ',' 进行分割\n 2909 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 2910 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 2911 * @code {.c} 2912 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 2913 * basicNodeApi->setAttribute(nodeHandle, NODE_DATE_PICKER_TEXT_STYLE, &item); 2914 * @endcode 2915 */ 2916 NODE_DATE_PICKER_TEXT_STYLE, 2917 /** 2918 * @brief 通过{@link setAttribute}方法设置日期选择器组件的选中项的文本颜色、字号、字体粗细。 2919 * 2920 * {@link ArkUI_AttributeItem}参数类型：\n 2921 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 2922 * 入参1： 文本颜色，#argb类型\n 2923 * 入参2： 文本大小，数字类型，单位fp\n 2924 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 2925 * 入参4： 文本字体列表，使用 ',' 进行分割\n 2926 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 2927 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 2928 * @code {.c} 2929 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 2930 * basicNodeApi->setAttribute(nodeHandle, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item); 2931 * @endcode 2932 */ 2933 NODE_DATE_PICKER_SELECTED_TEXT_STYLE, 2934 /** 2935 * @brief 通过{@link setAttribute}方法设置时间选择组件选中项的时间。 2936 * 2937 * {@link ArkUI_AttributeItem}参数类型：\n 2938 * .string： 时间，默认值当前系统时间。 2939 * 2940 * @code {.c} 2941 * ARKUI_AttributeItem item = { .string = "17-11" }; 2942 * basicNodeApi->setAttribute(nodeHandle, NODE_TIME_PICKER_SELECTED, &item); 2943 * @endcode 2944 */ 2945 2946 NODE_TIME_PICKER_SELECTED = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TIME_PICKER, 2947 /** 2948 * @brief 通过{@link setAttribute}方法设置时间选择组件展示时间是否为24小时制。 2949 * 2950 * {@link ArkUI_AttributeItem}参数类型：\n 2951 * .value[0].i32： 是否为24小时制，默认值false。 2952 * 2953 * @code {.c} 2954 * ArkUI_NumberValue value[] = { { .i32 = true } }; 2955 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 2956 * basicNodeApi->setAttribute(nodeHandle, NODE_TIME_PICKER_USE_MILITARY_TIME, &item); 2957 * @endcode 2958 */ 2959 NODE_TIME_PICKER_USE_MILITARY_TIME, 2960 /** 2961 * @brief 通过{@link setAttribute}方法设置时间选择组件所有选项中最上和最下两个选项的文本颜色、字号、字体粗细。 2962 * 2963 * {@link ArkUI_AttributeItem}参数类型：\n 2964 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 2965 * 入参1： 文本颜色，#argb类型\n 2966 * 入参2： 文本大小，数字类型，单位fp\n 2967 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 2968 * 入参4： 文本字体列表，使用 ',' 进行分割\n 2969 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 2970 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 2971 * @code {.c} 2972 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 2973 * basicNodeApi->setAttribute(nodeHandle, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item); 2974 * @endcode 2975 */ 2976 NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, 2977 /** 2978 * @brief 通过{@link 2979 * setAttribute}方法设置时间选择组件所有选项中除了最上、最下及选中项以外的文本颜色、字号、字体粗细。 2980 * 2981 * {@link ArkUI_AttributeItem}参数类型：\n 2982 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 2983 * 入参1： 文本颜色，#argb类型\n 2984 * 入参2： 文本大小，数字类型，单位fp\n 2985 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 2986 * 入参4： 文本字体列表，使用 ',' 进行分割\n 2987 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 2988 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 2989 * @code {.c} 2990 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 2991 * basicNodeApi->setAttribute(nodeHandle, NODE_TIME_PICKER_TEXT_STYLE, &item); 2992 * @endcode 2993 */ 2994 NODE_TIME_PICKER_TEXT_STYLE, 2995 /** 2996 * @brief 通过{@link setAttribute}方法设置时间选择组件选中项的文本颜色、字号、字体粗细。 2997 * 2998 * {@link ArkUI_AttributeItem}参数类型：\n 2999 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 3000 * 入参1： 文本颜色，#argb类型\n 3001 * 入参2： 文本大小，数字类型，单位fp\n 3002 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 3003 * 入参4： 文本字体列表，使用 ',' 进行分割\n 3004 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 3005 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 3006 * @code {.c} 3007 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 3008 * basicNodeApi->setAttribute(nodeHandle, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item); 3009 * @endcode 3010 */ 3011 NODE_TIME_PICKER_SELECTED_TEXT_STYLE, 3012 3013 /** 3014 * @brief 滑动选择文本选择器的选择列表, 支持属性设置和属性获取接口。 3015 * 3016 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 3017 * .value[0].i32：使用的选择器类型{@link ArkUI_TextPickerRangeType}，默认值为ARKUI_TEXTPICKER_RANGETYPE_SINGLE；\n 3018 * ?.string：针对不同选择器类型有如下输入范式：\n 3019 * 1：单列选择器，入参格式为用分号分隔的一组字符串；\n 3020 * 2：多列选择器，支持多对纯文本字符串对，多对之间使用分号分隔，每对内部使用逗号分隔；\n 3021 * ?.object：针对不同选择器类型有如下输入范式：\n 3022 * 1：单列支持图片的选择器，输入结构体为{@link ARKUI_TextPickerRangeContent}；\n 3023 * 2：多列联动选择器，输入结构体为{@link ARKUI_TextPickerCascadeRangeContent}；\n 3024 * \n 3025 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 3026 * .value[0].i32：使用的选择器类型{@link ArkUI_TextPickerRangeType}；\n 3027 * ?.string：针对不同选择器类型有如下输出范式：\n 3028 * 1：单列选择器，输出格式为用分号分隔的一组字符串；\n 3029 * 2：多列选择器，输出多对纯文本字符串对，多对之间使用分号分隔，每对内部使用逗号分隔；\n 3030 * ?.object：针对不同选择器类型有如下输出范式：\n 3031 * 1：单列支持图片的选择器，输出结构体为{@link ARKUI_TextPickerRangeContent}；\n 3032 * 2：多列联动选择器，输出结构体为{@link ARKUI_TextPickerCascadeRangeContent}；\n 3033 * 3034 * @code {.cpp} 3035 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3036 * ArkUI_NumberValue value[] = { {.i32=ARKUI_TEXTPICKER_RANGETYPE_MULTI} }; 3037 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue), "1,2,3;A,B,C" }; 3038 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_PICKER_OPTION_RANGE, &item); 3039 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_PICKER_OPTION_RANGE); 3040 * auto nodeTextPickerRangeType = item->value[0].i32; 3041 * auto nodeTextPickerMultiRange = item->string; 3042 * @endcode 3043 * 3044 */ 3045 NODE_TEXT_PICKER_OPTION_RANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TEXT_PICKER, 3046 /** 3047 * @brief 滑动选择文本内容的组件默认选中项在数组中的索引值，支持属性设置和属性获取接口。 3048 * 3049 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 3050 * .value[0].u32：索引值，如存在多个索引值则逐个添加；\n 3051 * \n 3052 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 3053 * .value[0].u32：索引值，如存在多个索引值则逐个添加；\n 3054 * 3055 * @code {.cpp} 3056 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3057 * ArkUI_NumberValue value[] = { {.u32 = 1}, {.u32 = 2} }; 3058 * ArkUI_AttributeItem item = { value, sizeof(value)/sizeof(ArkUI_NumberValue) }; 3059 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_PICKER_OPTION_SELECTED, &item); 3060 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_PICKER_OPTION_SELECTED); 3061 * auto nodeTextPickerSelected = item->value[0].u32; 3062 * @endcode 3063 * 3064 */ 3065 NODE_TEXT_PICKER_OPTION_SELECTED, 3066 /** 3067 * @brief 滑动选择文本内容的组件默认选中项的值，支持属性设置和属性获取接口。 3068 * 3069 * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n 3070 * .string：选中项的值，如存在多个值则逐个添加，用分号分隔；\n 3071 * \n 3072 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 3073 * .string：选中项的值，如存在多个值则逐个添加，用分号分隔；\n 3074 * 3075 * @code {.cpp} 3076 * ArkUI_NativeNodeAPI_1* nativeNodeApi - reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3077 * ArkUI_AttributeItem item = { .string = "A;B" }; 3078 * nativeNodeApi->setAttribute(nodeHandle, NODE_TEXT_PICKER_OPTION_VALUE, &item); 3079 * auto item = nativeNodeApi=>getAttribute(nodeHandle, NODE_TEXT_PICKER_OPTION_VALUE); 3080 * auto nodeTextPickerValue = item->string; 3081 * @endcode 3082 * 3083 */ 3084 NODE_TEXT_PICKER_OPTION_VALUE, 3085 /** 3086 * @brief 通过{@link 3087 * setAttribute}方法设置滑动选择文本内容的组件所有选项中最上和最下两个选项的文本颜色、字号、字体粗细。 3088 * 3089 * {@link ArkUI_AttributeItem}参数类型：\n 3090 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 3091 * 入参1： 文本颜色，#argb类型\n 3092 * 入参2： 文本大小，数字类型，单位fp\n 3093 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 3094 * 入参4： 文本字体列表，使用 ',' 进行分割\n 3095 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 3096 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 3097 * @code {.c} 3098 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 3099 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item); 3100 * @endcode 3101 */ 3102 NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, 3103 /** 3104 * @brief 通过{@link 3105 * setAttribute}方法设置滑动选择文本内容的组件所有选项中除了最上、最下及选中项以外的文本颜色、字号、字体粗细。 3106 * 3107 * {@link ArkUI_AttributeItem}参数类型：\n 3108 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 3109 * 入参1： 文本颜色，#argb类型\n 3110 * 入参2： 文本大小，数字类型，单位fp\n 3111 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 3112 * 入参4： 文本字体列表，使用 ',' 进行分割\n 3113 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 3114 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 3115 * @code {.c} 3116 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 3117 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_PICKER_TEXT_STYLE, &item); 3118 * @endcode 3119 */ 3120 NODE_TEXT_PICKER_TEXT_STYLE, 3121 /** 3122 * @brief 通过{@link setAttribute}方法设置滑动选择文本内容的组件选中项的文本颜色、字号、字体粗细。 3123 * 3124 * {@link ArkUI_AttributeItem}参数类型：\n 3125 * .string： 入参5个，格式为字符串，以 ';' 分割：\n 3126 * 入参1： 文本颜色，#argb类型\n 3127 * 入参2： 文本大小，数字类型，单位fp\n 3128 * 入参3： 文本粗细，字符串枚举("bold", "normal", "bolder", "lighter", "medium", "regular")\n 3129 * 入参4： 文本字体列表，使用 ',' 进行分割\n 3130 * 入参5： 文本样式，字符串枚举("normal", "italic")\n 3131 * 如 "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" 。 3132 * @code {.c} 3133 * ARKUI_AttributeItem item = { .string = "#ff182431;14;normal;Arial,HarmonyOS Sans;normal" }; 3134 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item); 3135 * @endcode 3136 */ 3137 NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, 3138 /** 3139 * @brief 通过{@link setAttribute}方法设置滑动选择文本内容的组件默认选中项在数组中的索引值，优先级高于 options 3140 * 中的选中值。 3141 * 3142 * {@link ArkUI_AttributeItem}参数类型：\n 3143 * .value[0...].i32：默认选中项在数组中的索引值数组，优先级高于options中的选中值。 3144 * 3145 * @note 入参索引列表，数字类型数组，格式字符串，以空格分割，如 "0 1" 。 3146 * @code {.c} 3147 * ArkUI_NumberValue value[] = { { .i32 = 0 }, { .i32 = 1 } }; 3148 * ARKUI_AttributeItem item = { value, sizeof(value) / sizeof(ArkUI_NumberValue) }; 3149 * basicNodeApi->setAttribute(nodeHandle, NODE_TEXT_PICKER_SELECTED_INDEX, &item); 3150 * @endcode 3151 */ 3152 NODE_TEXT_PICKER_SELECTED_INDEX, 3153 3154 /** 3155 * @brief Slider滑块的颜色，支持属性设置，属性重置和属性获取。 3156 * 3157 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3158 * .value[0].u32：滑块的颜色, 类型为0xargb，如0xFF1122FF。 3159 * \n 3160 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3161 * .value[0].u32：滑块的颜色, 类型为0xargb，如0xFF1122FF。 3162 * 3163 * @code {.c} 3164 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3165 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3166 * ArkUI_NumberValue value[] = { { .u32 = 0xFF1122FF } }; 3167 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3168 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_BLOCK_COLOR, &item); 3169 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_BLOCK_COLOR); 3170 * auto value = item->value[0].u32; 3171 * @endcode 3172 * 3173 */ 3174 NODE_SLIDER_BLOCK_COLOR = MAX_NODE_SCOPE_NUM * ARKUI_NODE_SLIDER, 3175 3176 /** 3177 * @brief Slider滑轨的背景颜色，支持属性设置，属性重置和属性获取。 3178 * 3179 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3180 * .value[0].u32：背景颜色, 类型为0xargb，如0xFF1122FF。 3181 * \n 3182 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3183 * .value[0].u32：背景颜色, 类型为0xargb，如0xFF1122FF。 3184 * 3185 * @code {.c} 3186 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3187 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3188 * ArkUI_NumberValue value[] = { { .u32 = 0xFF1122FF } }; 3189 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3190 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_TRACK_COLOR, &item); 3191 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_TRACK_COLOR); 3192 * auto value = item->value[0].u32; 3193 * @endcode 3194 * 3195 */ 3196 NODE_SLIDER_TRACK_COLOR, 3197 3198 /** 3199 * @brief Slider滑轨的已滑动部分颜色，支持属性设置，属性重置和属性获取。 3200 * 3201 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3202 * .value[0].u32：已滑动部分颜色, 类型为0xargb，如0xFF1122FF。 3203 * \n 3204 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3205 * .value[0].u32：已滑动部分颜色, 类型为0xargb，如0xFF1122FF。 3206 * 3207 * @code {.c} 3208 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3209 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3210 * ArkUI_NumberValue value[] = { { .u32 = 0xFF1122FF } }; 3211 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3212 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_SELECTED_COLOR, &item); 3213 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_SELECTED_COLOR); 3214 * auto value = item->value[0].u32; 3215 * @endcode 3216 * 3217 */ 3218 NODE_SLIDER_SELECTED_COLOR, 3219 3220 /** 3221 * @brief Slider滑动时是否显示气泡提示，支持属性设置，属性重置和属性获取。 3222 * 3223 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3224 * .value[0].i32：是否显示气泡，1表示显示，0表示不显示，默认值为0。 3225 * .string? 可选值，气泡提示的文本内容，默认显示当前百分比字符串。 3226 * \n 3227 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n 3228 * .value[0].i32：是否显示气泡，1表示显示，0表示不显示，默认值为0。 3229 * .string? 可选值，气泡提示的文本内容，默认显示当前百分比字符串。 3230 * 3231 * @code {.c} 3232 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3233 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3234 * ArkUI_NumberValue value[] = { { .i32 = 1 } }; 3235 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue), "test"}; 3236 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_SHOW_TIPS, &item); 3237 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_SELECTED_COLOR); 3238 * auto value = item->value[0].i32; 3239 * @endcode 3240 * 3241 */ 3242 NODE_SLIDER_SHOW_TIPS, 3243 3244 /** 3245 * @brief Slider滑块形状参数，支持属性设置，属性重置和属性获取。 3246 * 3247 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3248 * .value[0].i32：形状参数。参数类型{@link ArkUI_SliderBlockStyle}。 3249 * .string? 可选值，根据形状参数而定。 3250 * ARKUI_SLIDER_BLOCK_STYLE_IMAGE: 滑块图片资源。如/pages/common/icon.png。 3251 * ARKUI_SLIDER_BLOCK_STYLE_SHAPE: 滑块使用的自定义形状。 3252 * "rect(10,10,10,10)"括号内分别为width、height、radiusWidth与radiusHeight"; \n 3253 * "circle(10,10)"括号内分别为width、height; \n 3254 * "ellipse(10,10)"括号内分别为width、height; \n 3255 * "path(10,10,M0 0 L600 0)"括号内分别为width、height、commands; \n 3256 * \n 3257 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3258 * .value[0].i32：形状参数。参数类型{@link ArkUI_SliderBlockStyle}。 3259 * .string? 可选值，根据形状参数而定。 3260 * ARKUI_SLIDER_BLOCK_STYLE_IMAGE: 滑块图片资源。如/pages/common/icon.png。 3261 * ARKUI_SLIDER_BLOCK_STYLE_SHAPE: 滑块使用的自定义形状。 3262 * "rect(10,10,10,10)"括号内分别为width、height、radiusWidth与radiusHeight"; \n 3263 * "circle(10,10)"括号内分别为width、height; \n 3264 * "ellipse(10,10)"括号内分别为width、height; \n 3265 * "path(10,10,M0 0 L600 0)"括号内分别为width、height、commands; \n 3266 * 3267 * @code {.c} 3268 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3269 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3270 * ArkUI_NumberValue value[] = {{.i32 = ARKUI_SLIDER_BLOCK_STYLE_DEFAULT}}; 3271 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3272 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_BLOCK_STYLE, &item); 3273 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_BLOCK_STYLE); 3274 * auto value = item->value[0].i32; 3275 * @endcode 3276 * 3277 */ 3278 NODE_SLIDER_BLOCK_STYLE, 3279 3280 /** 3281 * @brief slider进度值，支持属性设置，属性重置和属性获取。 3282 * 3283 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3284 * .value[0].f32：进度值。 3285 * \n 3286 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3287 * .value[0].f32：进度值。 3288 * 3289 * @code {.c} 3290 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3291 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3292 * ArkUI_NumberValue value[] = { 0 }; 3293 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3294 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_VALUE, &item); 3295 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_VALUE); 3296 * auto value = item->value[0].f32; 3297 * @endcode 3298 * 3299 */ 3300 NODE_SLIDER_VALUE, 3301 3302 /** 3303 * @brief slider最小值，支持属性设置，属性重置和属性获取。 3304 * 3305 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3306 * .value[0].f32：进度值的最小值。 3307 * \n 3308 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3309 * .value[0].f32：进度值的最小值。 3310 * 3311 * @code {.c} 3312 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3313 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3314 * ArkUI_NumberValue value[] = { 0 }; 3315 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3316 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_MIN_VALUE, &item); 3317 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_MIN_VALUE); 3318 * auto value = item->value[0].f32; 3319 * @endcode 3320 * 3321 */ 3322 NODE_SLIDER_MIN_VALUE, 3323 3324 /** 3325 * @brief slider最大值，支持属性设置，属性重置和属性获取。 3326 * 3327 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3328 * .value[0].f32：进度值的最大值。 3329 * \n 3330 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3331 * .value[0].f32：进度值的最大值。 3332 * 3333 * @code {.c} 3334 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3335 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3336 * ArkUI_NumberValue value[] = { 100 }; 3337 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3338 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_MAX_VALUE, &item); 3339 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_MIN_VALUE); 3340 * auto value = item->value[0].f32; 3341 * @endcode 3342 * 3343 */ 3344 NODE_SLIDER_MAX_VALUE, 3345 3346 /** 3347 * @brief Slider滑动步长，支持属性设置，属性重置和属性获取。 3348 * 3349 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3350 * .value[0].f32：滑动步长，取值范围：[0.01, 100]。 3351 * \n 3352 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3353 * .value[0].f32：滑动步长，取值范围：[0.01, 100]。 3354 * 3355 * @code {.c} 3356 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3357 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3358 * ArkUI_NumberValue value[] = { 100 }; 3359 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3360 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_STEP, &item); 3361 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_STEP); 3362 * auto value = item->value[0].f32; 3363 * @endcode 3364 * 3365 */ 3366 NODE_SLIDER_STEP, 3367 3368 /** 3369 * @brief Slider滑动条滑动方向，支持属性设置，属性重置和属性获取。 3370 * 3371 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3372 * .value[0].i32：显示样式，参数类型{@link ArkUI_SliderDirection}。 3373 * \n 3374 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3375 * .value[0].i32：显示样式，参数类型{@link ArkUI_SliderDirection}。 3376 * 3377 * @code {.c} 3378 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3379 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3380 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_SLIDER_DIRECTION_VERTICAL } }; 3381 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3382 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_DIRECTION, &item); 3383 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_DIRECTION); 3384 * auto value = item->value[0].i32; 3385 * @endcode 3386 * 3387 */ 3388 NODE_SLIDER_DIRECTION, 3389 3390 /** 3391 * @brief Slider滑动条取值范围是否反向，支持属性设置，属性重置和属性获取。 3392 * 3393 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3394 * .value[0].i32：是否反向，1表示反向，0表示不反向。 3395 * \n 3396 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3397 * .value[0].i32：是否反向，1表示反向，0表示不反向。 3398 * 3399 * @code {.c} 3400 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3401 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3402 * ArkUI_NumberValue value[] = { {.i32 = 0} }; 3403 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3404 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_REVERSE, &item); 3405 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_REVERSE); 3406 * auto value = item->value[0].i32; 3407 * @endcode 3408 * 3409 */ 3410 NODE_SLIDER_REVERSE, 3411 3412 /** 3413 * @brief Slider的滑块与滑轨显示样式，支持属性设置，属性重置和属性获取。 3414 * 3415 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3416 * .value[0].i32：显示样式，参数类型{@link ArkUI_SliderStyle}。 3417 * \n 3418 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3419 * .value[0].i32：显示样式，参数类型{@link ArkUI_SliderStyle}。 3420 * 3421 * @code {.c} 3422 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3423 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3424 * ArkUI_NumberValue value[] = { { .i32 = ARKUI_SLIDER_STYLE_OUT_SET } }; 3425 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3426 * nativeNodeApi->setAttribute(nodeHandle, NODE_SLIDER_STYLE, &item); 3427 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_SLIDER_STYLE); 3428 * auto value = item->value[0].i32; 3429 * @endcode 3430 * 3431 */ 3432 NODE_SLIDER_STYLE, 3433 3434 /** 3435 * @brief CheckBox多选框是否选中，支持属性设置，属性重置和属性获取。 3436 * 3437 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3438 * .value[0].i32：1表示选中，0表示不选中。 3439 * \n 3440 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3441 * .value[0].i32：1表示选中，0表示不选中。 3442 * 3443 * @code {.c} 3444 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3445 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3446 * ArkUI_NumberValue value[] = { { .i32 = 0 } }; 3447 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3448 * nativeNodeApi->setAttribute(nodeHandle, NODE_CHECKBOX_SELECT, &item); 3449 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_CHECKBOX_SELECT); 3450 * auto value = item->value[0].i32; 3451 * @endcode 3452 * 3453 */ 3454 NODE_CHECKBOX_SELECT = MAX_NODE_SCOPE_NUM * ARKUI_NODE_CHECKBOX, 3455 3456 /** 3457 * @brief CheckBox多选框选中状态颜色，支持属性设置，属性重置和属性获取。 3458 * 3459 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3460 * .value[0].u32：多选框选中状态颜色, 类型为0xargb，如0xFF1122FF。 3461 * \n 3462 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3463 * .value[0].u32：多选框选中状态颜色, 类型为0xargb，如0xFF1122FF。 3464 * 3465 * @code {.c} 3466 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3467 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3468 * ArkUI_NumberValue value[] = { { .u32 = 0xFF1122FF } }; 3469 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3470 * basicNodeApi->setAttribute(nodeHandle, NODE_CHECKBOX_SELECT_COLOR, &item); 3471 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_CHECKBOX_SELECT_COLOR); 3472 * auto value = item->value[0].u32; 3473 * @endcode 3474 * 3475 */ 3476 NODE_CHECKBOX_SELECT_COLOR, 3477 3478 /** 3479 * @brief CheckBox多选框非选中状态边框颜色，支持属性设置，属性重置和属性获取。 3480 * 3481 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3482 * .value[0].u32：边框颜色, 类型为0xargb，如0xFF1122FF 3483 * \n 3484 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3485 * .value[0].u32：边框颜色, 类型为0xargb，如0xFF1122FF 3486 * 3487 * @code {.c} 3488 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3489 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3490 * ArkUI_NumberValue value[] = { { .u32 = 0xFF1122FF } }; 3491 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3492 * nativeNodeApi->setAttribute(nodeHandle, NODE_CHECKBOX_UNSELECT_COLOR, &item); 3493 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_CHECKBOX_UNSELECT_COLOR); 3494 * auto value = item->value[0].u32; 3495 * @endcode 3496 * 3497 */ 3498 NODE_CHECKBOX_UNSELECT_COLOR, 3499 3500 /** 3501 * @brief CheckBox多选框内部图标样式，支持属性设置，属性重置和属性获取。 3502 * 3503 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3504 * .value[0].i32：边框颜色, 类型为0xargb，如0xFF1122FF 3505 * .value[1]?.f32：可选，内部图标大小，单位vp。 3506 * .value[2]?.f32：可选，内部图标粗细，单位vp，默认值2。 3507 * \n 3508 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3509 * .value[0].u32：边框颜色, 类型为0xargb，如0xFF1122FF 3510 * .value[1]?.f32：可选，内部图标大小，单位vp。 3511 * .value[2]?.f32：可选，内部图标粗细，单位vp，默认值2。 3512 * 3513 * @code {.c} 3514 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3515 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3516 * ArkUI_NumberValue value[] = { { .i32 = 0xFF1122FF }, 20.0f, 2.0f }; 3517 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3518 * nativeNodeApi->setAttribute(nodeHandle, NODE_CHECKBOX_MARK, &item); 3519 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_CHECKBOX_MARK); 3520 * auto value = item->value[0].i32; 3521 * @endcode 3522 * 3523 */ 3524 NODE_CHECKBOX_MARK, 3525 3526 /** 3527 * @brief CheckBox组件形状, 支持属性设置，属性重置和属性获取。 3528 * 3529 * 属性设置方法{@link ArkUI_AttributeItem}参数格式： \n 3530 * .value[0].i32：组件形状，参数类型{@link ArkUI_CheckboxShape}。 3531 * \n 3532 * 属性获取方法返回值{@link ArkUI_AttributeItem}格式： \n 3533 * .value[0].i32：组件形状，参数类型{@link ArkUI_CheckboxShape}。 3534 * 3535 * @code {.c} 3536 * ArkUI_NativeNodeAPI_1* nativeNodeApi = 3537 * reinterpret_cast<ArkUI_NativeNodeAPI_1*>(OH_ArkUI_GetNativeAPI(ARKUI_NATIVE_NODE, 1)); 3538 * ArkUI_NumberValue value[] = { { .i32 = ArkUI_CHECKBOX_SHAPE_CIRCLE } }; 3539 * ArkUI_AttributeItem item = {value, sizeof(value)/sizeof(ArkUI_NumberValue)}; 3540 * nativeNodeApi->setAttribute(nodeHandle, NODE_CHECKBOX_SHAPE, &item); 3541 * auto item = nativeNodeApi->getAttribute(nodeHandle, NODE_CHECKBOX_SHAPE); 3542 * auto value = item->value[0].i32; 3543 * @endcode 3544 * 3545 */ 3546 NODE_CHECKBOX_SHAPE, 3547 3548 } ArkUI_NodeAttributeType; 3549 3550 #define MAX_COMPONENT_EVENT_ARG_NUM 12 3551 /** 3552 * @brief 定义组件回调事件的参数类型。 3553 * 3554 * @since 12 3555 */ 3556 typedef struct { 3557 /** 数据数组对象。*/ 3558 ArkUI_NumberValue data[MAX_COMPONENT_EVENT_ARG_NUM]; 3559 } ArkUI_NodeComponentEvent; 3560 3561 /** 3562 * @brief 定义组件回调事件使用字符串参数的类型。 3563 * 3564 * @since 12 3565 */ 3566 typedef struct { 3567 /** 字符串数据。*/ 3568 const char* pStr; 3569 } ArkUI_StringAsyncEvent; 3570 3571 /** 3572 * @brief 提供NativeNode组件支持的事件类型定义。 3573 * 3574 * @since 12 3575 */ 3576 typedef enum { 3577 /** 3578 * @brief 手势事件类型。 3579 * 3580 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_TouchEvent}。 3581 */ 3582 NODE_TOUCH_EVENT = 0, 3583 3584 /** 3585 * @brief 挂载事件。 3586 * 3587 * 触发该事件的条件 ：组件挂载显示时触发此回调。\n 3588 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3589 * {@link ArkUI_NodeComponentEvent}中不包含参数。 3590 */ 3591 NODE_EVENT_ON_APPEAR, 3592 3593 /** 3594 * @brief 组件区域变化事件 3595 * 3596 * 触发该事件的条件 ：组件区域变化时触发该回调。\n 3597 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3598 * @note <b>::ArkUI_NodeComponentEvent</b>中包含12个参数\n 3599 * <b>ArkUI_NodeComponent.data[0].f32</b>表示 old Area 目标元素的宽度，类型为number，单位vp。\n 3600 * <b>ArkUI_NodeComponent.data[1].f32</b>表示 old Area 目标元素的高度，类型为number，单位vp。\n 3601 * <b>ArkUI_NodeComponent.data[2].f32</b>表示 old Area 3602 * 目标元素左上角相对父元素左上角的位置的x轴坐标，类型为number，单位vp。\n 3603 * <b>ArkUI_NodeComponent.data[3].f32</b>表示 old Area 3604 * 目标元素左上角相对父元素左上角的位置的y轴坐标，类型为number，单位vp。\n 3605 * <b>ArkUI_NodeComponent.data[4].f32</b>表示 old Area 3606 * 目标元素目标元素左上角相对页面左上角的位置的x轴坐标，类型为number，单位vp。\n 3607 * <b>ArkUI_NodeComponent.data[5].f32</b>表示 old Area 3608 * 目标元素目标元素左上角相对页面左上角的位置的y轴坐标，类型为number，单位vp。\n 3609 * <b>ArkUI_NodeComponent.data[6].f32</b>表示 new Area 目标元素的宽度，类型为number，单位vp。\n 3610 * <b>ArkUI_NodeComponent.data[7].f32</b>表示 new Area 目标元素的高度，类型为number，单位vp。\n 3611 * <b>ArkUI_NodeComponent.data[8].f32</b>表示 new Area 3612 * 目标元素左上角相对父元素左上角的位置的x轴坐标，类型为number，单位vp。\n 3613 * <b>ArkUI_NodeComponent.data[9].f32</b>表示 new Area 3614 * 目标元素左上角相对父元素左上角的位置的y轴坐标，类型为number，单位vp。\n 3615 * <b>ArkUI_NodeComponent.data[10].f32</b>表示 new Area 3616 * 目标元素目标元素左上角相对页面左上角的位置的x轴坐标，类型为number，单位vp。\n 3617 * <b>ArkUI_NodeComponent.data[11].f32</b>表示 new Area 3618 * 目标元素目标元素左上角相对页面左上角的位置的y轴坐标，类型为number，单位vp。\n 3619 */ 3620 NODE_EVENT_ON_ON_AREA_CHANGE, 3621 NODE_ON_FOCUS, 3622 NODE_ON_BLUR, 3623 NODE_ON_CLICK, 3624 3625 NODE_TOGGLE_ON_CHANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TOGGLE, 3626 3627 NODE_TEXT_INPUT_ON_CHANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TEXT_INPUT, 3628 NODE_TEXT_INPUT_ON_SUBMIT, 3629 NODE_TEXT_INPUT_ON_CUT, 3630 NODE_TEXT_INPUT_ON_PASTE, 3631 3632 /** 3633 * @brief 定义ARKUI_NODE_SCROLL滚动组件的滚动事件枚举值。 3634 * 3635 * 触发该事件的条件 ：\n 3636 * 1、滚动组件触发滚动时触发，支持键鼠操作等其他触发滚动的输入设置。\n 3637 * 2、通过滚动控制器API接口调用。\n 3638 * 3、越界回弹。\n 3639 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3640 * <b>::ArkUI_NodeComponentEvent</b>中包含2个参数\n 3641 * <b>ArkUI_NodeComponent.data[0].f32</b>表示距离上一次事件触发的X轴增量。\n 3642 * <b>ArkUI_NodeComponent.data[1].f32</b>表示距离上一次事件触发的Y轴增量。\n 3643 */ 3644 NODE_SCROLL_EVENT_ON_SCROLL = MAX_NODE_SCOPE_NUM * ARKUI_NODE_SCROLL, 3645 /** 3646 * @brief 定义ARKUI_NODE_SCROLL滚动组件的滚动帧始事件枚举值 3647 * 3648 * 触发该事件的条件 ：\n 3649 * 1、滚动组件触发滚动时触发，包括键鼠操作等其他触发滚动的输入设置。\n 3650 * 2、调用控制器接口时不触发。\n 3651 * 3、越界回弹不触发。\n 3652 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3653 * <b>::ArkUI_NodeComponentEvent</b>中包含2个参数\n 3654 * <b>ArkUI_NodeComponent.data[0].f32</b>表示即将发生的滚动量。\n 3655 * <b>ArkUI_NodeComponent.data[1].i32</b>表示当前滚动状态。\n 3656 * <b>::ArkUI_NodeComponentEvent</b>中包含1个返回值\n 3657 * <b>ArkUI_NodeComponent.data[0].f32</b>事件处理函数中可根据应用场景计算实际需要的滚动量并存于data[0].f32中，Scroll将按照返回值的实际滚动量进行滚动\n 3658 */ 3659 NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN, 3660 /** 3661 * @brief 定义ARKUI_NODE_SCROLL滚动组件的滚动开始事件枚举值。 3662 * 3663 * 触发该事件的条件 ：\n 3664 * 1、滚动组件开始滚动时触发，支持键鼠操作等其他触发滚动的输入设置。\n 3665 * 2、通过滚动控制器API接口调用后开始，带过渡动效。\n 3666 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3667 * <b>::ArkUI_NodeComponentEvent</b>中不包含参数。\n 3668 */ 3669 NODE_SCROLL_EVENT_ON_SCROLL_START, 3670 /** 3671 * @brief 定义ARKUI_NODE_SCROLL滚动组件的滚动停止事件枚举值。 3672 * 3673 * 触发该事件的条件 ：\n 3674 * 1、滚动组件触发滚动后停止，支持键鼠操作等其他触发滚动的输入设置。\n 3675 * 2、通过滚动控制器API接口调用后停止，带过渡动效。\n 3676 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3677 * <b>::ArkUI_NodeComponentEvent</b>中不包含参数。\n 3678 */ 3679 NODE_SCROLL_EVENT_ON_SCROLL_STOP, 3680 /** 3681 * @brief 定义ARKUI_NODE_SCROLL滚动组件的滚动边缘事件枚举值。 3682 * 3683 * 触发该事件的条件 ：\n 3684 * 1、滚动组件滚动到边缘时触发，支持键鼠操作等其他触发滚动的输入设置。\n 3685 * 2、通过滚动控制器API接口调用。\n 3686 * 3、越界回弹。\n 3687 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3688 * <b>::ArkUI_NodeComponentEvent</b>中包含1个参数。\n 3689 * <b>ArkUI_NodeComponent.data[0].i32</b>表示当前碰到的是上下左右哪个边。\n 3690 */ 3691 NODE_SCROLL_EVENT_ON_SCROLL_EDGE, 3692 3693 NODE_TEXT_AREA_ON_CHANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TEXT_AREA, 3694 3695 NODE_REFRESH_STATE_CHANGE = 1000 * ARKUI_NODE_REFRESH + 1, 3696 NODE_REFRESH_ON_REFRESH, 3697 3698 /** 3699 * @brief 定义ARKUI_NODE_DATE_PICKER 列表组件的滚动触摸事件枚举值。 3700 * 3701 * 触发该事件的条件 ：选择日期时触发该事件。\n 3702 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3703 * <b>::ArkUI_NodeComponentEvent</b>中包含3个参数。\n 3704 * <b>ArkUI_NodeComponent.data[0].i32</b>表示 选中时间的年。\n 3705 * <b>ArkUI_NodeComponent.data[1].i32</b>表示 选中时间的月，取值范围：[0-11]。\n 3706 * <b>ArkUI_NodeComponent.data[2].i32</b>表示 选中时间的天。\n 3707 */ 3708 NODE_DATE_PICKER_EVENT_ON_DATE_CHANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_DATE_PICKER, 3709 3710 /** 3711 * @brief 定义ARKUI_NODE_TIME_PICKER 列表组件的滚动触摸事件枚举值。 3712 * 3713 * 触发该事件的条件 ：选择时间时触发该事件。\n 3714 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3715 * <b>::ArkUI_NodeComponentEvent</b>中包含2个参数。\n 3716 * <b>ArkUI_NodeComponent.data[0].i32</b>表示 选中时间的时，取值范围：[0-23]。\n 3717 * <b>ArkUI_NodeComponent.data[1].i32</b>表示 选中时间的分，取值范围：[0-59]。\n 3718 */ 3719 NODE_TIME_PICKER_EVENT_ON_CHANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TIME_PICKER, 3720 3721 /** 3722 * @brief 定义ARKUI_NODE_TEXT_PICKER 列表组件的滚动触摸事件枚举值。 3723 * 3724 * 触发该事件的条件 ：选择时间时触发该事件。\n 3725 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3726 * <b>::ArkUI_NodeComponentEvent</b>中包含2个参数。\n 3727 * <b>ArkUI_NodeComponent.data[0].i32</b>表示 选中时间的时，取值范围：[0-23]。\n 3728 * <b>ArkUI_NodeComponent.data[1].i32</b>表示 选中时间的分，取值范围：[0-59]。\n 3729 */ 3730 NODE_TEXT_PICKER_EVENT_ON_CHANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_TEXT_PICKER, 3731 3732 /** 3733 * @brief 定义ARKUI_NODE_CHECKBOX当选中状态发生变化时，触发该回调。 3734 * 3735 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3736 * <b>ArkUI_NodeComponent.data[0].i32</b>1:表示已选中, 0: 表示未选中\n 3737 */ 3738 NODE_CHECKBOX_EVENT_ON_CHANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_CHECKBOX, 3739 /** 3740 * @brief 定义ARKUI_NODE_SLIDER拖动或点击时触发事件回调。 3741 * 3742 * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n 3743 * <b>ArkUI_NodeComponent.data[0].f32</b>当前滑动进度值。\n 3744 * <b>ArkUI_NodeComponent.data[1].i32</b>事件触发的相关状态值\n 3745 */ 3746 NODE_SLIDER_EVENT_ON_CHANGE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_SLIDER, 3747 3748 } ArkUI_NodeEventType; 3749 3750 /** 3751 * @brief 定义组件事件的通用结构类型。 3752 * 3753 * @since 12 3754 */ 3755 typedef struct { 3756 /** 3757 * @brief 事件类型。 3758 * 3759 * @see ArkUI_NodeEventType 3760 */ 3761 int32_t kind; 3762 3763 /** 3764 * @brief 事件自定义标识ID。 3765 * 3766 * 该事件id在调用{@link registerNodeEvent}函数时作为参数传递进来，可应用于同一事件入口函数{@link 3767 * registerNodeEventReceiver}分发逻辑。 3768 */ 3769 int32_t eventId; 3770 3771 /** 触发该组件的组件对象。*/ 3772 ArkUI_NodeHandle node; 3773 union { 3774 /** touch事件类型回调参数。*/ 3775 ArkUI_NodeTouchEvent touchEvent; 3776 /** 通用组件事件使用数字类型回调参数。*/ 3777 ArkUI_NodeComponentEvent componentEvent; 3778 /** 通用组件事件使用字符串类型回调参数。*/ 3779 ArkUI_StringAsyncEvent stringEvent; 3780 }; 3781 } ArkUI_NodeEvent; 3782 3783 /** 3784 * @brief 自定义组件调用<b>::markDirty</b>是传递的藏区标识类型。 3785 * 3786 * @since 12 3787 */ 3788 typedef enum { 3789 /** 3790 * @brief 重新测算大小。 3791 * 3792 * 该flag类型触发时，同时也默认会触发重新布局。 3793 */ 3794 NODE_NEED_MEASURE = 1, 3795 3796 /** 重新布局位置。*/ 3797 NODE_NEED_LAYOUT, 3798 /** 重新进行绘制。*/ 3799 NODE_NEED_RENDER, 3800 } ArkUI_NodeDirtyFlag; 3801 3802 /** 3803 * @brief ArkUI提供的Native侧Node类型接口集合。 3804 * 3805 * @version 1 3806 * @since 12 3807 */ 3808 typedef struct { 3809 /** 结构体版本。 */ 3810 int32_t version; 3811 3812 /** 3813 * @brief 基于{@link ArkUI_NodeType}生成对应的组件并返回组件对象指针。 3814 * 3815 * @param type 创建指定类型的UI组件节点。 3816 * @return 返回创建完成的组件操作指针，如果创建失败返回NULL。 3817 */ 3818 ArkUI_NodeHandle (*createNode)(ArkUI_NodeType type); 3819 3820 /** 3821 * @brief 销毁组件指针指向的组件对象。 3822 * 3823 * @param node 组件指针对象。 3824 */ 3825 void (*disposeNode)(ArkUI_NodeHandle node); 3826 3827 /** 3828 * @brief 将组件挂载到某个父节点之下。 3829 * 3830 * @param parent 父节点指针。 3831 * @param child 子节点指针。 3832 */ 3833 void (*addChild)(ArkUI_NodeHandle parent, ArkUI_NodeHandle child); 3834 3835 /** 3836 * @brief 将组件从父节点中移除。 3837 * 3838 * @param parent 父节点指针。 3839 * @param child 子节点指针。 3840 */ 3841 void (*removeChild)(ArkUI_NodeHandle parent, ArkUI_NodeHandle child); 3842 3843 /** 3844 * @brief 将组件挂载到某个父节点之下，挂载位置在<b>sibling</b>节点之后。 3845 * 3846 * @param parent 父节点指针。 3847 * @param child 子节点指针。 3848 * @param sibling 前一个兄弟节点指针，如果为空则插入位置在最前面。 3849 */ 3850 void (*insertChildAfter)(ArkUI_NodeHandle parent, ArkUI_NodeHandle child, ArkUI_NodeHandle sibling); 3851 3852 /** 3853 * @brief 将组件挂载到某个父节点之下，挂载位置在<b>sibling</b>节点之前。 3854 * 3855 * @param parent 父节点指针。 3856 * @param child 子节点指针。 3857 * @param sibling 后一个兄弟节点指针，如果为空则插入位置在最后面。 3858 */ 3859 void (*insertChildBefore)(ArkUI_NodeHandle parent, ArkUI_NodeHandle child, ArkUI_NodeHandle sibling); 3860 3861 /** 3862 * @brief 将组件挂载到某个父节点之下，挂载位置由<b>position</b>指定。 3863 * 3864 * @param parent 父节点指针。 3865 * @param child 子节点指针。 3866 * @param postion 插入位置，如果插入位置为负数或者不存在，则默认插入位置在最后面。 3867 */ 3868 void (*insertChildAt)(ArkUI_NodeHandle parent, ArkUI_NodeHandle child, int32_t position); 3869 3870 /** 3871 * @brief 属性设置函数。 3872 * 3873 * @param node 需要设置属性的节点对象。 3874 * @param attribute 需要设置的属性类型。 3875 * @param item 需要设置的属性值。 3876 * @return 0 - 成功。 3877 * 401 - 函数参数异常。 3878 * 106101 - 系统中未找到Native接口的动态实现库。 3879 */ 3880 int32_t (*setAttribute)(ArkUI_NodeHandle node, ArkUI_NodeAttributeType attribute, const ArkUI_AttributeItem* item); 3881 3882 /** 3883 * @brief 属性获取函数。 3884 * 3885 * 该接口返回的指针是ArkUI框架内部的缓冲区指针，不需要开发者主动调用delete释放内存，但是需要在该函数下一次被调用前使用，否则可能会被其他值所覆盖。 3886 * 3887 * @param node 需要获取属性的节点对象。 3888 * @param attribute 需要获取的属性类型。 3889 * @return 当前属性类型的属性值，失败返回空指针。 3890 */ 3891 const ArkUI_AttributeItem* (*getAttribute)(ArkUI_NodeHandle node, ArkUI_NodeAttributeType attribute); 3892 3893 /** 3894 * @brief 重置属性函数。 3895 * 3896 * @param node 需要重置属性的节点对象。 3897 * @param attribute 需要重置的属性类型。 3898 */ 3899 void (*resetAttribute)(ArkUI_NodeHandle node, ArkUI_NodeAttributeType attribute); 3900 3901 /** 3902 * @brief 注册节点事件函数。 3903 * 3904 * @param node 需要注册事件的节点对象。 3905 * @param eventType 需要注册的事件类型。 3906 * @param eventId 自定义事件ID，当事件触发时在回调参数<@link ArkUI_NodeEvent>中携带回来。 3907 * @return 0 - 成功。 3908 * 401 - 函数参数异常。 3909 * 106101 - 系统中未找到Native接口的动态实现库。 3910 */ 3911 int32_t (*registerNodeEvent)(ArkUI_NodeHandle node, ArkUI_NodeEventType eventType, int32_t eventId); 3912 3913 /** 3914 * @brief 反注册节点事件函数。 3915 * 3916 * @param node 需要反注册事件的节点对象。 3917 * @param eventType 需要反注册的事件类型。 3918 */ 3919 void (*unregisterNodeEvent)(ArkUI_NodeHandle node, ArkUI_NodeEventType eventType); 3920 3921 /** 3922 * @brief 注册事件回调统一入口函数。 3923 * 3924 * ArkUI框架会统一收集过程中产生的组件事件并通过注册的eventReceiver函数回调给开发者。\n 3925 * 重复调用时会覆盖前一次注册的函数。 3926 * 3927 * @param eventReceiver 事件回调统一入口函数。 3928 */ 3929 void (*registerNodeEventReceiver)(void (*eventReceiver)(ArkUI_NodeEvent* event)); 3930 3931 /** 3932 * @brief 反注册事件回调统一入口函数。 3933 * 3934 */ 3935 void (*unregisterNodeEventReceiver)(); 3936 3937 /** 3938 * @brief 强制标记当前节点需要重新测算，布局或者绘制。 3939 * 3940 * 系统属性设置更新场景下ArkUI框架会自动标记藏区并重新执行测算，布局或者绘制，不需要开发者主动调用该函数。 3941 * 3942 * @param node 需要标记藏区的节点对象。 3943 * @param dirtyFlag 藏区类型。 3944 */ 3945 void (*markDirty)(ArkUI_NodeHandle node, ArkUI_NodeDirtyFlag dirtyFlag); 3946 } ArkUI_NativeNodeAPI_1; 3947 3948 #ifdef __cplusplus 3949 }; 3950 #endif 3951 3952 #endif // ARKUI_NATIVE_NODE_H 3953 /** @}*/ 3954
