1#[cfg(feature = "api-17")]
2use ohos_arkui_input_sys::OH_ArkUI_PointerEvent_GetRollAngle;
3#[cfg(feature = "api-15")]
4use ohos_arkui_input_sys::{
5 ArkUI_ErrorCode_ARKUI_ERROR_CODE_PARAM_INVALID, ArkUI_InteractionHand_ARKUI_EVENT_HAND_NONE,
6 ArkUI_NodeHandle, OH_ArkUI_MouseEvent_GetPressedButtons, OH_ArkUI_MouseEvent_GetRawDeltaX,
7 OH_ArkUI_MouseEvent_GetRawDeltaY, OH_ArkUI_PointerEvent_CreateClonedEvent,
8 OH_ArkUI_PointerEvent_DestroyClonedEvent, OH_ArkUI_PointerEvent_GetInteractionHand,
9 OH_ArkUI_PointerEvent_GetInteractionHandByIndex, OH_ArkUI_PointerEvent_GetPressedTimeByIndex,
10 OH_ArkUI_PointerEvent_PostClonedEvent, OH_ArkUI_PointerEvent_SetClonedEventActionType,
11 OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId,
12 OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex,
13 OH_ArkUI_PointerEvent_SetClonedEventLocalPosition,
14 OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex,
15};
16use ohos_arkui_input_sys::{
17 HitTestMode, OH_ArkUI_MouseEvent_GetMouseAction, OH_ArkUI_MouseEvent_GetMouseButton,
18 OH_ArkUI_PointerEvent_GetDisplayX, OH_ArkUI_PointerEvent_GetDisplayXByIndex,
19 OH_ArkUI_PointerEvent_GetDisplayY, OH_ArkUI_PointerEvent_GetDisplayYByIndex,
20 OH_ArkUI_PointerEvent_GetHistoryDisplayX, OH_ArkUI_PointerEvent_GetHistoryDisplayY,
21 OH_ArkUI_PointerEvent_GetHistoryEventTime, OH_ArkUI_PointerEvent_GetHistoryPointerCount,
22 OH_ArkUI_PointerEvent_GetHistoryPointerId, OH_ArkUI_PointerEvent_GetHistoryPressure,
23 OH_ArkUI_PointerEvent_GetHistorySize, OH_ArkUI_PointerEvent_GetHistoryTiltX,
24 OH_ArkUI_PointerEvent_GetHistoryTiltY, OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight,
25 OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth, OH_ArkUI_PointerEvent_GetHistoryWindowX,
26 OH_ArkUI_PointerEvent_GetHistoryWindowY, OH_ArkUI_PointerEvent_GetHistoryX,
27 OH_ArkUI_PointerEvent_GetHistoryY, OH_ArkUI_PointerEvent_GetPressure,
28 OH_ArkUI_PointerEvent_GetTiltX, OH_ArkUI_PointerEvent_GetTiltY,
29 OH_ArkUI_PointerEvent_GetTouchAreaHeight, OH_ArkUI_PointerEvent_GetTouchAreaWidth,
30 OH_ArkUI_PointerEvent_GetWindowX, OH_ArkUI_PointerEvent_GetWindowXByIndex,
31 OH_ArkUI_PointerEvent_GetWindowY, OH_ArkUI_PointerEvent_GetWindowYByIndex,
32 OH_ArkUI_PointerEvent_GetX, OH_ArkUI_PointerEvent_GetXByIndex, OH_ArkUI_PointerEvent_GetY,
33 OH_ArkUI_PointerEvent_GetYByIndex, OH_ArkUI_PointerEvent_SetInterceptHitTestMode,
34 OH_ArkUI_PointerEvent_SetStopPropagation,
35};
36#[cfg(feature = "api-20")]
37use ohos_arkui_input_sys::{
38 OH_ArkUI_PointerEvent_GetGlobalDisplayX, OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex,
39 OH_ArkUI_PointerEvent_GetGlobalDisplayY, OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex,
40 OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX, OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY,
41};
42#[cfg(feature = "api-15")]
43use std::ptr::NonNull;
44
45use crate::ui_input_data::check_status;
46use crate::{ArkUIInputError, ArkUIInputEvent, HitTest, UIMouseEventAction, UIMouseEventButton};
47#[cfg(feature = "api-15")]
48use crate::{InteractionHand, UIInputAction};
49
50impl ArkUIInputEvent {
51 pub fn pointer_x(&self) -> f32 {
52 unsafe { OH_ArkUI_PointerEvent_GetX(self.raw()) }
53 }
54
55 pub fn pointer_x_by_index(&self, pointer_index: u32) -> f32 {
56 unsafe { OH_ArkUI_PointerEvent_GetXByIndex(self.raw(), pointer_index) }
57 }
58
59 pub fn pointer_y(&self) -> f32 {
60 unsafe { OH_ArkUI_PointerEvent_GetY(self.raw()) }
61 }
62
63 pub fn pointer_y_by_index(&self, pointer_index: u32) -> f32 {
64 unsafe { OH_ArkUI_PointerEvent_GetYByIndex(self.raw(), pointer_index) }
65 }
66
67 pub fn pointer_window_x(&self) -> f32 {
68 unsafe { OH_ArkUI_PointerEvent_GetWindowX(self.raw()) }
69 }
70
71 pub fn pointer_window_x_by_index(&self, pointer_index: u32) -> f32 {
72 unsafe { OH_ArkUI_PointerEvent_GetWindowXByIndex(self.raw(), pointer_index) }
73 }
74
75 pub fn pointer_window_y(&self) -> f32 {
76 unsafe { OH_ArkUI_PointerEvent_GetWindowY(self.raw()) }
77 }
78
79 pub fn pointer_window_y_by_index(&self, pointer_index: u32) -> f32 {
80 unsafe { OH_ArkUI_PointerEvent_GetWindowYByIndex(self.raw(), pointer_index) }
81 }
82
83 pub fn pointer_display_x(&self) -> f32 {
84 unsafe { OH_ArkUI_PointerEvent_GetDisplayX(self.raw()) }
85 }
86
87 pub fn pointer_display_x_by_index(&self, pointer_index: u32) -> f32 {
88 unsafe { OH_ArkUI_PointerEvent_GetDisplayXByIndex(self.raw(), pointer_index) }
89 }
90
91 pub fn pointer_display_y(&self) -> f32 {
92 unsafe { OH_ArkUI_PointerEvent_GetDisplayY(self.raw()) }
93 }
94
95 pub fn pointer_display_y_by_index(&self, pointer_index: u32) -> f32 {
96 unsafe { OH_ArkUI_PointerEvent_GetDisplayYByIndex(self.raw(), pointer_index) }
97 }
98
99 #[cfg(feature = "api-20")]
100 pub fn pointer_global_display_x(&self) -> f32 {
101 unsafe { OH_ArkUI_PointerEvent_GetGlobalDisplayX(self.raw()) }
102 }
103
104 #[cfg(feature = "api-20")]
105 pub fn pointer_global_display_x_by_index(&self, pointer_index: u32) -> f32 {
106 unsafe { OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(self.raw(), pointer_index) }
107 }
108
109 #[cfg(feature = "api-20")]
110 pub fn pointer_global_display_y(&self) -> f32 {
111 unsafe { OH_ArkUI_PointerEvent_GetGlobalDisplayY(self.raw()) }
112 }
113
114 #[cfg(feature = "api-20")]
115 pub fn pointer_global_display_y_by_index(&self, pointer_index: u32) -> f32 {
116 unsafe { OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(self.raw(), pointer_index) }
117 }
118
119 pub fn pointer_pressure(&self, pointer_index: u32) -> f32 {
120 unsafe { OH_ArkUI_PointerEvent_GetPressure(self.raw(), pointer_index) }
121 }
122
123 pub fn pointer_tilt_x(&self, pointer_index: u32) -> f32 {
124 unsafe { OH_ArkUI_PointerEvent_GetTiltX(self.raw(), pointer_index) }
125 }
126
127 pub fn pointer_tilt_y(&self, pointer_index: u32) -> f32 {
128 unsafe { OH_ArkUI_PointerEvent_GetTiltY(self.raw(), pointer_index) }
129 }
130
131 #[cfg(feature = "api-17")]
132 pub fn pointer_roll_angle(&self) -> Result<f64, ArkUIInputError> {
133 let mut roll_angle = 0.0f64;
134 check_status(unsafe { OH_ArkUI_PointerEvent_GetRollAngle(self.raw(), &mut roll_angle) })?;
135 Ok(roll_angle)
136 }
137
138 pub fn pointer_touch_area_width(&self, pointer_index: u32) -> f32 {
139 unsafe { OH_ArkUI_PointerEvent_GetTouchAreaWidth(self.raw(), pointer_index) }
140 }
141
142 pub fn pointer_touch_area_height(&self, pointer_index: u32) -> f32 {
143 unsafe { OH_ArkUI_PointerEvent_GetTouchAreaHeight(self.raw(), pointer_index) }
144 }
145
146 #[cfg(feature = "api-15")]
147 pub fn pointer_interaction_hand(&self) -> Result<InteractionHand, ArkUIInputError> {
148 let mut hand = ArkUI_InteractionHand_ARKUI_EVENT_HAND_NONE;
149 check_status(unsafe { OH_ArkUI_PointerEvent_GetInteractionHand(self.raw(), &mut hand) })?;
150 Ok(InteractionHand::from(hand))
151 }
152
153 #[cfg(feature = "api-15")]
154 pub fn pointer_interaction_hand_by_index(
155 &self,
156 pointer_index: i32,
157 ) -> Result<InteractionHand, ArkUIInputError> {
158 let mut hand = ArkUI_InteractionHand_ARKUI_EVENT_HAND_NONE;
159 check_status(unsafe {
160 OH_ArkUI_PointerEvent_GetInteractionHandByIndex(self.raw(), pointer_index, &mut hand)
161 })?;
162 Ok(InteractionHand::from(hand))
163 }
164
165 pub fn pointer_history_size(&self) -> u32 {
166 unsafe { OH_ArkUI_PointerEvent_GetHistorySize(self.raw()) }
167 }
168
169 pub fn pointer_history_event_time(&self, history_index: u32) -> i64 {
170 unsafe { OH_ArkUI_PointerEvent_GetHistoryEventTime(self.raw(), history_index) }
171 }
172
173 pub fn pointer_history_pointer_count(&self, history_index: u32) -> u32 {
174 unsafe { OH_ArkUI_PointerEvent_GetHistoryPointerCount(self.raw(), history_index) }
175 }
176
177 pub fn pointer_history_pointer_id(&self, pointer_index: u32, history_index: u32) -> i32 {
178 unsafe {
179 OH_ArkUI_PointerEvent_GetHistoryPointerId(self.raw(), pointer_index, history_index)
180 }
181 }
182
183 pub fn pointer_history_x(&self, pointer_index: u32, history_index: u32) -> f32 {
184 unsafe { OH_ArkUI_PointerEvent_GetHistoryX(self.raw(), pointer_index, history_index) }
185 }
186
187 pub fn pointer_history_y(&self, pointer_index: u32, history_index: u32) -> f32 {
188 unsafe { OH_ArkUI_PointerEvent_GetHistoryY(self.raw(), pointer_index, history_index) }
189 }
190
191 pub fn pointer_history_window_x(&self, pointer_index: u32, history_index: u32) -> f32 {
192 unsafe { OH_ArkUI_PointerEvent_GetHistoryWindowX(self.raw(), pointer_index, history_index) }
193 }
194
195 pub fn pointer_history_window_y(&self, pointer_index: u32, history_index: u32) -> f32 {
196 unsafe { OH_ArkUI_PointerEvent_GetHistoryWindowY(self.raw(), pointer_index, history_index) }
197 }
198
199 pub fn pointer_history_display_x(&self, pointer_index: u32, history_index: u32) -> f32 {
200 unsafe {
201 OH_ArkUI_PointerEvent_GetHistoryDisplayX(self.raw(), pointer_index, history_index)
202 }
203 }
204
205 pub fn pointer_history_display_y(&self, pointer_index: u32, history_index: u32) -> f32 {
206 unsafe {
207 OH_ArkUI_PointerEvent_GetHistoryDisplayY(self.raw(), pointer_index, history_index)
208 }
209 }
210
211 #[cfg(feature = "api-20")]
212 pub fn pointer_history_global_display_x(&self, pointer_index: u32, history_index: u32) -> f32 {
213 unsafe {
214 OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(self.raw(), pointer_index, history_index)
215 }
216 }
217
218 #[cfg(feature = "api-20")]
219 pub fn pointer_history_global_display_y(&self, pointer_index: u32, history_index: u32) -> f32 {
220 unsafe {
221 OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(self.raw(), pointer_index, history_index)
222 }
223 }
224
225 pub fn pointer_history_pressure(&self, pointer_index: u32, history_index: u32) -> f32 {
226 unsafe {
227 OH_ArkUI_PointerEvent_GetHistoryPressure(self.raw(), pointer_index, history_index)
228 }
229 }
230
231 pub fn pointer_history_tilt_x(&self, pointer_index: u32, history_index: u32) -> f32 {
232 unsafe { OH_ArkUI_PointerEvent_GetHistoryTiltX(self.raw(), pointer_index, history_index) }
233 }
234
235 pub fn pointer_history_tilt_y(&self, pointer_index: u32, history_index: u32) -> f32 {
236 unsafe { OH_ArkUI_PointerEvent_GetHistoryTiltY(self.raw(), pointer_index, history_index) }
237 }
238
239 pub fn pointer_history_touch_area_width(&self, pointer_index: u32, history_index: u32) -> f32 {
240 unsafe {
241 OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(self.raw(), pointer_index, history_index)
242 }
243 }
244
245 pub fn pointer_history_touch_area_height(&self, pointer_index: u32, history_index: u32) -> f32 {
246 unsafe {
247 OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(
248 self.raw(),
249 pointer_index,
250 history_index,
251 )
252 }
253 }
254
255 pub fn pointer_set_intercept_hit_test_mode(
256 &self,
257 mode: HitTest,
258 ) -> Result<(), ArkUIInputError> {
259 let mode: HitTestMode = mode.into();
260 check_status(unsafe { OH_ArkUI_PointerEvent_SetInterceptHitTestMode(self.raw(), mode) })
261 }
262
263 pub fn mouse_button(&self) -> UIMouseEventButton {
264 UIMouseEventButton::from(unsafe { OH_ArkUI_MouseEvent_GetMouseButton(self.raw()) } as u32)
265 }
266
267 pub fn mouse_action(&self) -> UIMouseEventAction {
268 UIMouseEventAction::from(unsafe { OH_ArkUI_MouseEvent_GetMouseAction(self.raw()) } as u32)
269 }
270
271 pub fn pointer_set_stop_propagation(
272 &self,
273 stop_propagation: bool,
274 ) -> Result<(), ArkUIInputError> {
275 check_status(unsafe {
276 OH_ArkUI_PointerEvent_SetStopPropagation(self.raw(), stop_propagation)
277 })
278 }
279
280 #[cfg(feature = "api-15")]
281 pub fn pointer_pressed_time_by_index(&self, pointer_index: u32) -> i64 {
282 unsafe { OH_ArkUI_PointerEvent_GetPressedTimeByIndex(self.raw(), pointer_index) }
283 }
284
285 #[cfg(feature = "api-15")]
286 pub fn mouse_raw_delta_x(&self) -> f32 {
287 unsafe { OH_ArkUI_MouseEvent_GetRawDeltaX(self.raw()) }
288 }
289
290 #[cfg(feature = "api-15")]
291 pub fn mouse_raw_delta_y(&self) -> f32 {
292 unsafe { OH_ArkUI_MouseEvent_GetRawDeltaY(self.raw()) }
293 }
294
295 #[cfg(feature = "api-15")]
296 pub fn mouse_pressed_buttons(
297 &self,
298 pressed_buttons: &mut [i32],
299 ) -> Result<usize, ArkUIInputError> {
300 let mut length = pressed_buttons.len() as i32;
301 check_status(unsafe {
302 OH_ArkUI_MouseEvent_GetPressedButtons(
303 self.raw(),
304 pressed_buttons.as_mut_ptr(),
305 &mut length,
306 )
307 })?;
308 Ok(length.max(0) as usize)
309 }
310
311 #[cfg(feature = "api-15")]
312 pub fn create_cloned_event(&self) -> Result<ArkUIInputClonedEvent, ArkUIInputError> {
313 let mut cloned_event: *mut ohos_arkui_input_sys::ArkUI_UIInputEvent = std::ptr::null_mut();
314 check_status(unsafe {
315 OH_ArkUI_PointerEvent_CreateClonedEvent(self.raw(), &mut cloned_event)
316 })?;
317 let event = NonNull::new(cloned_event).ok_or(ArkUIInputError::InternalError(
318 ArkUI_ErrorCode_ARKUI_ERROR_CODE_PARAM_INVALID as i32,
319 ))?;
320 Ok(ArkUIInputClonedEvent { event })
321 }
322}
323
324#[cfg(feature = "api-15")]
325#[derive(Debug)]
326pub struct ArkUIInputClonedEvent {
327 event: NonNull<ohos_arkui_input_sys::ArkUI_UIInputEvent>,
328}
329
330#[cfg(feature = "api-15")]
331impl ArkUIInputClonedEvent {
332 pub fn raw(&self) -> *const ohos_arkui_input_sys::ArkUI_UIInputEvent {
333 self.event.as_ptr()
334 }
335
336 pub fn set_local_position(&self, x: f32, y: f32) -> Result<(), ArkUIInputError> {
337 check_status(unsafe { OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(self.raw(), x, y) })
338 }
339
340 pub fn set_local_position_by_index(
341 &self,
342 x: f32,
343 y: f32,
344 pointer_index: i32,
345 ) -> Result<(), ArkUIInputError> {
346 check_status(unsafe {
347 OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(
348 self.raw(),
349 x,
350 y,
351 pointer_index,
352 )
353 })
354 }
355
356 pub fn set_action_type(&self, action: UIInputAction) -> Result<(), ArkUIInputError> {
357 check_status(unsafe {
358 OH_ArkUI_PointerEvent_SetClonedEventActionType(self.raw(), action.into())
359 })
360 }
361
362 pub fn set_changed_finger_id(&self, finger_id: i32) -> Result<(), ArkUIInputError> {
363 check_status(unsafe {
364 OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(self.raw(), finger_id)
365 })
366 }
367
368 pub fn set_finger_id_by_index(
369 &self,
370 finger_id: i32,
371 pointer_index: i32,
372 ) -> Result<(), ArkUIInputError> {
373 check_status(unsafe {
374 OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(
375 self.raw(),
376 finger_id,
377 pointer_index,
378 )
379 })
380 }
381
382 pub fn post_to_node(&self, node: ArkUI_NodeHandle) -> Result<(), ArkUIInputError> {
383 check_status(unsafe { OH_ArkUI_PointerEvent_PostClonedEvent(node, self.raw()) })
384 }
385}
386
387#[cfg(feature = "api-15")]
388impl Drop for ArkUIInputClonedEvent {
389 fn drop(&mut self) {
390 unsafe {
391 let _ = OH_ArkUI_PointerEvent_DestroyClonedEvent(self.raw());
392 }
393 }
394}