• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# ui_input_event.h
2<!--Kit: ArkUI-->
3<!--Subsystem: ArkUI-->
4<!--Owner: @jiangtao92-->
5<!--Designer: @piggyguy-->
6<!--Tester: @songyanhong-->
7<!--Adviser: @HelloCrease-->
8
9## 概述
10
11提供ArkUI在Native侧的事件定义。
12
13**引用文件:** <arkui/ui_input_event.h>
14
15**库:** libace_ndk.z.so
16
17**系统能力:** SystemCapability.ArkUI.ArkUI.Full
18
19**起始版本:** 12
20
21**相关模块:** [ArkUI_EventModule](capi-arkui-eventmodule.md)
22
23## 汇总
24
25### 结构体
26
27| 名称 | typedef关键字 | 描述 |
28| -- | -- | -- |
29| [ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md) | ArkUI_UIInputEvent | UI输入事件定义。 |
30
31### 枚举
32
33| 名称                                                  | typedef关键字 | 描述 |
34|-----------------------------------------------------| -- | -- |
35| [ArkUI_UIInputEvent_Type](#arkui_uiinputevent_type) | ArkUI_UIInputEvent_Type | UI输入事件类型定义。 |
36| [anonymous1](#anonymous1)                       | - | 定义输入事件的Action Code。 |
37| [anonymous2](#anonymous2)                       | - | 产生输入事件的工具类型定义。 |
38| [anonymous3](#anonymous3)                       | - | 产生输入事件的来源类型定义。 |
39| [HitTestMode](#hittestmode)                         | HitTestMode | 定义触摸测试类型的枚举值。 |
40| [anonymous4](#anonymous4)                       | - | 定义鼠标事件的Action Code。 |
41| [anonymous5](#anonymous5)                       | - | 定义鼠标事件的按键类型。 |
42| [ArkUI_ModifierKeyName](#arkui_modifierkeyname)     | ArkUI_ModifierKeyName | 定义modifier按键。 |
43| [anonymous6](#anonymous6)                       | - | 定义焦点轴事件的轴类型。 |
44| [ArkUI_InteractionHand](#arkui_interactionhand)     | ArkUI_InteractionHand | 定义触摸事件是左手还是右手。 |
45| [anonymous7](#anonymous7)                       | - | 定义轴事件的操作类型。 |
46
47### 函数
48
49| 名称 | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
50| -- |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
51| [int32_t OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_gettype) | 获取UI输入事件的类型。在访问一个ArkUI_UIInputEvent指针对象之前,推荐使用该方法判断该输入事件的类型,该接口会返回[ArkUI_UIInputEvent_Type](capi-ui-input-event-h.md#arkui_uiinputevent_type)枚举中的一种。比如,当事件是一个触控类型时,由于触控类型是指向性事件,那么使用OH_ArkUI_UIInputEvent_GetXXX及OH_ArkUI_PointerEvent_GetXXX系列接口,均可以正常访问;而如果使用OH_ArkUI_KeyEvent_GetXXX相关接口去访问它,则会有无法预期的结果。对于还未支持的事件类型,接口返回默认值0。                                                                                                                                                                                                                                                       |
52| [int32_t OH_ArkUI_UIInputEvent_GetAction(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_getaction) | 获取输入事件的action类型。action类型为基础事件在不同阶段的类型定义,通常代表了事件的特点,并表征事件的开始与结束,如touch down, touch up。触控事件的action类型为UI_TOUCH_EVENT_ACTION_XXX,鼠标事件的action类型为UI_MOUSE_EVENT_ACTION_XXX。                                                                                                                                                                                                                                                                                                                                                                                                                  |
53| [int32_t OH_ArkUI_UIInputEvent_GetSourceType(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_getsourcetype) | 获取UI输入事件的触发源类型。输入源为产生输入事件的真实物理设备,如触摸屏,鼠标等,由UI_INPUT_EVENT_SOURCE_TYPE_XXX定义,而输入工具为操作输入源设备来产生事件的工具,如手指、触控笔。在某些情况下两者可能容易发生混淆,比如当用户在操作鼠标时,鼠标既是输入源,也是输入工具。                                                                                                                                                                                                                                                                                                                                                                                                                                 |
54| [int32_t OH_ArkUI_UIInputEvent_GetToolType(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_gettooltype) | 获取UI输入事件的工具类型。输入工具为操作输入源设备来产生事件的操作方,如手指、触控笔,他们自身不真实产生事件,但可以驱动输入源设备不断产生事件。返回的类型由UI_INPUT_EVENT_TOOL_TYPE_XXX枚举值定义。                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
55| [int64_t OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_geteventtime) | 获取UI输入事件发生的时间。单位为ns。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
56| [uint32_t OH_ArkUI_PointerEvent_GetPointerCount(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_getpointercount) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取多点触控的接触点数量。指向性事件一般是附带有事件发生位置信息的事件,如触摸事件,用户操作时,可以感知事件在什么位置发生。而非指向性事件,如按键事件,一般没有位置信息,没有触点的说法,所以该接口对按键事件无效。对于触摸事件,该接口多用于处理多指触控,判断用户有几根手指在操作当前控件。而对于鼠标和轴事件,可认为触点只有1个,该接口永远返回1。                                                                                                                                                                                                                                                                                                                                                                                  |
57| [int32_t OH_ArkUI_PointerEvent_GetPointerId(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getpointerid) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取多点触控的接触点标识。返回事件发生时,事件触点的唯一标识符,用于区分同类输入设备的多点触控信息。其数值没有除标识触点外的其他含义。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
58| [int32_t OH_ArkUI_PointerEvent_GetChangedPointerId(const ArkUI_UIInputEvent* event, uint32_t* pointerIndex)](#oh_arkui_pointerevent_getchangedpointerid) | 获取当前触摸事件触发的id。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
59| [float OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_getx) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前组件左上角的X坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
60| [float OH_ArkUI_PointerEvent_GetXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getxbyindex) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前组件左上角的X坐标。对于鼠标和轴事件,当给定的索引大于0时,返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
61| [float OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_gety) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前组件左上角的Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
62| [float OH_ArkUI_PointerEvent_GetYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getybyindex) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前组件左上角的Y坐标。对于鼠标和轴事件,当给定的索引大于0时,返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
63| [float OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_getwindowx) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前应用窗口左上角的X坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
64| [float OH_ArkUI_PointerEvent_GetWindowXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getwindowxbyindex) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前应用窗口左上角的X坐标。对于鼠标和轴事件,当给定的索引大于0时,总是返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
65| [float OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_getwindowy) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前应用窗口左上角的Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
66| [float OH_ArkUI_PointerEvent_GetWindowYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getwindowybyindex) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前应用窗口左上角的Y坐标。对于鼠标和轴事件,当给定的索引大于0时,总是返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
67| [float OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_getdisplayx) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前屏幕左上角的X坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
68| [float OH_ArkUI_PointerEvent_GetDisplayXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getdisplayxbyindex) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前屏幕左上角的X坐标。对于鼠标和轴事件,当给定的索引大于0时,总是返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
69| [float OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_getdisplayy) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前屏幕左上角的Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
70| [float OH_ArkUI_PointerEvent_GetDisplayYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getdisplayybyindex) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前屏幕左上角的Y坐标。对于鼠标和轴事件,当给定的索引大于0时,总是返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
71| [float OH_ArkUI_PointerEvent_GetGlobalDisplayX(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_getglobaldisplayx) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于全局显示的X坐标。只能从pointer-likely事件中获取位置信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
72| [float OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getglobaldisplayxbyindex) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于全局显示的X坐标。只能从指针事件中获取位置信息,对于鼠标和轴事件,当给定的pointerIndex大于0时,始终返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
73| [float OH_ArkUI_PointerEvent_GetGlobalDisplayY(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_getglobaldisplayy) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于全局显示的Y坐标。只能从pointer-likely事件中获取位置信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
74| [float OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getglobaldisplayybyindex) | 从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于全局显示的Y坐标。只能从指针事件中获取位置信息,对于鼠标和轴事件,当给定的pointerIndex大于0时,始终返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
75| [float OH_ArkUI_PointerEvent_GetPressure(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getpressure) | 从带有指向性的输入事件(如触摸事件)中获取触屏压力。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
76| [float OH_ArkUI_PointerEvent_GetTiltX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_gettiltx) | 从指向性输入事件(如触摸事件)中获取相对YZ平面的角度,取值的范围[-90, 90],其中正值是向右倾斜。仅适用于支持倾角上报的触控笔操作产生的触控事件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
77| [float OH_ArkUI_PointerEvent_GetTiltY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_gettilty) | 从指向性输入事件(如触摸事件)中获取相对XZ平面的角度,取值的范围[-90, 90],其中正值是向右倾斜。仅适用于支持倾角上报的触控笔操作产生的触控事件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
78| [int32_t OH_ArkUI_PointerEvent_GetRollAngle(const ArkUI_UIInputEvent* event, double* rollAngle)](#oh_arkui_pointerevent_getrollangle) | 获取触控笔绕Z轴旋转的角度。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
79| [float OH_ArkUI_PointerEvent_GetTouchAreaWidth(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_gettouchareawidth) | 从指向性输入事件(如触摸事件)中获取触屏区域的宽度。仅适用于手指操作产生的触控事件,这通常是一个圆形区域的半径。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
80| [float OH_ArkUI_PointerEvent_GetTouchAreaHeight(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_gettouchareaheight) | 从指向性输入事件(如触摸事件)中获取触屏区域的高度。仅适用于手指操作产生的触控事件,这通常是一个圆形区域的半径。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
81| [int32_t OH_ArkUI_PointerEvent_GetInteractionHand(const ArkUI_UIInputEvent *event, ArkUI_InteractionHand *hand)](#oh_arkui_pointerevent_getinteractionhand) | 获取当前触摸事件是左手点击触发还是右手点击触发。仅在部分触控产品上有效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
82| [int32_t OH_ArkUI_PointerEvent_GetInteractionHandByIndex(const ArkUI_UIInputEvent *event, int32_t pointerIndex, ArkUI_InteractionHand *hand)](#oh_arkui_pointerevent_getinteractionhandbyindex) | 获取当前触摸事件是左手点击触发还是右手点击触发。仅在部分触控产品上有效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
83| [uint32_t OH_ArkUI_PointerEvent_GetHistorySize(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_gethistorysize) | 从指向性输入事件(如触摸事件)中获取历史事件数量。历史事件为此次事件与上一次事件之间发生的原始事件,仅适用于move事件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
84| [int64_t OH_ArkUI_PointerEvent_GetHistoryEventTime(const ArkUI_UIInputEvent* event, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistoryeventtime) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取历史事件发生的时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
85| [uint32_t OH_ArkUI_PointerEvent_GetHistoryPointerCount(const ArkUI_UIInputEvent* event, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorypointercount) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中多点触控的接触点数量。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
86| [int32_t OH_ArkUI_PointerEvent_GetHistoryPointerId(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorypointerid) | 从指向性输入事件(如触摸事件)的历史点中获取多点触控的接触点标识。返回事件发生时,事件触点的唯一标识符,用于区分同类输入设备的多点触控信息。其数值没有除标识触点外的其他含义。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
87| [float OH_ArkUI_PointerEvent_GetHistoryX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistoryx) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前组件左上角的X坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
88| [float OH_ArkUI_PointerEvent_GetHistoryY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistoryy) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前组件左上角的Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
89| [float OH_ArkUI_PointerEvent_GetHistoryWindowX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorywindowx) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前应用窗口左上角的X坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
90| [float OH_ArkUI_PointerEvent_GetHistoryWindowY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorywindowy) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前应用窗口左上角的Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
91| [float OH_ArkUI_PointerEvent_GetHistoryDisplayX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorydisplayx) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前屏幕左上角的X坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
92| [float OH_ArkUI_PointerEvent_GetHistoryDisplayY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorydisplayy) | 从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前屏幕左上角的Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
93| [float OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistoryglobaldisplayx) | 从给定指针索引和历史记录索引的输入事件(如触摸事件、鼠标事件、轴事件)中获取历史事件中相对于全局显示的特定触摸点的X坐标。只能从指针事件中获取位置信息,对于鼠标和轴事件,当给定的pointerIndex大于0时,始终返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
94| [float OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistoryglobaldisplayy) | 从给定指针索引和历史记录索引的输入事件(如触摸事件、鼠标事件、轴事件)中获取历史事件中相对于全局显示的特定触摸点的Y坐标。只能从指针事件中获取位置信息,对于鼠标和轴事件,当给定的pointerIndex大于0时,始终返回默认值0.0f。                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
95| [float OH_ArkUI_PointerEvent_GetHistoryPressure(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorypressure) | 从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的触屏压力。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
96| [float OH_ArkUI_PointerEvent_GetHistoryTiltX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorytiltx) | 从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的相对YZ平面的角度,取值的范围[-90, 90],其中正值是向右倾斜。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
97| [float OH_ArkUI_PointerEvent_GetHistoryTiltY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorytilty) | 从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的相对XZ平面的角度,值的范围[-90, 90],其中正值是向下倾斜。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
98| [float OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorytouchareawidth) | 从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的触屏区域的宽度。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
99| [float OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)](#oh_arkui_pointerevent_gethistorytouchareaheight) | 从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的触屏区域的高度。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
100| [double OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent* event)](#oh_arkui_axisevent_getverticalaxisvalue) | 获取当前轴事件的垂直滚动轴的值。通常由鼠标滚轮,或用户在触控板上双指竖向滑动产生。当通过鼠标滚动触发时:1.上报的数值单位为角度,为单次滚动角度增量,非滚动总量;2.上报的数值已与用户配置的放大系数[OH_ArkUI_AxisEvent_GetScrollStep](capi-ui-input-event-h.md#oh_arkui_axisevent_getscrollstep)叠加运算;3.数值的正负代表方向,向前滚动鼠标滚轮时上报数值为正数,向后滚动鼠标滚轮时上报数值为负数;当通过触控板双指竖向滑动时:1.上报的数值单位为PX,为单次滚动增量,非滚动总量;2.上报的数值不受用户配置的放大系数[OH_ArkUI_AxisEvent_GetScrollStep](capi-ui-input-event-h.md#oh_arkui_axisevent_getscrollstep)影响;3.数值的正负代表方向,双指从上往下滑动时上报数值为正数,双指从下往上滑动时上报数值为负数;4.方向会受系统设置中"自然滚动"配置的影响。通常情况下,垂直滚动轴事件只能驱动竖向的滑动手势响应,但当鼠标指针下命中的可滑动手势里,如果可响应的方向都是一致的,那么垂直滚动轴事件可以驱动这些滑动手势得到响应,即使这些手势所定义的方向是横向的。 |
101| [double OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent* event)](#oh_arkui_axisevent_gethorizontalaxisvalue) | 获取当前轴事件的水平滚动轴的值,通过在触控板上双指横向滑动产生。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
102| [double OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent* event)](#oh_arkui_axisevent_getpinchaxisscalevalue) | 获取当前轴事件的捏合轴缩放的值。通过触控板双指缩放/捏合操作产生。上报的scale数值,为相对于初始状态时的当前scale值。初始状态为系统识别到用户通过触控板发生了捏合操作时的两指位置状态,此时的scale数值为1.0。在手指抬起前的本次捏合操作过程中,所上报的scale数值均将初始状态作为参考系,从初始状态往中心捏合,则上报的scale会从1.0逐步往0.0缩小;当从初始化状态往外扩大双指距离时,会从1.0逐步变大。                                                                                                                                                                                                                                                                                                                                                                   |
103| [int32_t OH_ArkUI_AxisEvent_GetAxisAction(const ArkUI_UIInputEvent* event)](#oh_arkui_axisevent_getaxisaction) | 获取当前轴事件的操作类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
104| [int32_t OH_ArkUI_PointerEvent_SetInterceptHitTestMode(const ArkUI_UIInputEvent* event, HitTestMode mode)](#oh_arkui_pointerevent_setintercepthittestmode) | 配置HitTest模式。仅适用于接收基础事件的场景,如使用NODE_ON_TOUCH接收touch事件场景。对于通过[OH_ArkUI_GestureEvent_GetRawInputEvent](capi-native-gesture-h.md#oh_arkui_gestureevent_getrawinputevent)接口从一个手势事件中获取到的ArkUI_UIInputEvent对象,无法使用该接口。                                                                                                                                                                                                                                                                                                                                                                         |
105| [int32_t OH_ArkUI_MouseEvent_GetMouseButton(const ArkUI_UIInputEvent* event)](#oh_arkui_mouseevent_getmousebutton) | 获取鼠标事件的按键类型的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
106| [int32_t OH_ArkUI_MouseEvent_GetMouseAction(const ArkUI_UIInputEvent* event)](#oh_arkui_mouseevent_getmouseaction) | 获取鼠标事件的鼠标动作类型的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
107| [int32_t OH_ArkUI_PointerEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)](#oh_arkui_pointerevent_setstoppropagation) | 设置是否阻止事件冒泡。仅适用于接收基础事件的场景,如使用NODE_ON_TOUCH接收touch事件场景。对于通过 [OH_ArkUI_GestureEvent_GetRawInputEvent](capi-native-gesture-h.md#oh_arkui_gestureevent_getrawinputevent)接口从一个手势事件中获取到的ArkUI_UIInputEvent对象,无法使用该接口。                                                                                                                                                                                                                                                                                                                                                                                                                                    |
108| [int32_t OH_ArkUI_UIInputEvent_GetDeviceId(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_getdeviceid) | 获取当前按键的输入设备ID。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
109| [int32_t OH_ArkUI_UIInputEvent_GetPressedKeys(const ArkUI_UIInputEvent* event, int32_t* pressedKeyCodes, int32_t* length)](#oh_arkui_uiinputevent_getpressedkeys) | 获取所有按下的按键,当前只支持按键事件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
110| [double OH_ArkUI_FocusAxisEvent_GetAxisValue(const ArkUI_UIInputEvent* event, int32_t axis)](#oh_arkui_focusaxisevent_getaxisvalue) | 获取焦点轴事件的轴值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
111| [int32_t OH_ArkUI_FocusAxisEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)](#oh_arkui_focusaxisevent_setstoppropagation) | 设置是否阻止焦点轴事件冒泡。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
112| [int32_t OH_ArkUI_UIInputEvent_GetModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)](#oh_arkui_uiinputevent_getmodifierkeystates) | 获取UI输入事件的修饰键状态。该接口会通过keys传出当前事件发生时所有修饰键的状态,你可以通过与[ArkUI_ModifierKeyName](capi-ui-input-event-h.md#arkui_modifierkeyname)中定义的修饰键类型进行位计算操作获取哪些键处于按下状态。                                                                                                                                                                                                                                                                                                                                                                                                                                   |
113| [int32_t OH_ArkUI_AxisEvent_SetPropagation(const ArkUI_UIInputEvent* event, bool propagation)](#oh_arkui_axisevent_setpropagation) | 设置是否使能轴事件冒泡。默认不会进行冒泡传递,仅发送给第一个可响应轴事件的控件。可在接收到轴事件时,主动使能冒泡传递,以便当前事件可以继续传递给响应链上的下一个可响应轴事件的祖先组件处理。不支持对从手势事件中获取到的轴事件进行设置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
114| [int32_t OH_ArkUI_AxisEvent_GetScrollStep(const ArkUI_UIInputEvent* event)](#oh_arkui_axisevent_getscrollstep) | 获取滚动轴事件的滚动步长系数,适用于鼠标滚轮产生的轴事件。这个值可以告诉你用户所配置的滚动放大系数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
115| [float OH_ArkUI_UIInputEvent_GetEventTargetWidth(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_geteventtargetwidth) | 获取事件命中的组件的宽度。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
116| [float OH_ArkUI_UIInputEvent_GetEventTargetHeight(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_geteventtargetheight) | 获取事件命中的组件的高度。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
117| [float OH_ArkUI_UIInputEvent_GetEventTargetPositionX(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_geteventtargetpositionx) | 获取事件命中的组件的X坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
118| [float OH_ArkUI_UIInputEvent_GetEventTargetPositionY(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_geteventtargetpositiony) | 获取事件命中的组件的Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
119| [float OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_geteventtargetglobalpositionx) | 获取事件命中的组件的全局X坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
120| [float OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_geteventtargetglobalpositiony) | 获取事件命中的组件的全局Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
121| [int64_t OH_ArkUI_PointerEvent_GetPressedTimeByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)](#oh_arkui_pointerevent_getpressedtimebyindex) | 获取指定触点的按下时间。仅对触摸事件有效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
122| [float OH_ArkUI_MouseEvent_GetRawDeltaX(const ArkUI_UIInputEvent* event)](#oh_arkui_mouseevent_getrawdeltax) | 获取X轴相对于前一个上报的鼠标事件的鼠标指针位置的偏移量。当鼠标指针位于屏幕边缘时,该值可能小于两次上报的X坐标的差。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
123| [float OH_ArkUI_MouseEvent_GetRawDeltaY(const ArkUI_UIInputEvent* event)](#oh_arkui_mouseevent_getrawdeltay) | 获取相对于前一个上报的鼠标事件的鼠标指针位置的Y轴偏移量。当鼠标指针位于屏幕边缘时,该值可能小于两次上报的Y坐标的差。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
124| [int32_t OH_ArkUI_MouseEvent_GetPressedButtons(const ArkUI_UIInputEvent* event, int32_t* pressedButtons, int32_t* length)](#oh_arkui_mouseevent_getpressedbuttons) | 从鼠标事件中获取按下的按钮。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
125| [int32_t OH_ArkUI_UIInputEvent_GetTargetDisplayId(const ArkUI_UIInputEvent* event)](#oh_arkui_uiinputevent_gettargetdisplayid) | 获取发生UI输入事件的屏幕ID。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
126| [bool OH_ArkUI_HoverEvent_IsHovered(const ArkUI_UIInputEvent* event)](#oh_arkui_hoverevent_ishovered) | 获取鼠标是否悬浮在当前组件上                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
127| [int32_t OH_ArkUI_PointerEvent_CreateClonedEvent(const ArkUI_UIInputEvent* event, ArkUI_UIInputEvent** clonedEvent)](#oh_arkui_pointerevent_createclonedevent) | 基于原始事件指针创建克隆事件指针。仅对触摸事件有效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
128| [int32_t OH_ArkUI_PointerEvent_DestroyClonedEvent(const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_destroyclonedevent) | 销毁克隆事件指针。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
129| [int32_t OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(const ArkUI_UIInputEvent* event, float x, float y)](#oh_arkui_pointerevent_setclonedeventlocalposition) | 设置指向性事件相对于当前组件左上角的X坐标和Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
130| [int32_t OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(const ArkUI_UIInputEvent* event, float x, float y, int32_t pointerIndex)](#oh_arkui_pointerevent_setclonedeventlocalpositionbyindex) | 设置指向性事件特有接触点相对于当前组件左上角的X坐标和Y坐标。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
131| [int32_t OH_ArkUI_PointerEvent_SetClonedEventActionType(const ArkUI_UIInputEvent* event, int32_t actionType)](#oh_arkui_pointerevent_setclonedeventactiontype) | 设置当前带有指向性的克隆输入事件的事件类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
132| [int32_t OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(const ArkUI_UIInputEvent* event, int32_t fingerId)](#oh_arkui_pointerevent_setclonedeventchangedfingerid) | 设置当前带有指向性的克隆输入事件的触摸点ID。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
133| [int32_t OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(const ArkUI_UIInputEvent* event, int32_t fingerId, int32_t pointerIndex)](#oh_arkui_pointerevent_setclonedeventfingeridbyindex) | 设置带有指向性的克隆输入事件特定接触点的触摸点ID。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
134| [int32_t OH_ArkUI_PointerEvent_PostClonedEvent(ArkUI_NodeHandle node, const ArkUI_UIInputEvent* event)](#oh_arkui_pointerevent_postclonedevent) | 转发克隆事件到特定节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
135| [ArkUI_ErrorCode OH_ArkUI_UIInputEvent_GetLatestStatus()](#oh_arkui_uiinputevent_getlateststatus) | 调用该方法获取最近一次UIInput相关方法的执行情况。通常情况下不需要使用该方法,仅在返回值结果不确定是否异常时使用。以下是一个使用示例(对于返回的float类型,0.0并不代表错误,因此可以进一步使用OH_ArkUI_UIInputEvent_GetLatestStatus方法来确认是否发生异常)。float x = OH_ArkUI_PointerEvent_GetX(event);if (ARKUI_ERROR_CODE_NO_ERROR != OH_Arkui_UIInputEvent_GetlatestStatus()) {// errorreturn;}系统将在每次执行UIInput相关函数时主动清空上一次函数调用的状态,以确保每次通过该接口获取的均为最近一次的状态。                                                                                                                                                                                                                              |
136
137## 枚举类型说明
138
139### ArkUI_UIInputEvent_Type
140
141```
142enum ArkUI_UIInputEvent_Type
143```
144
145**描述:**
146
147
148UI输入事件类型定义。
149
150**起始版本:** 12
151
152| 枚举项 | 描述 |
153| -- | -- |
154| ARKUI_UIINPUTEVENT_TYPE_UNKNOWN = 0 | 未知。 |
155| ARKUI_UIINPUTEVENT_TYPE_TOUCH = 1 | 触摸事件。 |
156| ARKUI_UIINPUTEVENT_TYPE_AXIS = 2 | 轴事件。 |
157| ARKUI_UIINPUTEVENT_TYPE_MOUSE = 3 | 鼠标事件。|
158| ARKUI_UIINPUTEVENT_TYPE_KEY = 4 | 按键事件。<br>**起始版本:** 20 |
159
160### anonymous1
161
162```
163enum anonymous1
164```
165
166**描述:**
167
168
169定义输入事件的Action Code。
170
171**起始版本:** 12
172
173| 枚举项 | 描述 |
174| -- | -- |
175| UI_TOUCH_EVENT_ACTION_CANCEL = 0 | 触摸取消。 |
176| UI_TOUCH_EVENT_ACTION_DOWN = 1 | 触摸按下。 |
177| UI_TOUCH_EVENT_ACTION_MOVE = 2 | 触摸移动。 |
178| UI_TOUCH_EVENT_ACTION_UP = 3 | 触摸抬起。 |
179
180### anonymous2
181
182```
183enum anonymous2
184```
185
186**描述:**
187
188
189产生输入事件的工具类型定义。
190
191**起始版本:** 12
192
193| 枚举项 | 描述 |
194| -- | -- |
195| UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN = 0 | 不支持的工具类型。 |
196| UI_INPUT_EVENT_TOOL_TYPE_FINGER = 1 | 手指。 |
197| UI_INPUT_EVENT_TOOL_TYPE_PEN = 2 | 笔。 |
198| UI_INPUT_EVENT_TOOL_TYPE_MOUSE = 3 | 鼠标。 |
199| UI_INPUT_EVENT_TOOL_TYPE_TOUCHPAD = 4 | 触控板。 |
200| UI_INPUT_EVENT_TOOL_TYPE_JOYSTICK = 5 | 操纵杆。 |
201
202### anonymous3
203
204```
205enum anonymous3
206```
207
208**描述:**
209
210
211产生输入事件的来源类型定义。
212
213**起始版本:** 12
214
215| 枚举项 | 描述 |
216| -- | -- |
217| UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN = 0 | 不支持的来源类型。 |
218| UI_INPUT_EVENT_SOURCE_TYPE_MOUSE = 1 | 鼠标。 |
219| UI_INPUT_EVENT_SOURCE_TYPE_TOUCH_SCREEN = 2 | 触摸屏。 |
220
221### HitTestMode
222
223```
224enum HitTestMode
225```
226
227**描述:**
228
229
230定义触摸测试类型的枚举值。
231
232**起始版本:** 12
233
234| 枚举项 | 描述 |
235| -- | -- |
236| HTM_DEFAULT = 0 | 默认触摸测试效果。自身及子节点响应触摸测试,但阻塞兄弟节点的触摸测试,不影响祖先节点的触摸测试。 |
237| HTM_BLOCK | 自身响应触摸测试,阻塞子节点、兄弟节点和祖先节点的触摸测试。 |
238| HTM_TRANSPARENT | 自身和子节点都响应触摸测试,不会阻塞兄弟节点和祖先节点的触摸测试。 |
239| HTM_NONE | 自身不响应触摸测试,不会阻塞子节点、兄弟节点和祖先节点的触摸测试。 |
240| HTM_BLOCK_HIERARCHY | 自身和子节点响应触摸测试,阻止所有优先级较低的兄弟节点和父节点参与触摸测试。<br>**起始版本:** 20 |
241| HTM_BLOCK_DESCENDANTS | 自身不响应触摸测试,并且所有的后代(孩子,孙子等)也不响应触摸测试,不会影响祖先节点的触摸测试。<br>**起始版本:** 20 |
242
243### anonymous4
244
245```
246enum anonymous4
247```
248
249**描述:**
250
251
252定义鼠标事件的Action Code。
253
254**起始版本:** 12
255
256| 枚举项 | 描述 |
257| -- | -- |
258| UI_MOUSE_EVENT_ACTION_UNKNOWN = 0 | 无效行为。 |
259| UI_MOUSE_EVENT_ACTION_PRESS = 1 | 鼠标按键按下。 |
260| UI_MOUSE_EVENT_ACTION_RELEASE = 2 | 鼠标按键松开。 |
261| UI_MOUSE_EVENT_ACTION_MOVE = 3 | 鼠标移动。 |
262| UI_MOUSE_EVENT_ACTION_CANCEL = 13 | 鼠标按键被取消。<br>**起始版本:** 18 |
263
264### anonymous5
265
266```
267enum anonymous5
268```
269
270**描述:**
271
272
273定义鼠标事件的按键类型。
274
275**起始版本:** 12
276
277| 枚举项 | 描述 |
278| -- | -- |
279| UI_MOUSE_EVENT_BUTTON_NONE = 0 | 无按键。 |
280| UI_MOUSE_EVENT_BUTTON_LEFT = 1 | 鼠标左键。 |
281| UI_MOUSE_EVENT_BUTTON_RIGHT = 2 | 鼠标右键。 |
282| UI_MOUSE_EVENT_BUTTON_MIDDLE = 3 | 鼠标中键。 |
283| UI_MOUSE_EVENT_BUTTON_BACK = 4 | 鼠标左侧后退键。 |
284| UI_MOUSE_EVENT_BUTTON_FORWARD = 5 | 鼠标左侧前进键。 |
285
286### ArkUI_ModifierKeyName
287
288```
289enum ArkUI_ModifierKeyName
290```
291
292**描述:**
293
294
295定义modifier按键。
296
297**起始版本:** 12
298
299| 枚举项 | 描述 |
300| -- | -- |
301| ARKUI_MODIFIER_KEY_CTRL = 1 << 0 | Ctrl. |
302| ARKUI_MODIFIER_KEY_SHIFT = 1 << 1 | Shift. |
303| ARKUI_MODIFIER_KEY_ALT = 1 << 2 | Alt. |
304| ARKUI_MODIFIER_KEY_FN = 1 << 3 | Fn(仅调试使用,通常不上报Fn状态). |
305
306### anonymous6
307
308```
309enum anonymous6
310```
311
312**描述:**
313
314
315定义焦点轴事件的轴类型。
316
317**起始版本:** 15
318
319| 枚举项 | 描述 |
320| -- | -- |
321| UI_FOCUS_AXIS_EVENT_ABS_X = 0 | 游戏手柄X轴。 |
322| UI_FOCUS_AXIS_EVENT_ABS_Y = 1 | 游戏手柄Y轴。 |
323| UI_FOCUS_AXIS_EVENT_ABS_Z = 2 | 游戏手柄Z轴。 |
324| UI_FOCUS_AXIS_EVENT_ABS_RZ = 3 | 游戏手柄RZ轴。 |
325| UI_FOCUS_AXIS_EVENT_ABS_GAS = 4 | 游戏手柄GAS轴。 |
326| UI_FOCUS_AXIS_EVENT_ABS_BRAKE = 5 | 游戏手柄BRAKE轴。 |
327| UI_FOCUS_AXIS_EVENT_ABS_HAT0X = 6 | 游戏手柄HAT0X轴。 |
328| UI_FOCUS_AXIS_EVENT_ABS_HAT0Y = 7 | 游戏手柄HAT0Y轴。 |
329
330### ArkUI_InteractionHand
331
332```
333enum ArkUI_InteractionHand
334```
335
336**描述:**
337
338
339定义触摸事件是左手还是右手。
340
341**起始版本:** 15
342
343| 枚举项 | 描述 |
344| -- | -- |
345| ARKUI_EVENT_HAND_NONE = 0 | 未知。 |
346| ARKUI_EVENT_HAND_LEFT = 1 | 左手。 |
347| ARKUI_EVENT_HAND_RIGHT = 2 | 右手。 |
348
349### anonymous7
350
351```
352enum anonymous7
353```
354
355**描述:**
356
357
358定义轴事件的操作类型。
359
360**起始版本:** 15
361
362| 枚举项 | 描述 |
363| -- | -- |
364| UI_AXIS_EVENT_ACTION_NONE = 0 | 轴事件异常。 |
365| UI_AXIS_EVENT_ACTION_BEGIN = 1 | 轴事件开始。 |
366| UI_AXIS_EVENT_ACTION_UPDATE = 2 | 轴事件更新。 |
367| UI_AXIS_EVENT_ACTION_END = 3 | 轴事件结束。 |
368| UI_AXIS_EVENT_ACTION_CANCEL = 4 | 轴事件取消。 |
369
370
371## 函数说明
372
373### OH_ArkUI_UIInputEvent_GetType()
374
375```
376int32_t OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent* event)
377```
378
379**描述:**
380
381
382获取UI输入事件的类型。在访问一个ArkUI_UIInputEvent指针对象之前,推荐使用该方法判断该输入事件的类型,该接口会返回[ArkUI_UIInputEvent_Type](capi-ui-input-event-h.md#arkui_uiinputevent_type)枚举中的一种。比如,当事件是一个触控类型时,由于触控类型是指向性事件,那么使用OH_ArkUI_UIInputEvent_GetXXX及OH_ArkUI_PointerEvent_GetXXX系列接口,均可以正常访问;而如果使用OH_ArkUI_KeyEvent_GetXXX相关接口去访问它,则会有无法预期的结果。对于还未支持的事件类型,接口返回默认值0。
383
384**起始版本:** 12
385
386
387**参数:**
388
389| 参数项 | 描述 |
390| -- | -- |
391| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
392
393**返回:**
394
395| 类型 | 说明 |
396| -- | -- |
397| int32_t | 返回当前UI输入事件的类型,如果参数异常则返回0。 |
398
399### OH_ArkUI_UIInputEvent_GetAction()
400
401```
402int32_t OH_ArkUI_UIInputEvent_GetAction(const ArkUI_UIInputEvent* event)
403```
404
405**描述:**
406
407
408获取输入事件的action类型。action类型为基础事件在不同阶段的类型定义,通常代表了事件的特点,并表征事件的开始与结束,如touch down, touch up。触控事件的action类型为[UI_TOUCH_EVENT_ACTION_XXX](#anonymous1),鼠标事件的action类型为[UI_MOUSE_EVENT_ACTION_XXX](#anonymous4)。轴事件的action类型获取请使用[OH_ArkUI_AxisEvent_GetAxisAction](#oh_arkui_axisevent_getaxisaction),返回值类型为[UI_AXIS_EVENT_ACTION_XXX](#anonymous7),按键事件的action类型获取请使用[OH_ArkUI_KeyEvent_GetType](./capi-native-key-event-h.md#oh_arkui_keyevent_gettype)接口。
409
410**起始版本:** 12
411
412
413**参数:**
414
415| 参数项 | 描述 |
416| -- | -- |
417| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
418
419**返回:**
420
421| 类型 | 说明 |
422| -- | -- |
423| int32_t | 返回当前UI输入事件的操作类型,如果参数异常则返回-1。 |
424
425### OH_ArkUI_UIInputEvent_GetSourceType()
426
427```
428int32_t OH_ArkUI_UIInputEvent_GetSourceType(const ArkUI_UIInputEvent* event)
429```
430
431**描述:**
432
433
434获取UI输入事件的触发源类型。输入源为产生输入事件的真实物理设备,如触摸屏,鼠标等,由UI_INPUT_EVENT_SOURCE_TYPE_XXX定义,而输入工具为操作输入源设备来产生事件的工具,如手指、触控笔。在某些情况下两者可能容易发生混淆,比如当用户在操作鼠标时,鼠标既是输入源,也是输入工具。对于按键事件,并不支持获取输入源类型,返回unkown。
435
436**起始版本:** 12
437
438
439**参数:**
440
441| 参数项 | 描述 |
442| -- | -- |
443| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
444
445**返回:**
446
447| 类型 | 说明 |
448| -- | -- |
449| int32_t | 返回产生当前UI输入事件的来源类型。 |
450
451### OH_ArkUI_UIInputEvent_GetToolType()
452
453```
454int32_t OH_ArkUI_UIInputEvent_GetToolType(const ArkUI_UIInputEvent* event)
455```
456
457**描述:**
458
459
460获取UI输入事件的工具类型。输入工具为操作输入源设备来产生事件的操作方,如手指、触控笔,他们自身不真实产生事件,但可以驱动输入源设备不断产生事件。返回的类型由UI_INPUT_EVENT_TOOL_TYPE_XXX枚举值定义。对于按键事件,并不支持获取输入工具类型,返回unkown。
461
462**起始版本:** 12
463
464
465**参数:**
466
467| 参数项 | 描述 |
468| -- | -- |
469| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
470
471**返回:**
472
473| 类型 | 说明 |
474| -- | -- |
475| int32_t | 返回产生当前UI输入事件的工具类型。 |
476
477### OH_ArkUI_UIInputEvent_GetEventTime()
478
479```
480int64_t OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent* event)
481```
482
483**描述:**
484
485
486获取UI输入事件发生的时间。单位为ns。
487
488**起始版本:** 12
489
490
491**参数:**
492
493| 参数项 | 描述 |
494| -- | -- |
495| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
496
497**返回:**
498
499| 类型 | 说明 |
500| -- | -- |
501| int64_t | 返回UI输入事件发生的时间,如果参数异常则返回0。 |
502
503### OH_ArkUI_PointerEvent_GetPointerCount()
504
505```
506uint32_t OH_ArkUI_PointerEvent_GetPointerCount(const ArkUI_UIInputEvent* event)
507```
508
509**描述:**
510
511
512从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取多点触控的接触点数量。指向性事件一般是附带有事件发生位置信息的事件,如触摸事件,用户操作时,可以感知事件在什么位置发生。而非指向性事件,如按键事件,一般没有位置信息,没有触点的说法,所以该接口对按键事件无效。对于触摸事件,该接口多用于处理多指触控,判断用户有几根手指在操作当前控件。而对于鼠标和轴事件,可认为触点只有1个,该接口永远返回1。
513
514**起始版本:** 12
515
516
517**参数:**
518
519| 参数项 | 描述 |
520| -- | -- |
521| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
522
523**返回:**
524
525| 类型 | 说明 |
526| -- | -- |
527| uint32_t | 返回当前带有指向性的输入事件的接触点数量。 |
528
529### OH_ArkUI_PointerEvent_GetPointerId()
530
531```
532int32_t OH_ArkUI_PointerEvent_GetPointerId(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
533```
534
535**描述:**
536
537
538从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取多点触控的接触点标识。返回事件发生时,事件触点的唯一标识符,用于区分同类输入设备的多点触控信息。其数值没有除标识触点外的其他含义。
539
540**起始版本:** 12
541
542
543**参数:**
544
545| 参数项 | 描述 |
546| -- | -- |
547| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
548| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
549
550**返回:**
551
552| 类型 | 说明 |
553| -- | -- |
554| int32_t | 返回特定接触点标识。 |
555
556### OH_ArkUI_PointerEvent_GetChangedPointerId()
557
558```
559int32_t OH_ArkUI_PointerEvent_GetChangedPointerId(const ArkUI_UIInputEvent* event, uint32_t* pointerIndex)
560```
561
562**描述:**
563
564
565获取触发当前事件的对应的手指id。
566
567**起始版本:** 15
568
569
570**参数:**
571
572| 参数项 | 描述 |
573| -- | -- |
574| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
575| uint32_t* pointerIndex | 表示多点触控数据列表中的序号。 |
576
577**返回:**
578
579| 类型 | 说明 |
580| -- | -- |
581| int32_t | 错误码。<br>         [ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode) 成功。<br>         [ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode) 函数参数异常。 |
582
583### OH_ArkUI_PointerEvent_GetX()
584
585```
586float OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent* event)
587```
588
589**描述:**
590
591
592从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前组件左上角的X坐标。
593
594**起始版本:** 12
595
596
597**参数:**
598
599| 参数项 | 描述 |
600| -- | -- |
601| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
602
603**返回:**
604
605| 类型 | 说明 |
606| -- | -- |
607| float | 返回当前带有指向性的输入事件相对于当前组件左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
608
609### OH_ArkUI_PointerEvent_GetXByIndex()
610
611```
612float OH_ArkUI_PointerEvent_GetXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
613```
614
615**描述:**
616
617
618从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前组件左上角的X坐标。对于鼠标和轴事件,当给定的索引大于0时,返回默认值0.0f。
619
620**起始版本:** 12
621
622
623**参数:**
624
625| 参数项 | 描述 |
626| -- | -- |
627| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
628| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
629
630**返回:**
631
632| 类型 | 说明 |
633| -- | -- |
634| float | 返回当前带有指向性的输入事件相对于当前组件左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
635
636### OH_ArkUI_PointerEvent_GetY()
637
638```
639float OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent* event)
640```
641
642**描述:**
643
644
645从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前组件左上角的Y坐标。
646
647**起始版本:** 12
648
649
650**参数:**
651
652| 参数项 | 描述 |
653| -- | -- |
654| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
655
656**返回:**
657
658| 类型 | 说明 |
659| -- | -- |
660| float | 返回当前带有指向性的输入事件相对于当前组件左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
661
662### OH_ArkUI_PointerEvent_GetYByIndex()
663
664```
665float OH_ArkUI_PointerEvent_GetYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
666```
667
668**描述:**
669
670
671从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前组件左上角的Y坐标。对于鼠标和轴事件,当给定的索引大于0时,返回默认值0.0f。
672
673**起始版本:** 12
674
675
676**参数:**
677
678| 参数项 | 描述 |
679| -- | -- |
680| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
681| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
682
683**返回:**
684
685| 类型 | 说明 |
686| -- | -- |
687| float | 返回当前带有指向性的输入事件相对于当前组件左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
688
689### OH_ArkUI_PointerEvent_GetWindowX()
690
691```
692float OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent* event)
693```
694
695**描述:**
696
697
698从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前应用窗口左上角的X坐标。
699
700**起始版本:** 12
701
702
703**参数:**
704
705| 参数项 | 描述 |
706| -- | -- |
707| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
708
709**返回:**
710
711| 类型 | 说明 |
712| -- | -- |
713| float | 返回当前带有指向性的输入事件相对于当前应用窗口左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
714
715### OH_ArkUI_PointerEvent_GetWindowXByIndex()
716
717```
718float OH_ArkUI_PointerEvent_GetWindowXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
719```
720
721**描述:**
722
723
724从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前应用窗口左上角的X坐标。对于鼠标和轴事件,当给定的索引大于0时,总是返回默认值0.0f。
725
726**起始版本:** 12
727
728
729**参数:**
730
731| 参数项 | 描述 |
732| -- | -- |
733| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
734| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
735
736**返回:**
737
738| 类型 | 说明 |
739| -- | -- |
740| float | 返回当前带有指向性的输入事件相对于当前应用窗口左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
741
742### OH_ArkUI_PointerEvent_GetWindowY()
743
744```
745float OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent* event)
746```
747
748**描述:**
749
750
751从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前应用窗口左上角的Y坐标。
752
753**起始版本:** 12
754
755
756**参数:**
757
758| 参数项 | 描述 |
759| -- | -- |
760| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
761
762**返回:**
763
764| 类型 | 说明 |
765| -- | -- |
766| float | 返回当前带有指向性的输入事件相对于当前应用窗口左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
767
768### OH_ArkUI_PointerEvent_GetWindowYByIndex()
769
770```
771float OH_ArkUI_PointerEvent_GetWindowYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
772```
773
774**描述:**
775
776
777从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前应用窗口左上角的Y坐标。对于鼠标和轴事件,当给定的索引大于0时,总是返回默认值0.0f。
778
779**起始版本:** 12
780
781
782**参数:**
783
784| 参数项 | 描述 |
785| -- | -- |
786| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
787| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
788
789**返回:**
790
791| 类型 | 说明 |
792| -- | -- |
793| float | 返回当前带有指向性的输入事件相对于当前应用窗口左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
794
795### OH_ArkUI_PointerEvent_GetDisplayX()
796
797```
798float OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent* event)
799```
800
801**描述:**
802
803
804从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前屏幕左上角的X坐标。
805
806**起始版本:** 12
807
808
809**参数:**
810
811| 参数项 | 描述 |
812| -- | -- |
813| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
814
815**返回:**
816
817| 类型 | 说明 |
818| -- | -- |
819| float | 返回当前带有指向性的输入事件相对于当前屏幕左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
820
821### OH_ArkUI_PointerEvent_GetDisplayXByIndex()
822
823```
824float OH_ArkUI_PointerEvent_GetDisplayXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
825```
826
827**描述:**
828
829
830从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前屏幕左上角的X坐标。对于鼠标和轴事件,当给定的索引大于0时,总是返回默认值0.0f。
831
832**起始版本:** 12
833
834
835**参数:**
836
837| 参数项 | 描述 |
838| -- | -- |
839| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
840| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
841
842**返回:**
843
844| 类型 | 说明 |
845| -- | -- |
846| float | 返回当前带有指向性的输入事件相对于当前屏幕左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
847
848### OH_ArkUI_PointerEvent_GetDisplayY()
849
850```
851float OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent* event)
852```
853
854**描述:**
855
856
857从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于当前屏幕左上角的Y坐标。
858
859**起始版本:** 12
860
861
862**参数:**
863
864| 参数项 | 描述 |
865| -- | -- |
866| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
867
868**返回:**
869
870| 类型 | 说明 |
871| -- | -- |
872| float | 返回当前带有指向性的输入事件相对于当前屏幕左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
873
874### OH_ArkUI_PointerEvent_GetDisplayYByIndex()
875
876```
877float OH_ArkUI_PointerEvent_GetDisplayYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
878```
879
880**描述:**
881
882
883从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取特定接触点相对于当前屏幕左上角的Y坐标。对于鼠标和轴事件,当给定的索引大于0时,总是返回默认值0.0f。
884
885**起始版本:** 12
886
887
888**参数:**
889
890| 参数项 | 描述 |
891| -- | -- |
892| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
893| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
894
895**返回:**
896
897| 类型 | 说明 |
898| -- | -- |
899| float | 返回当前带有指向性的输入事件相对于当前屏幕左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
900
901### OH_ArkUI_PointerEvent_GetGlobalDisplayX()
902
903```
904float OH_ArkUI_PointerEvent_GetGlobalDisplayX(const ArkUI_UIInputEvent* event)
905```
906
907**描述:**
908
909
910从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于全局显示的X坐标。只能从pointer-likely事件中获取位置信息。
911
912**起始版本:** 20
913
914
915**参数:**
916
917| 参数项 | 描述 |
918| -- | -- |
919| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
920
921**返回:**
922
923| 类型 | 说明 |
924| -- | -- |
925| float | float 返回相对于全局显示的X坐标,单位为px。如果发生任何参数错误,例如传递的一个事件没有位置信息,则返回0。 |
926
927### OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex()
928
929```
930float OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
931```
932
933**描述:**
934
935
936从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于全局显示的X坐标。只能从指针事件中获取位置信息,对于鼠标和轴事件,当给定的pointerIndex大于0时,始终返回默认值0.0f。
937
938**起始版本:** 20
939
940
941**参数:**
942
943| 参数项 | 描述                                                                                                                  |
944| -- |---------------------------------------------------------------------------------------------------------------------|
945| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。                                                                                                    |
946| uint32_t pointerIndex | 表示多点触控数据列表中目标触控点的索引。有效值范围[0, [OH_ArkUI_PointerEvent_GetPointerCount()](#oh_arkui_pointerevent_getpointercount) - 1] |
947
948**返回:**
949
950| 类型 | 说明 |
951| -- | -- |
952| float | float 返回相对于全局显示的X坐标,单位为px。如果发生任何参数错误,则返回0.0f。 |
953
954### OH_ArkUI_PointerEvent_GetGlobalDisplayY()
955
956```
957float OH_ArkUI_PointerEvent_GetGlobalDisplayY(const ArkUI_UIInputEvent* event)
958```
959
960**描述:**
961
962
963从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于全局显示的Y坐标。只能从pointer-likely事件中获取位置信息。
964
965**起始版本:** 20
966
967
968**参数:**
969
970| 参数项 | 描述 |
971| -- | -- |
972| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
973
974**返回:**
975
976| 类型 | 说明 |
977| -- | -- |
978| float | float 返回相对于全局显示的Y坐标,单位为px。如果发生任何参数错误,例如传递的一个事件没有位置信息,则返回0。 |
979
980### OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex()
981
982```
983float OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
984```
985
986**描述:**
987
988
989从指向性输入事件(如触摸事件、鼠标事件、轴事件)中获取相对于全局显示的Y坐标。只能从指针事件中获取位置信息,对于鼠标和轴事件,当给定的pointerIndex大于0时,始终返回默认值0.0f。
990
991**起始版本:** 20
992
993
994**参数:**
995
996| 参数项 | 描述                                                                                  |
997| -- |-------------------------------------------------------------------------------------|
998| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。                                                                    |
999| uint32_t pointerIndex | 表示多点触控数据列表中目标触控点的索引。有效值范围[0, [OH_ArkUI_PointerEvent_GetPointerCount()](#oh_arkui_pointerevent_getpointercount) - 1] |
1000
1001**返回:**
1002
1003| 类型 | 说明 |
1004| -- | -- |
1005| float | float 返回相对于全局显示的Y坐标,单位为px。如果发生任何参数错误,则返回0.0f。 |
1006
1007### OH_ArkUI_PointerEvent_GetPressure()
1008
1009```
1010float OH_ArkUI_PointerEvent_GetPressure(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1011```
1012
1013**描述:**
1014
1015
1016从带有指向性的输入事件(如触摸事件)中获取触屏压力。
1017
1018**起始版本:** 12
1019
1020
1021**参数:**
1022
1023| 参数项 | 描述 |
1024| -- | -- |
1025| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1026| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1027
1028**返回:**
1029
1030| 类型 | 说明 |
1031| -- | -- |
1032| float | 返回当前带有指向性的输入事件产生的触屏压力,如果参数异常则返回0.0f。 |
1033
1034### OH_ArkUI_PointerEvent_GetTiltX()
1035
1036```
1037float OH_ArkUI_PointerEvent_GetTiltX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1038```
1039
1040**描述:**
1041
1042
1043从指向性输入事件(如触摸事件)中获取相对YZ平面的角度,取值的范围[-90, 90],其中正值是向右倾斜。仅适用于支持倾角上报的触控笔操作产生的触控事件。
1044
1045**起始版本:** 12
1046
1047
1048**参数:**
1049
1050| 参数项 | 描述 |
1051| -- | -- |
1052| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1053| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1054
1055**返回:**
1056
1057| 类型 | 说明 |
1058| -- | -- |
1059| float | 返回当前带有指向性的输入事件中相对YZ平面的角度。 |
1060
1061### OH_ArkUI_PointerEvent_GetTiltY()
1062
1063```
1064float OH_ArkUI_PointerEvent_GetTiltY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1065```
1066
1067**描述:**
1068
1069
1070从指向性输入事件(如触摸事件)中获取相对XZ平面的角度,取值的范围[-90, 90],其中正值是向右倾斜。仅适用于支持倾角上报的触控笔操作产生的触控事件。
1071
1072**起始版本:** 12
1073
1074
1075**参数:**
1076
1077| 参数项 | 描述 |
1078| -- | -- |
1079| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1080| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1081
1082**返回:**
1083
1084| 类型 | 说明 |
1085| -- | -- |
1086| float | 返回当前带有指向性的输入事件中相对XZ平面的角度。 |
1087
1088### OH_ArkUI_PointerEvent_GetRollAngle()
1089
1090```
1091int32_t OH_ArkUI_PointerEvent_GetRollAngle(const ArkUI_UIInputEvent* event, double* rollAngle)
1092```
1093
1094**描述:**
1095
1096
1097获取触控笔绕Z轴旋转的角度。
1098
1099**起始版本:** 17
1100
1101
1102**参数:**
1103
1104| 参数项 | 描述 |
1105| -- | -- |
1106| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 指向当前UI输入事件的指针。 |
1107| double* rollAngle | 触控笔绕Z轴旋转的角度,单位为deg。|
1108
1109**返回:**
1110
1111| 类型 | 说明 |
1112| -- | -- |
1113| int32_t | 错误码。<br>         Returns [ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode) 成功。<br>         Returns [ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode) 函数参数异常。 |
1114
1115### OH_ArkUI_PointerEvent_GetTouchAreaWidth()
1116
1117```
1118float OH_ArkUI_PointerEvent_GetTouchAreaWidth(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1119```
1120
1121**描述:**
1122
1123
1124从指向性输入事件(如触摸事件)中获取触屏区域的宽度。仅适用于手指操作产生的触控事件,这通常是一个圆形区域的半径。
1125
1126**起始版本:** 12
1127
1128
1129**参数:**
1130
1131| 参数项 | 描述 |
1132| -- | -- |
1133| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1134| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1135
1136**返回:**
1137
1138| 类型 | 说明 |
1139| -- | -- |
1140| float | 返回当前带有指向性的输入事件中触屏区域的宽度,单位为px。 |
1141
1142### OH_ArkUI_PointerEvent_GetTouchAreaHeight()
1143
1144```
1145float OH_ArkUI_PointerEvent_GetTouchAreaHeight(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1146```
1147
1148**描述:**
1149
1150
1151从指向性输入事件(如触摸事件)中获取触屏区域的高度。仅适用于手指操作产生的触控事件,这通常是一个圆形区域的半径。
1152
1153**起始版本:** 12
1154
1155
1156**参数:**
1157
1158| 参数项 | 描述 |
1159| -- | -- |
1160| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1161| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1162
1163**返回:**
1164
1165| 类型 | 说明 |
1166| -- | -- |
1167| float | 返回当前带有指向性的输入事件中触屏区域的高度,单位为px。 |
1168
1169### OH_ArkUI_PointerEvent_GetInteractionHand()
1170
1171```
1172int32_t OH_ArkUI_PointerEvent_GetInteractionHand(const ArkUI_UIInputEvent *event, ArkUI_InteractionHand *hand)
1173```
1174
1175**描述:**
1176
1177
1178获取当前触摸事件是左手点击触发还是右手点击触发。仅在部分触控产品上有效。该值并非在按下时就能实时获取,在系统完成结果推断之前,皆默认返回NONE,因此请不要过度依赖该接口返回的结果。
1179
1180**起始版本:** 15
1181
1182
1183**参数:**
1184
1185| 参数项 | 描述 |
1186| -- | -- |
1187| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md) *event | 表示指向当前UI输入事件的指针。 |
1188| [ArkUI_InteractionHand](capi-ui-input-event-h.md#arkui_interactionhand) *hand | 表示触摸点是左手还是右手。 |
1189
1190**返回:**
1191
1192| 类型 | 说明 |
1193| -- | -- |
1194| int32_t | 返回结果。<br> 如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br> 如果发生参数异常,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。 |
1195
1196### OH_ArkUI_PointerEvent_GetInteractionHandByIndex()
1197
1198```
1199int32_t OH_ArkUI_PointerEvent_GetInteractionHandByIndex(const ArkUI_UIInputEvent *event, int32_t pointerIndex, ArkUI_InteractionHand *hand)
1200```
1201
1202**描述:**
1203
1204
1205获取当前触摸事件是左手点击触发还是右手点击触发。仅在部分触控产品上有效。该值并非在按下时就能实时获取,在系统完成结果推断之前,皆默认返回NONE,因此请不要过度依赖该接口返回的结果。
1206
1207**起始版本:** 15
1208
1209
1210**参数:**
1211
1212| 参数项 | 描述 |
1213| -- | -- |
1214| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md) *event | 表示指向当前UI输入事件的指针。 |
1215| int32_t pointerIndex | 表示多点触控数据列表中目标触控点的索引。 |
1216| [ArkUI_InteractionHand](capi-ui-input-event-h.md#arkui_interactionhand) *hand | 表示触摸点是左手还是右手。 |
1217
1218**返回:**
1219
1220| 类型 | 说明 |
1221| -- | -- |
1222| int32_t | 返回结果。<br> 如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br> 如果发生参数异常,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。 |
1223
1224### OH_ArkUI_PointerEvent_GetHistorySize()
1225
1226```
1227uint32_t OH_ArkUI_PointerEvent_GetHistorySize(const ArkUI_UIInputEvent* event)
1228```
1229
1230**描述:**
1231
1232
1233从指向性输入事件(如触摸事件)中获取历史事件数量。历史事件为此次事件与上一次事件之间发生的原始事件,仅适用于move事件。
1234
1235**起始版本:** 12
1236
1237
1238**参数:**
1239
1240| 参数项 | 描述 |
1241| -- | -- |
1242| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1243
1244**返回:**
1245
1246| 类型 | 说明 |
1247| -- | -- |
1248| uint32_t | 返回当前历史事件数量。 |
1249
1250### OH_ArkUI_PointerEvent_GetHistoryEventTime()
1251
1252```
1253int64_t OH_ArkUI_PointerEvent_GetHistoryEventTime(const ArkUI_UIInputEvent* event, uint32_t historyIndex)
1254```
1255
1256**描述:**
1257
1258
1259从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取历史事件发生的时间。
1260
1261**起始版本:** 12
1262
1263
1264**参数:**
1265
1266| 参数项 | 描述 |
1267| -- | -- |
1268| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1269| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1270
1271**返回:**
1272
1273| 类型 | 说明 |
1274| -- | -- |
1275| int64_t | 返回UI输入事件发生的时间,单位为ns。如果参数异常则返回0。 |
1276
1277### OH_ArkUI_PointerEvent_GetHistoryPointerCount()
1278
1279```
1280uint32_t OH_ArkUI_PointerEvent_GetHistoryPointerCount(const ArkUI_UIInputEvent* event, uint32_t historyIndex)
1281```
1282
1283**描述:**
1284
1285
1286从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中多点触控的接触点数量。
1287
1288**起始版本:** 12
1289
1290
1291**参数:**
1292
1293| 参数项 | 描述 |
1294| -- | -- |
1295| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1296| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1297
1298**返回:**
1299
1300| 类型 | 说明 |
1301| -- | -- |
1302| uint32_t | 特定历史事件中多点触控的接触点数量。 |
1303
1304### OH_ArkUI_PointerEvent_GetHistoryPointerId()
1305
1306```
1307int32_t OH_ArkUI_PointerEvent_GetHistoryPointerId(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1308```
1309
1310**描述:**
1311
1312
1313从指向性输入事件(如触摸事件)的历史点中获取多点触控的接触点标识。返回事件发生时,事件触点的唯一标识符,用于区分同类输入设备的多点触控信息。其数值没有除标识触点外的其他含义。
1314
1315**起始版本:** 12
1316
1317
1318**参数:**
1319
1320| 参数项 | 描述 |
1321| -- | -- |
1322| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1323| uint32_t pointerIndex | 表示多点触控数据列表的序号。 |
1324| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1325
1326**返回:**
1327
1328| 类型 | 说明 |
1329| -- | -- |
1330| int32_t | 返回特定历史事件中的特定接触点标识。 |
1331
1332### OH_ArkUI_PointerEvent_GetHistoryX()
1333
1334```
1335float OH_ArkUI_PointerEvent_GetHistoryX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1336```
1337
1338**描述:**
1339
1340
1341从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前组件左上角的X坐标。
1342
1343**起始版本:** 12
1344
1345
1346**参数:**
1347
1348| 参数项 | 描述 |
1349| -- | -- |
1350| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1351| uint32_t pointerIndex | 表示多点触控数据列表的序号。 |
1352| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1353
1354**返回:**
1355
1356| 类型 | 说明 |
1357| -- | -- |
1358| float | 返回当前带有指向性的输入事件相对于当前组件左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
1359
1360### OH_ArkUI_PointerEvent_GetHistoryY()
1361
1362```
1363float OH_ArkUI_PointerEvent_GetHistoryY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1364```
1365
1366**描述:**
1367
1368
1369从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前组件左上角的Y坐标。
1370
1371**起始版本:** 12
1372
1373
1374**参数:**
1375
1376| 参数项 | 描述 |
1377| -- | -- |
1378| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1379| uint32_t pointerIndex | 表示多点触控数据列表的序号。 |
1380| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1381
1382**返回:**
1383
1384| 类型 | 说明 |
1385| -- | -- |
1386| float | 返回当前带有指向性的输入事件相对于当前组件左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
1387
1388### OH_ArkUI_PointerEvent_GetHistoryWindowX()
1389
1390```
1391float OH_ArkUI_PointerEvent_GetHistoryWindowX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1392```
1393
1394**描述:**
1395
1396
1397从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前应用窗口左上角的X坐标。
1398
1399**起始版本:** 12
1400
1401
1402**参数:**
1403
1404| 参数项 | 描述 |
1405| -- | -- |
1406| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1407| uint32_t pointerIndex | 表示多点触控数据列表的序号。 |
1408| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1409
1410**返回:**
1411
1412| 类型 | 说明 |
1413| -- | -- |
1414| float | 返回当前带有指向性的输入事件相对于当前应用窗口左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
1415
1416### OH_ArkUI_PointerEvent_GetHistoryWindowY()
1417
1418```
1419float OH_ArkUI_PointerEvent_GetHistoryWindowY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1420```
1421
1422**描述:**
1423
1424
1425从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前应用窗口左上角的Y坐标。
1426
1427**起始版本:** 12
1428
1429
1430**参数:**
1431
1432| 参数项 | 描述 |
1433| -- | -- |
1434| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1435| uint32_t pointerIndex | 表示多点触控数据列表的序号。 |
1436| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1437
1438**返回:**
1439
1440| 类型 | 说明 |
1441| -- | -- |
1442| float | 返回当前带有指向性的输入事件相对于当前应用窗口左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
1443
1444### OH_ArkUI_PointerEvent_GetHistoryDisplayX()
1445
1446```
1447float OH_ArkUI_PointerEvent_GetHistoryDisplayX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1448```
1449
1450**描述:**
1451
1452
1453从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前屏幕左上角的X坐标。
1454
1455**起始版本:** 12
1456
1457
1458**参数:**
1459
1460| 参数项 | 描述 |
1461| -- | -- |
1462| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1463| uint32_t pointerIndex | 表示多点触控数据列表的序号。 |
1464| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1465
1466**返回:**
1467
1468| 类型 | 说明 |
1469| -- | -- |
1470| float | 返回当前带有指向性的输入事件相对于当前屏幕左上角的X坐标,单位为px。如果参数异常则返回0.0f。 |
1471
1472### OH_ArkUI_PointerEvent_GetHistoryDisplayY()
1473
1474```
1475float OH_ArkUI_PointerEvent_GetHistoryDisplayY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1476```
1477
1478**描述:**
1479
1480
1481从带有指向性的输入事件(如触摸事件、鼠标事件、轴事件)中获取特定历史事件中特定接触点相对于当前屏幕左上角的Y坐标。
1482
1483**起始版本:** 12
1484
1485
1486**参数:**
1487
1488| 参数项 | 描述 |
1489| -- | -- |
1490| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1491| uint32_t pointerIndex | 表示多点触控数据列表的序号。 |
1492| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1493
1494**返回:**
1495
1496| 类型 | 说明 |
1497| -- | -- |
1498| float | 返回当前带有指向性的输入事件相对于当前屏幕左上角的Y坐标,单位为px。如果参数异常则返回0.0f。 |
1499
1500### OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX()
1501
1502```
1503float OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1504```
1505
1506**描述:**
1507
1508
1509从给定指针索引和历史记录索引的输入事件(如触摸事件、鼠标事件、轴事件)中获取历史事件中相对于全局显示的特定触摸点的X坐标。只能从指针事件中获取位置信息,对于鼠标和轴事件,当给定的pointerIndex大于0时,始终返回默认值0.0f。
1510
1511**起始版本:** 20
1512
1513
1514**参数:**
1515
1516| 参数项 | 描述                                                                                                                   |
1517| -- |----------------------------------------------------------------------------------------------------------------------|
1518| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。                                                                                                     |
1519| uint32_t pointerIndex | 表示多点触控数据列表中目标触控点的索引。有效值范围[0,  [OH_ArkUI_PointerEvent_GetPointerCount()](#oh_arkui_pointerevent_getpointercount) - 1] |
1520| uint32_t historyIndex | 表示要返回的历史值,必须小于[OH_ArkUI_PointerEvent_GetHistorySize](capi-ui-input-event-h.md#oh_arkui_pointerevent_gethistorysize)。 |
1521
1522**返回:**
1523
1524| 类型 | 说明 |
1525| -- | -- |
1526| float | float 返回相对于全局显示的X坐标,单位为px。如果发生任何参数错误,则返回0.0f。 |
1527
1528### OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY()
1529
1530```
1531float OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1532```
1533
1534**描述:**
1535
1536
1537从给定指针索引和历史记录索引的输入事件(如触摸事件、鼠标事件、轴事件)中获取历史事件中相对于全局显示的特定触摸点的Y坐标。只能从指针事件中获取位置信息,对于鼠标和轴事件,当给定的pointerIndex大于0时,始终返回默认值0.0f。
1538
1539**起始版本:** 20
1540
1541
1542**参数:**
1543
1544| 参数项 | 描述                                                                                                                   |
1545| -- |----------------------------------------------------------------------------------------------------------------------|
1546| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。                                                                                                     |
1547| uint32_t pointerIndex | 表示多点触控数据列表中目标触控点的索引。有效值范围[0, [OH_ArkUI_PointerEvent_GetPointerCount()](#oh_arkui_pointerevent_getpointercount) - 1]  |
1548| uint32_t historyIndex | 表示要返回的历史值,必须小于[OH_ArkUI_PointerEvent_GetHistorySize](capi-ui-input-event-h.md#oh_arkui_pointerevent_gethistorysize)。 |
1549
1550**返回:**
1551
1552| 类型 | 说明 |
1553| -- | -- |
1554| float | float 返回相对于全局显示的Y坐标,如果发生任何参数错误,则返回0.0f。 |
1555
1556### OH_ArkUI_PointerEvent_GetHistoryPressure()
1557
1558```
1559float OH_ArkUI_PointerEvent_GetHistoryPressure(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1560```
1561
1562**描述:**
1563
1564
1565从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的触屏压力。
1566
1567**起始版本:** 12
1568
1569
1570**参数:**
1571
1572| 参数项 | 描述 |
1573| -- | -- |
1574| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1575| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1576| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1577
1578**返回:**
1579
1580| 类型 | 说明 |
1581| -- | -- |
1582| float | 返回当前带有指向性的输入事件产生的触屏压力,如果参数异常则返回0.0f。 |
1583
1584### OH_ArkUI_PointerEvent_GetHistoryTiltX()
1585
1586```
1587float OH_ArkUI_PointerEvent_GetHistoryTiltX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1588```
1589
1590**描述:**
1591
1592
1593从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的相对YZ平面的角度,取值的范围[-90, 90],单位为deg,其中正值是向右倾斜。
1594
1595**起始版本:** 12
1596
1597
1598**参数:**
1599
1600| 参数项 | 描述 |
1601| -- | -- |
1602| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1603| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1604| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1605
1606**返回:**
1607
1608| 类型 | 说明 |
1609| -- | -- |
1610| float | 返回当前带有指向性的输入事件中相对YZ平面的角度。 |
1611
1612### OH_ArkUI_PointerEvent_GetHistoryTiltY()
1613
1614```
1615float OH_ArkUI_PointerEvent_GetHistoryTiltY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1616```
1617
1618**描述:**
1619
1620
1621从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的相对XZ平面的角度,值的范围[-90, 90],单位为deg,其中正值是向下倾斜。
1622
1623**起始版本:** 12
1624
1625
1626**参数:**
1627
1628| 参数项 | 描述 |
1629| -- | -- |
1630| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1631| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1632| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1633
1634**返回:**
1635
1636| 类型 | 说明 |
1637| -- | -- |
1638| float | 返回当前带有指向性的输入事件中相对XZ平面的角度。 |
1639
1640### OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth()
1641
1642```
1643float OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1644```
1645
1646**描述:**
1647
1648
1649从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的触屏区域的宽度。
1650
1651**起始版本:** 12
1652
1653
1654**参数:**
1655
1656| 参数项 | 描述 |
1657| -- | -- |
1658| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1659| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1660| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1661
1662**返回:**
1663
1664| 类型 | 说明 |
1665| -- | -- |
1666| float | 返回当前带有指向性的输入事件中触屏区域的宽度,单位为px。 |
1667
1668### OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight()
1669
1670```
1671float OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1672```
1673
1674**描述:**
1675
1676
1677从带有指向性的输入事件(如触摸事件)中获取特定历史事件中的触屏区域的高度。
1678
1679**起始版本:** 12
1680
1681
1682**参数:**
1683
1684| 参数项 | 描述 |
1685| -- | -- |
1686| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1687| uint32_t pointerIndex | 表示多点触控数据列表中的序号。 |
1688| uint32_t historyIndex | 表示历史事件数据列表的序号。 |
1689
1690**返回:**
1691
1692| 类型 | 说明 |
1693| -- | -- |
1694| float | 返回当前带有指向性的输入事件中触屏区域的高度,单位为px。 |
1695
1696### OH_ArkUI_AxisEvent_GetVerticalAxisValue()
1697
1698```
1699double OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent* event)
1700```
1701
1702**描述:**
1703
1704
1705获取当前轴事件的垂直滚动轴的值。通常由鼠标滚轮,或用户在触控板上双指竖向滑动产生。当通过鼠标滚动触发时:1.上报的数值单位为角度,为单次滚动角度增量,非滚动总量;2.上报的数值已与用户配置的放大系数[OH_ArkUI_AxisEvent_GetScrollStep](capi-ui-input-event-h.md#oh_arkui_axisevent_getscrollstep)叠加运算;3.数值的正负代表方向,向前滚动鼠标滚轮时上报数值为负数,向后滚动鼠标滚轮时上报数值为正数;当通过触控板双指竖向滑动时:1.上报的数值单位为PX,为单次滚动增量,非滚动总量;2.上报的数值不受用户配置的放大系数[OH_ArkUI_AxisEvent_GetScrollStep](capi-ui-input-event-h.md#oh_arkui_axisevent_getscrollstep)影响;3.数值的正负代表方向,双指从上往下滑动时上报数值为负数,双指从下往上滑动时上报数值为正数;4.方向会受系统设置中"自然滚动"配置的影响。通常情况下,垂直滚动轴事件只能驱动竖向的滑动手势响应,但当鼠标指针下命中的可滑动手势里,如果可响应的方向都是一致的,那么垂直滚动轴事件可以驱动这些滑动手势得到响应,即使这些手势所定义的方向是横向的。
1706
1707**起始版本:** 12
1708
1709
1710**参数:**
1711
1712| 参数项 | 描述 |
1713| -- | -- |
1714| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1715
1716**返回:**
1717
1718| 类型 | 说明 |
1719| -- | -- |
1720| double | 返回当前轴事件的垂直滚动轴的值,如果参数异常则返回0.0。 |
1721
1722### OH_ArkUI_AxisEvent_GetHorizontalAxisValue()
1723
1724```
1725double OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent* event)
1726```
1727
1728**描述:**
1729
1730
1731获取当前轴事件的水平滚动轴的值,通过在触控板上双指横向滑动产生。1.上报的数值单位为PX,为单次滚动增量,非滚动总量;2.上报的数值不受用户配置的放大系数[OH_ArkUI_AxisEvent_GetScrollStep](capi-ui-input-event-h.md#oh_arkui_axisevent_getscrollstep)影响;3.数值的正负代表方向,双指从左往右滑动时上报数值为负数,双指从右往左滑动时上报数值为正数;4.方向会受系统设置中"自然滚动"配置的影响。
1732
1733**起始版本:** 12
1734
1735
1736**参数:**
1737
1738| 参数项 | 描述 |
1739| -- | -- |
1740| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1741
1742**返回:**
1743
1744| 类型 | 说明 |
1745| -- | -- |
1746| double | 返回当前轴事件的水平滚动轴的值,如果参数异常则返回0.0。 |
1747
1748### OH_ArkUI_AxisEvent_GetPinchAxisScaleValue()
1749
1750```
1751double OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent* event)
1752```
1753
1754**描述:**
1755
1756
1757获取当前轴事件的捏合轴缩放的值。通过触控板双指缩放/捏合操作产生。上报的scale数值,为相对于初始状态时的当前scale值。初始状态为系统识别到用户通过触控板发生了捏合操作时的两指位置状态,此时的scale数值为1.0。在手指抬起前的本次捏合操作过程中,所上报的scale数值均将初始状态作为参考系,从初始状态往中心捏合,则上报的scale会从1.0逐步往0.0缩小;当从初始化状态往外扩大双指距离时,会从1.0逐步变大。
1758
1759**起始版本:** 12
1760
1761
1762**参数:**
1763
1764| 参数项 | 描述 |
1765| -- | -- |
1766| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1767
1768**返回:**
1769
1770| 类型 | 说明 |
1771| -- | -- |
1772| double | 返回当前轴事件的捏合轴缩放的值,如果参数异常则返回0.0。 |
1773
1774### OH_ArkUI_AxisEvent_GetAxisAction()
1775
1776```
1777int32_t OH_ArkUI_AxisEvent_GetAxisAction(const ArkUI_UIInputEvent* event)
1778```
1779
1780**描述:**
1781
1782
1783获取当前轴事件的操作类型。
1784
1785**起始版本:** 15
1786
1787
1788**参数:**
1789
1790| 参数项 | 描述 |
1791| -- | -- |
1792| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1793
1794**返回:**
1795
1796| 类型 | 说明 |
1797| -- | -- |
1798| int32_t | 返回当前轴事件的操作类型。 |
1799
1800### OH_ArkUI_PointerEvent_SetInterceptHitTestMode()
1801
1802```
1803int32_t OH_ArkUI_PointerEvent_SetInterceptHitTestMode(const ArkUI_UIInputEvent* event, HitTestMode mode)
1804```
1805
1806**描述:**
1807
1808
1809配置HitTest模式。仅适用于接收基础事件的场景,如使用NODE_ON_TOUCH接收touch事件场景。对于通过[OH_ArkUI_GestureEvent_GetRawInputEvent](capi-native-gesture-h.md#oh_arkui_gestureevent_getrawinputevent)接口从一个手势事件中获取到的ArkUI_UIInputEvent对象,无法使用该接口。
1810
1811**起始版本:** 12
1812
1813
1814**参数:**
1815
1816| 参数项 | 描述 |
1817| -- | -- |
1818| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1819| [HitTestMode](capi-ui-input-event-h.md#hittestmode) mode | 指定HitTest模式,参数类型[HitTestMode](capi-ui-input-event-h.md#hittestmode)。 |
1820
1821**返回:**
1822
1823| 类型 | 说明 |
1824| -- | -- |
1825| int32_t | 返回执行的状态代码。 |
1826
1827### OH_ArkUI_MouseEvent_GetMouseButton()
1828
1829```
1830int32_t OH_ArkUI_MouseEvent_GetMouseButton(const ArkUI_UIInputEvent* event)
1831```
1832
1833**描述:**
1834
1835
1836获取鼠标事件的按键类型的值。
1837
1838**起始版本:** 12
1839
1840
1841**参数:**
1842
1843| 参数项 | 描述 |
1844| -- | -- |
1845| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1846
1847**返回:**
1848
1849| 类型 | 说明 |
1850| -- | -- |
1851| int32_t | 返回鼠标按键类型,1为左键,2为右键,3为中键,4为后退键,5为前进键。 |
1852
1853### OH_ArkUI_MouseEvent_GetMouseAction()
1854
1855```
1856int32_t OH_ArkUI_MouseEvent_GetMouseAction(const ArkUI_UIInputEvent* event)
1857```
1858
1859**描述:**
1860
1861
1862获取鼠标事件的鼠标动作类型的值。
1863
1864**起始版本:** 12
1865
1866
1867**参数:**
1868
1869| 参数项 | 描述 |
1870| -- | -- |
1871| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1872
1873**返回:**
1874
1875| 类型 | 说明 |
1876| -- | -- |
1877| int32_t | 返回鼠标动作类型,1表示按键按下,2表示按键松开,3表示鼠标移动。 |
1878
1879### OH_ArkUI_PointerEvent_SetStopPropagation()
1880
1881```
1882int32_t OH_ArkUI_PointerEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)
1883```
1884
1885**描述:**
1886
1887
1888设置是否阻止事件冒泡。仅适用于接收基础事件的场景,如使用NODE_ON_TOUCH接收touch事件场景,不适用于轴事件。对于通过[OH_ArkUI_GestureEvent_GetRawInputEvent](capi-native-gesture-h.md#oh_arkui_gestureevent_getrawinputevent)接口从一个手势事件中获取到的ArkUI_UIInputEvent对象,无法使用该接口。
1889
1890**起始版本:** 12
1891
1892
1893**参数:**
1894
1895| 参数项 | 描述 |
1896| -- | -- |
1897| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
1898| bool stopPropagation | 表示是否阻止事件冒泡。true表示阻止事件冒泡,false表示不阻止事件冒泡。 |
1899
1900**返回:**
1901
1902| 类型 | 说明 |
1903| -- | -- |
1904| int32_t | 返回执行的状态代码。返回0表示设置成功,如果返回401,表示返回失败,可能的原因是参数异常,例如event是一个空指针。 |
1905
1906### OH_ArkUI_UIInputEvent_GetDeviceId()
1907
1908```
1909int32_t OH_ArkUI_UIInputEvent_GetDeviceId(const ArkUI_UIInputEvent* event)
1910```
1911
1912**描述:**
1913
1914
1915获取当前按键的输入设备ID。
1916
1917**起始版本:** 14
1918
1919
1920**参数:**
1921
1922| 参数项 | 描述 |
1923| -- | -- |
1924| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
1925
1926**返回:**
1927
1928| 类型 | 说明 |
1929| -- | -- |
1930| int32_t | 当前按键的输入设备ID。 |
1931
1932### OH_ArkUI_UIInputEvent_GetPressedKeys()
1933
1934```
1935int32_t OH_ArkUI_UIInputEvent_GetPressedKeys(const ArkUI_UIInputEvent* event, int32_t* pressedKeyCodes, int32_t* length)
1936```
1937
1938**描述:**
1939
1940
1941获取所有按下的按键,当前只支持按键事件。
1942
1943**起始版本:** 14
1944
1945
1946**参数:**
1947
1948| 参数项 | 描述 |
1949| -- | -- |
1950| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
1951| int32_t* pressedKeyCodes | 输出参数,表示所有按下键的数组,指向的内存空间需要调用者申请。 |
1952| int32_t* length | 作为输入参数表示传入的pressedKeyCodes数组长度,作为输出参数表示实际按下按键的个数。 |
1953
1954**返回:**
1955
1956| 类型 | 说明 |
1957| -- | -- |
1958| int32_t | 错误码。<br>         [ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode) 成功。<br>         [ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH](capi-native-type-h.md#arkui_errorcode) 内存分配不足。<br>         [ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode) 函数参数异常。 |
1959
1960### OH_ArkUI_FocusAxisEvent_GetAxisValue()
1961
1962```
1963double OH_ArkUI_FocusAxisEvent_GetAxisValue(const ArkUI_UIInputEvent* event, int32_t axis)
1964```
1965
1966**描述:**
1967
1968
1969获取焦点轴事件的轴值。
1970
1971**起始版本:** 15
1972
1973
1974**参数:**
1975
1976| 参数项 | 描述 |
1977| -- | -- |
1978| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
1979| int32_t axis | 焦点轴事件的轴类型。 |
1980
1981**返回:**
1982
1983| 类型 | 说明 |
1984| -- | -- |
1985| double | 焦点轴事件的轴值,如果参数异常则返回0.0。 |
1986
1987### OH_ArkUI_FocusAxisEvent_SetStopPropagation()
1988
1989```
1990int32_t OH_ArkUI_FocusAxisEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)
1991```
1992
1993**描述:**
1994
1995
1996设置是否阻止焦点轴事件冒泡。
1997
1998**起始版本:** 15
1999
2000
2001**参数:**
2002
2003| 参数项 | 描述 |
2004| -- | -- |
2005| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前UI输入事件的指针。 |
2006| bool stopPropagation | 表示是否阻止事件冒泡。true表示阻止事件冒泡,false表示不阻止事件冒泡。 |
2007
2008**返回:**
2009
2010| 类型 | 说明 |
2011| -- | -- |
2012| int32_t | 错误码。<br>         [ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode) 成功。<br>         [ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode) 参数异常。 |
2013
2014### OH_ArkUI_UIInputEvent_GetModifierKeyStates()
2015
2016```
2017int32_t OH_ArkUI_UIInputEvent_GetModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
2018```
2019
2020**描述:**
2021
2022
2023获取UI输入事件的修饰键状态。该接口会通过keys传出当前事件发生时所有修饰键的状态,你可以通过与[ArkUI_ModifierKeyName](capi-ui-input-event-h.md#arkui_modifierkeyname)中定义的修饰键类型进行位计算操作获取哪些键处于按下状态。
2024
2025**起始版本:** 17
2026
2027
2028**参数:**
2029
2030| 参数项 | 描述 |
2031| -- | -- |
2032| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2033| uint64_t* keys | 返回当前处于按下状态的modifier key组合,应用可通过位运算进行判断。 |
2034
2035**返回:**
2036
2037| 类型 | 说明 |
2038| -- | -- |
2039| int32_t | 错误码。<br>         [ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode) 成功。<br>         [ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode) 函数参数异常。 |
2040
2041### OH_ArkUI_AxisEvent_SetPropagation()
2042
2043```
2044int32_t OH_ArkUI_AxisEvent_SetPropagation(const ArkUI_UIInputEvent* event, bool propagation)
2045```
2046
2047**描述:**
2048
2049
2050设置是否使能轴事件冒泡。默认不会进行冒泡传递,仅发送给第一个可响应轴事件的控件。可在接收到轴事件时,主动使能冒泡传递,以便当前事件可以继续传递给响应链上的下一个可响应轴事件的祖先组件处理。不支持对从手势事件中获取到的轴事件进行设置。
2051
2052**起始版本:** 17
2053
2054
2055**参数:**
2056
2057| 参数项 | 描述 |
2058| -- | -- |
2059| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 表示指向当前 UI 输入事件的指针。 |
2060| bool propagation | 表示是否激活事件冒泡。true表示激活事件冒泡,false表示不激活事件冒泡。 |
2061
2062**返回:**
2063
2064| 类型 | 说明 |
2065| -- | -- |
2066| int32_t | 错误码。<br>         [ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode) 成功。<br>         [ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode) 参数异常。 |
2067
2068### OH_ArkUI_AxisEvent_GetScrollStep()
2069
2070```
2071int32_t OH_ArkUI_AxisEvent_GetScrollStep(const ArkUI_UIInputEvent* event)
2072```
2073
2074**描述:**
2075
2076
2077获取滚动轴事件的滚动步长系数,适用于鼠标滚轮产生的轴事件。这个值可以告诉你用户所配置的滚动放大系数。
2078
2079**起始版本:** 17
2080
2081
2082**参数:**
2083
2084| 参数项 | 描述 |
2085| -- | -- |
2086| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 指向 ArkUI_UIInputEvent事件指针。 |
2087
2088**返回:**
2089
2090| 类型 | 说明 |
2091| -- | -- |
2092| int32_t | 返回鼠标滚轮轴滚动步长配置。 |
2093
2094### OH_ArkUI_UIInputEvent_GetEventTargetWidth()
2095
2096```
2097float OH_ArkUI_UIInputEvent_GetEventTargetWidth(const ArkUI_UIInputEvent* event)
2098```
2099
2100**描述:**
2101
2102
2103获取事件命中的组件的宽度。
2104
2105**起始版本:** 17
2106
2107
2108**参数:**
2109
2110| 参数项 | 描述 |
2111| -- | -- |
2112| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 指向ArkUI_UIInputEvent对象的指针。 |
2113
2114**返回:**
2115
2116| 类型 | 说明 |
2117| -- | -- |
2118| float | 返回事件命中的组件的宽度;如果发生任何参数错误,则返回 0.0f。 |
2119
2120### OH_ArkUI_UIInputEvent_GetEventTargetHeight()
2121
2122```
2123float OH_ArkUI_UIInputEvent_GetEventTargetHeight(const ArkUI_UIInputEvent* event)
2124```
2125
2126**描述:**
2127
2128
2129获取事件命中的组件的高度。
2130
2131**起始版本:** 17
2132
2133
2134**参数:**
2135
2136| 参数项 | 描述 |
2137| -- | -- |
2138| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 指向ArkUI_UIInputEvent对象的指针。 |
2139
2140**返回:**
2141
2142| 类型 | 说明 |
2143| -- | -- |
2144| float | 返回事件命中的组件的高度;如果发生任何参数错误,则返回 0.0f。 |
2145
2146### OH_ArkUI_UIInputEvent_GetEventTargetPositionX()
2147
2148```
2149float OH_ArkUI_UIInputEvent_GetEventTargetPositionX(const ArkUI_UIInputEvent* event)
2150```
2151
2152**描述:**
2153
2154
2155获取事件命中的组件的X坐标。
2156
2157**起始版本:** 17
2158
2159
2160**参数:**
2161
2162| 参数项 | 描述 |
2163| -- | -- |
2164| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 指向ArkUI_UIInputEvent对象的指针。 |
2165
2166**返回:**
2167
2168| 类型 | 说明 |
2169| -- | -- |
2170| float | 返回事件命中的组件的X坐标;如果发生任何参数错误,则返回 0.0f。 |
2171
2172### OH_ArkUI_UIInputEvent_GetEventTargetPositionY()
2173
2174```
2175float OH_ArkUI_UIInputEvent_GetEventTargetPositionY(const ArkUI_UIInputEvent* event)
2176```
2177
2178**描述:**
2179
2180
2181获取事件命中的组件的Y坐标。
2182
2183**起始版本:** 17
2184
2185
2186**参数:**
2187
2188| 参数项 | 描述 |
2189| -- | -- |
2190| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 指向ArkUI_UIInputEvent对象的指针。 |
2191
2192**返回:**
2193
2194| 类型 | 说明 |
2195| -- | -- |
2196| float | 返回事件命中的组件的Y坐标;如果发生任何参数错误,则返回 0.0f。 |
2197
2198### OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX()
2199
2200```
2201float OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
2202```
2203
2204**描述:**
2205
2206
2207获取事件命中的组件的全局X坐标。
2208
2209**起始版本:** 17
2210
2211
2212**参数:**
2213
2214| 参数项 | 描述 |
2215| -- | -- |
2216| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 指向ArkUI_UIInputEvent对象的指针。 |
2217
2218**返回:**
2219
2220| 类型 | 说明 |
2221| -- | -- |
2222| float | 返回事件命中的组件的全局X坐标;如果发生任何参数错误,则返回 0.0f。 |
2223
2224### OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY()
2225
2226```
2227float OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
2228```
2229
2230**描述:**
2231
2232
2233获取事件命中的组件的全局Y坐标。
2234
2235**起始版本:** 17
2236
2237
2238**参数:**
2239
2240| 参数项 | 描述 |
2241| -- | -- |
2242| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | 指向ArkUI_UIInputEvent对象的指针。 |
2243
2244**返回:**
2245
2246| 类型 | 说明 |
2247| -- | -- |
2248| float | 返回事件命中的组件的全局Y坐标;如果发生任何参数错误,则返回 0.0f。 |
2249
2250### OH_ArkUI_PointerEvent_GetPressedTimeByIndex()
2251
2252```
2253int64_t OH_ArkUI_PointerEvent_GetPressedTimeByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
2254```
2255
2256**描述:**
2257
2258
2259获取指定触点的按下时间。仅对触摸事件有效。
2260
2261**起始版本:** 15
2262
2263
2264**参数:**
2265
2266| 参数项 | 描述 |
2267| -- | -- |
2268| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2269| uint32_t pointerIndex | 指示多点触控数据列表中目标触控点的索引。 |
2270
2271**返回:**
2272
2273| 类型 | 说明 |
2274| -- | -- |
2275| int64_t | 返回特定触摸点的按下时间,单位为ns;如果发生任何参数错误,则返回0。 |
2276
2277### OH_ArkUI_MouseEvent_GetRawDeltaX()
2278
2279```
2280float OH_ArkUI_MouseEvent_GetRawDeltaX(const ArkUI_UIInputEvent* event)
2281```
2282
2283**描述:**
2284
2285
2286获取X轴相对于前一个上报的鼠标事件的鼠标指针位置的偏移量。当鼠标指针位于屏幕边缘时,该值可能小于两次上报的X坐标的差。
2287
2288**起始版本:** 15
2289
2290
2291**参数:**
2292
2293| 参数项 | 描述 |
2294| -- | -- |
2295| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2296
2297**返回:**
2298
2299| 类型 | 说明 |
2300| -- | -- |
2301| float | 返回相对于前一个上报的鼠标事件的鼠标指针位置的X轴偏移量,单位为px;如果发生任何参数错误,则返回0.0f。 |
2302
2303### OH_ArkUI_MouseEvent_GetRawDeltaY()
2304
2305```
2306float OH_ArkUI_MouseEvent_GetRawDeltaY(const ArkUI_UIInputEvent* event)
2307```
2308
2309**描述:**
2310
2311
2312获取相对于前一个上报的鼠标事件的鼠标指针位置的Y轴偏移量。当鼠标指针位于屏幕边缘时,该值可能小于两次上报的Y坐标的差。
2313
2314**起始版本:** 15
2315
2316
2317**参数:**
2318
2319| 参数项 | 描述 |
2320| -- | -- |
2321| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2322
2323**返回:**
2324
2325| 类型 | 说明 |
2326| -- | -- |
2327| float | 返回相对于前一个上报的鼠标事件的鼠标指针位置的Y轴偏移量,单位为px;如果发生任何参数错误,则返回0.0f。 |
2328
2329### OH_ArkUI_MouseEvent_GetPressedButtons()
2330
2331```
2332int32_t OH_ArkUI_MouseEvent_GetPressedButtons(const ArkUI_UIInputEvent* event, int32_t* pressedButtons, int32_t* length)
2333```
2334
2335**描述:**
2336
2337
2338从鼠标事件中获取按下的按钮。
2339
2340**起始版本:** 15
2341
2342
2343**参数:**
2344
2345| 参数项 | 描述 |
2346| -- | -- |
2347| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2348| int32_t* pressedButtons | 指示按下按钮的列表。需要先创建一个int数组,用来储存按下的按钮。 |
2349| int32_t* length | 指示列表数组的总长度。 |
2350
2351**返回:**
2352
2353| 类型 | 说明 |
2354| -- | -- |
2355| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果给定的缓冲区不够,则返回[ARKUI_ERROR_CODE_BUFFER_SIZE_ERROR](capi-native-type-h.md#arkui_errorcode)。 |
2356
2357### OH_ArkUI_UIInputEvent_GetTargetDisplayId()
2358
2359```
2360int32_t OH_ArkUI_UIInputEvent_GetTargetDisplayId(const ArkUI_UIInputEvent* event)
2361```
2362
2363**描述:**
2364
2365
2366获取发生UI输入事件的屏幕ID。
2367
2368**起始版本:** 15
2369
2370
2371**参数:**
2372
2373| 参数项 | 描述 |
2374| -- | -- |
2375| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2376
2377**返回:**
2378
2379| 类型 | 说明 |
2380| -- | -- |
2381| int32_t | 返回屏幕ID;如果发生任何参数错误,则返回0。 |
2382
2383### OH_ArkUI_HoverEvent_IsHovered()
2384
2385```
2386bool OH_ArkUI_HoverEvent_IsHovered(const ArkUI_UIInputEvent* event)
2387```
2388
2389**描述:**
2390
2391
2392获取鼠标是否悬浮在当前组件上
2393
2394**起始版本:** 17
2395
2396
2397**参数:**
2398
2399| 参数项 | 描述 |
2400| -- | -- |
2401| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2402
2403**返回:**
2404
2405| 类型 | 说明 |
2406| -- | -- |
2407| bool | 如果鼠标悬浮在当前组件上则返回true。<br>        如果鼠标没有悬浮在当前组件上,返回false |
2408
2409### OH_ArkUI_PointerEvent_CreateClonedEvent()
2410
2411```
2412int32_t OH_ArkUI_PointerEvent_CreateClonedEvent(const ArkUI_UIInputEvent* event, ArkUI_UIInputEvent** clonedEvent)
2413```
2414
2415**描述:**
2416
2417
2418基于原始事件指针创建克隆事件指针。仅对触摸事件有效。
2419
2420**起始版本:** 15
2421
2422
2423**参数:**
2424
2425| 参数项 | 描述 |
2426| -- | -- |
2427| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2428| [ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)** clonedEvent | ArkUI_UIInputEvent克隆事件指针。 |
2429
2430**返回:**
2431
2432| 类型 | 说明 |
2433| -- | -- |
2434| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果事件指针创建失败,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。 |
2435
2436### OH_ArkUI_PointerEvent_DestroyClonedEvent()
2437
2438```
2439int32_t OH_ArkUI_PointerEvent_DestroyClonedEvent(const ArkUI_UIInputEvent* event)
2440```
2441
2442**描述:**
2443
2444
2445销毁克隆事件指针。
2446
2447**起始版本:** 15
2448
2449
2450**参数:**
2451
2452| 参数项 | 描述 |
2453| -- | -- |
2454| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2455
2456**返回:**
2457
2458| 类型 | 说明 |
2459| -- | -- |
2460| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果入参错误,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。<br>         如果输入的事件指针不是克隆事件指针,则返回[ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT](capi-native-type-h.md#arkui_errorcode)。 |
2461
2462### OH_ArkUI_PointerEvent_SetClonedEventLocalPosition()
2463
2464```
2465int32_t OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(const ArkUI_UIInputEvent* event, float x, float y)
2466```
2467
2468**描述:**
2469
2470
2471设置指向性事件相对于当前组件左上角的X坐标和Y坐标。
2472
2473**起始版本:** 15
2474
2475
2476**参数:**
2477
2478| 参数项 | 描述 |
2479| -- | -- |
2480| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2481| float x | 当前带有指向性的输入事件相对于当前组件左上角的X坐标,单位为px。 |
2482| float y | 当前带有指向性的输入事件相对于当前组件左上角的Y坐标,单位为px。 |
2483
2484**返回:**
2485
2486| 类型 | 说明 |
2487| -- | -- |
2488| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果入参错误,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。<br>         如果输入的事件指针不是克隆事件指针,则返回[ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT](capi-native-type-h.md#arkui_errorcode)。 |
2489
2490### OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex()
2491
2492```
2493int32_t OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(const ArkUI_UIInputEvent* event, float x, float y, int32_t pointerIndex)
2494```
2495
2496**描述:**
2497
2498
2499设置指向性事件特有接触点相对于当前组件左上角的X坐标和Y坐标。
2500
2501**起始版本:** 15
2502
2503
2504**参数:**
2505
2506| 参数项 | 描述 |
2507| -- | -- |
2508| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2509| float x | 当前带有指向性的输入事件相对于当前组件左上角的X坐标,单位为px。 |
2510| float y | 当前带有指向性的输入事件相对于当前组件左上角的Y坐标,单位为px。 |
2511| int32_t pointerIndex | 表示多点触控数据列表中的序号。 |
2512
2513**返回:**
2514
2515| 类型 | 说明 |
2516| -- | -- |
2517| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果入参错误,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。<br>         如果输入的事件指针不是克隆事件指针,则返回[ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT](capi-native-type-h.md#arkui_errorcode)。 |
2518
2519### OH_ArkUI_PointerEvent_SetClonedEventActionType()
2520
2521```
2522int32_t OH_ArkUI_PointerEvent_SetClonedEventActionType(const ArkUI_UIInputEvent* event, int32_t actionType)
2523```
2524
2525**描述:**
2526
2527
2528设置当前带有指向性的克隆输入事件的事件类型。
2529
2530**起始版本:** 15
2531
2532
2533**参数:**
2534
2535| 参数项 | 描述 |
2536| -- | -- |
2537| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2538| int32_t actionType | ArkUI_UIInputEvent克隆事件类型。 |
2539
2540**返回:**
2541
2542| 类型 | 说明 |
2543| -- | -- |
2544| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果入参错误,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。<br>         如果输入的事件指针不是克隆事件指针,则返回[ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT](capi-native-type-h.md#arkui_errorcode)。 |
2545
2546### OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId()
2547
2548```
2549int32_t OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(const ArkUI_UIInputEvent* event, int32_t fingerId)
2550```
2551
2552**描述:**
2553
2554
2555设置当前带有指向性的克隆输入事件的触摸点ID。
2556
2557**起始版本:** 15
2558
2559
2560**参数:**
2561
2562| 参数项 | 描述 |
2563| -- | -- |
2564| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2565| int32_t fingerId | 触发当前事件指针的触摸点ID。 |
2566
2567**返回:**
2568
2569| 类型 | 说明 |
2570| -- | -- |
2571| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果入参错误,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。<br>         如果输入的事件指针不是克隆事件指针,则返回[ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT](capi-native-type-h.md#arkui_errorcode)。 |
2572
2573### OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex()
2574
2575```
2576int32_t OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(const ArkUI_UIInputEvent* event, int32_t fingerId, int32_t pointerIndex)
2577```
2578
2579**描述:**
2580
2581
2582设置带有指向性的克隆输入事件特定接触点的触摸点ID。
2583
2584**起始版本:** 15
2585
2586
2587**参数:**
2588
2589| 参数项 | 描述 |
2590| -- | -- |
2591| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2592| int32_t fingerId | 指向性的输入事件特定接触点的触摸点ID。 |
2593| int32_t pointerIndex | 表示多点触控数据列表中的序号。 |
2594
2595**返回:**
2596
2597| 类型 | 说明 |
2598| -- | -- |
2599| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果入参错误,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。<br>         如果输入的事件指针不是克隆事件指针,则返回[ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT](capi-native-type-h.md#arkui_errorcode)。 |
2600
2601### OH_ArkUI_PointerEvent_PostClonedEvent()
2602
2603```
2604int32_t OH_ArkUI_PointerEvent_PostClonedEvent(ArkUI_NodeHandle node, const ArkUI_UIInputEvent* event)
2605```
2606
2607**描述:**
2608
2609
2610转发克隆事件到特定节点。
2611
2612**起始版本:** 15
2613
2614
2615**参数:**
2616
2617| 参数项 | 描述 |
2618| -- | -- |
2619| [ArkUI_NodeHandle](capi-arkui-nativemodule-arkui-node8h.md) node | 目标节点。 |
2620| [const ArkUI_UIInputEvent](capi-arkui-eventmodule-arkui-uiinputevent.md)* event | ArkUI_UIInputEvent事件指针。 |
2621
2622**返回:**
2623
2624| 类型 | 说明 |
2625| -- | -- |
2626| int32_t | 返回结果代码。<br>         如果操作成功,则返回[ARKUI_ERROR_CODE_NO_ERROR](capi-native-type-h.md#arkui_errorcode)。<br>         如果入参错误,则返回[ARKUI_ERROR_CODE_PARAM_INVALID](capi-native-type-h.md#arkui_errorcode)。<br>         如果输入的事件指针不是克隆事件指针,则返回[ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT](capi-native-type-h.md#arkui_errorcode)。<br>         如果组件状态异常,则返回[ARKUI_ERROR_CODE_POST_CLONED_COMPONENT_STATUS_ABNORMAL](capi-native-type-h.md#arkui_errorcode)。<br>         如果未命中可响应事件的组件,则返回[ARKUI_ERROR_CODE_POST_CLONED_NO_COMPONENT_HIT_TO_RESPOND_TO_THE_EVENT](capi-native-type-h.md#arkui_errorcode)。 |
2627
2628### OH_ArkUI_UIInputEvent_GetLatestStatus()
2629
2630```
2631ArkUI_ErrorCode OH_ArkUI_UIInputEvent_GetLatestStatus()
2632```
2633
2634**描述:**
2635
2636
2637调用该方法获取最近一次UIInput相关方法的执行情况。通常情况下不需要使用该方法,仅在返回值结果不确定是否异常时使用。以下是一个使用示例(对于返回的float类型,0.0并不代表错误,因此可以进一步使用OH_ArkUI_UIInputEvent_GetLatestStatus方法来确认是否发生异常)。float x = OH_ArkUI_PointerEvent_GetX(event);if (ARKUI_ERROR_CODE_NO_ERROR != OH_Arkui_UIInputEvent_GetlatestStatus()) {// errorreturn;}系统将在每次执行UIInput相关函数时主动清空上一次函数调用的状态,以确保每次通过该接口获取的均为最近一次的状态。
2638
2639**起始版本:** 20
2640
2641**返回:**
2642
2643| 类型 | 说明 |
2644| -- | -- |
2645| [ArkUI_ErrorCode](capi-native-type-h.md#arkui_errorcode) | 返回最近一次调用UIInput方法产生的结果代码。 |
2646
2647
2648