1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "interfaces/native/event/ui_input_event_impl.h"
17
18 #include "base/utils/type_definition.h"
19 #include "core/event/touch_event.h"
20 #include "core/event/axis_event.h"
21 #include "core/interfaces/arkoala/arkoala_api.h"
22 #include "interfaces/native/node/event_converter.h"
23 #include "interfaces/native/node/node_model.h"
24 #include "base/error/error_code.h"
25
26 #ifdef __cplusplus
27 extern "C" {
28 #endif
isCurrentCTouchEventParamValid(const ArkUITouchEvent * touchEvent,uint32_t pointerIndex)29 bool isCurrentCTouchEventParamValid(const ArkUITouchEvent* touchEvent, uint32_t pointerIndex)
30 {
31 if (!touchEvent) {
32 return false;
33 }
34 if ((pointerIndex < 0 || pointerIndex >= touchEvent->touchPointSize) ||
35 !(touchEvent->touchPointes)) {
36 return false;
37 }
38 return true;
39 }
40
isHistoryCTouchEventParamValid(const ArkUITouchEvent * touchEvent,uint32_t historyIndex,uint32_t pointerIndex)41 bool isHistoryCTouchEventParamValid(const ArkUITouchEvent* touchEvent, uint32_t historyIndex, uint32_t pointerIndex)
42 {
43 if (!touchEvent) {
44 return false;
45 }
46 if ((historyIndex < 0 || historyIndex >= touchEvent->historySize) ||
47 !touchEvent->historyEvents) {
48 return false;
49 }
50 if ((pointerIndex < 0 || pointerIndex >= touchEvent->historyEvents[historyIndex].touchPointSize) ||
51 !(touchEvent->historyEvents[historyIndex].touchPointes)) {
52 return false;
53 }
54 return true;
55 }
56
OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent * event)57 int32_t OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent* event)
58 {
59 if (!event) {
60 return 0;
61 }
62 return event->inputType;
63 }
64
OH_ArkUI_UIInputEvent_GetAction(const ArkUI_UIInputEvent * event)65 int32_t OH_ArkUI_UIInputEvent_GetAction(const ArkUI_UIInputEvent* event)
66 {
67 if (!event) {
68 return -1;
69 }
70 switch (event->eventTypeId) {
71 case C_TOUCH_EVENT_ID: {
72 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
73 if (!touchEvent) {
74 return -1;
75 }
76 return OHOS::Ace::NodeModel::ConvertToCTouchActionType(touchEvent->action);
77 }
78 case C_MOUSE_EVENT_ID: {
79 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
80 if (!mouseEvent) {
81 return -1;
82 }
83 return OHOS::Ace::NodeModel::ConvertToCMouseActionType(mouseEvent->action);
84 }
85 default:
86 break;
87 }
88 return -1;
89 }
90
OH_ArkUI_UIInputEvent_GetSourceType(const ArkUI_UIInputEvent * event)91 int32_t OH_ArkUI_UIInputEvent_GetSourceType(const ArkUI_UIInputEvent* event)
92 {
93 if (!event) {
94 return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
95 }
96 switch (event->eventTypeId) {
97 case C_TOUCH_EVENT_ID: {
98 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
99 if (!touchEvent) {
100 return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
101 }
102 return touchEvent->sourceType;
103 }
104 case C_MOUSE_EVENT_ID: {
105 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
106 if (!mouseEvent) {
107 return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
108 }
109 return mouseEvent->sourceType;
110 }
111 case C_AXIS_EVENT_ID: {
112 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
113 if (!axisEvent) {
114 return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
115 }
116 return axisEvent->sourceType;
117 }
118 case C_FOCUS_AXIS_EVENT_ID: {
119 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
120 if (!focusAxisEvent) {
121 return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
122 }
123 return focusAxisEvent->sourceType;
124 }
125 case AXIS_EVENT_ID: {
126 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
127 if (!axisEvent) {
128 return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
129 }
130 return static_cast<int32_t>(axisEvent->sourceType);
131 }
132 default:
133 break;
134 }
135 return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
136 }
137
OH_ArkUI_UIInputEvent_GetToolType(const ArkUI_UIInputEvent * event)138 int32_t OH_ArkUI_UIInputEvent_GetToolType(const ArkUI_UIInputEvent* event)
139 {
140 if (!event) {
141 return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
142 }
143 switch (event->eventTypeId) {
144 case C_TOUCH_EVENT_ID: {
145 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
146 if (!touchEvent) {
147 return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
148 }
149 return OHOS::Ace::NodeModel::ConvertToCInputEventToolType(touchEvent->actionTouchPoint.toolType);
150 }
151 case C_MOUSE_EVENT_ID: {
152 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
153 if (!mouseEvent) {
154 return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
155 }
156 return OHOS::Ace::NodeModel::ConvertToCInputEventToolType(mouseEvent->actionTouchPoint.toolType);
157 }
158 case C_AXIS_EVENT_ID: {
159 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
160 if (!axisEvent) {
161 return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
162 }
163 return OHOS::Ace::NodeModel::ConvertToCInputEventToolType(axisEvent->actionTouchPoint.toolType);
164 }
165 case C_FOCUS_AXIS_EVENT_ID: {
166 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
167 if (!focusAxisEvent) {
168 return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
169 }
170 return OHOS::Ace::NodeModel::ConvertToCInputEventToolType(focusAxisEvent->toolType);
171 }
172 case AXIS_EVENT_ID: {
173 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
174 if (!axisEvent) {
175 return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
176 }
177 return OHOS::Ace::NodeModel::ConvertToCInputEventToolType(static_cast<int32_t>(axisEvent->sourceTool));
178 }
179 default:
180 break;
181 }
182 return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
183 }
184
HandleCTouchEvent(ArkUI_UIInputEvent * event)185 int64_t HandleCTouchEvent(ArkUI_UIInputEvent* event)
186 {
187 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
188 if (!touchEvent) {
189 return 0;
190 }
191 return touchEvent->timeStamp;
192 }
193
HandleTouchEvent(ArkUI_UIInputEvent * event)194 int64_t HandleTouchEvent(ArkUI_UIInputEvent* event)
195 {
196 const auto* uiEvent = reinterpret_cast<const OHOS::Ace::PointerEvent*>(event->inputEvent);
197 if (!uiEvent) {
198 LOGE("The parameter of OH_ArkUI_UIInputEvent_GetEventTime is invalid");
199 return 0;
200 }
201 return uiEvent->time.time_since_epoch().count();
202 }
203
HandleAxisEvent(ArkUI_UIInputEvent * event)204 int64_t HandleAxisEvent(ArkUI_UIInputEvent* event)
205 {
206 const auto* uiEvent = reinterpret_cast<const OHOS::Ace::PointerEvent*>(event->inputEvent);
207 if (!uiEvent) {
208 LOGE("The parameter of OH_ArkUI_UIInputEvent_GetEventTime is invalid");
209 return 0;
210 }
211 return uiEvent->time.time_since_epoch().count();
212 }
213
HandleCMouseEvent(ArkUI_UIInputEvent * event)214 int64_t HandleCMouseEvent(ArkUI_UIInputEvent* event)
215 {
216 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
217 if (!mouseEvent) {
218 return 0;
219 }
220 return mouseEvent->timeStamp;
221 }
222
HandleCAxisEvent(ArkUI_UIInputEvent * event)223 int64_t HandleCAxisEvent(ArkUI_UIInputEvent* event)
224 {
225 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
226 if (!axisEvent) {
227 return 0;
228 }
229 return axisEvent->timeStamp;
230 }
231
HandleCKeyEvent(ArkUI_UIInputEvent * event)232 int64_t HandleCKeyEvent(ArkUI_UIInputEvent* event)
233 {
234 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
235 if (!keyEvent) {
236 return 0;
237 }
238 return keyEvent->timestamp;
239 }
240
HandleCFocusAxisEvent(ArkUI_UIInputEvent * event)241 int64_t HandleCFocusAxisEvent(ArkUI_UIInputEvent* event)
242 {
243 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
244 if (!focusAxisEvent) {
245 return 0;
246 }
247 return focusAxisEvent->timeStamp;
248 }
249
OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent * event)250 int64_t OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent* event)
251 {
252 if (!event) {
253 return 0;
254 }
255 std::map<ArkUIEventTypeId, std::function<int64_t(ArkUI_UIInputEvent*)>> eventHandlers = {
256 {C_TOUCH_EVENT_ID, HandleCTouchEvent},
257 {TOUCH_EVENT_ID, HandleTouchEvent},
258 {AXIS_EVENT_ID, HandleAxisEvent},
259 {C_MOUSE_EVENT_ID, HandleCMouseEvent},
260 {C_AXIS_EVENT_ID, HandleCAxisEvent},
261 {C_KEY_EVENT_ID, HandleCKeyEvent},
262 {C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEvent},
263 };
264 auto it = eventHandlers.find(event->eventTypeId);
265 if (it != eventHandlers.end()) {
266 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
267 return it->second(inputEvent);
268 }
269 return 0;
270 }
271
GetCKeyEventDeviceId(ArkUI_UIInputEvent * event)272 int32_t GetCKeyEventDeviceId(ArkUI_UIInputEvent* event)
273 {
274 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
275 if (!keyEvent) {
276 return -1;
277 }
278 return static_cast<int32_t>(keyEvent->deviceId);
279 }
280
GetCFocusAxisEventDeviceId(ArkUI_UIInputEvent * event)281 int32_t GetCFocusAxisEventDeviceId(ArkUI_UIInputEvent* event)
282 {
283 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
284 if (!focusAxisEvent) {
285 return -1;
286 }
287 return static_cast<int32_t>(focusAxisEvent->deviceId);
288 }
289
OH_ArkUI_UIInputEvent_GetDeviceId(const ArkUI_UIInputEvent * event)290 int32_t OH_ArkUI_UIInputEvent_GetDeviceId(const ArkUI_UIInputEvent *event)
291 {
292 if (!event) {
293 return -1;
294 }
295 std::map<ArkUIEventTypeId, std::function<int64_t(ArkUI_UIInputEvent*)>> eventHandlers = {
296 {C_KEY_EVENT_ID, GetCKeyEventDeviceId},
297 {C_FOCUS_AXIS_EVENT_ID, GetCFocusAxisEventDeviceId},
298 };
299 auto iter = eventHandlers.find(event->eventTypeId);
300 if (iter != eventHandlers.end()) {
301 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
302 return iter->second(inputEvent);
303 }
304 return -1;
305 }
306
OH_ArkUI_UIInputEvent_GetPressedKeys(const ArkUI_UIInputEvent * event,int32_t * pressedKeyCodes,int32_t * length)307 int32_t OH_ArkUI_UIInputEvent_GetPressedKeys(
308 const ArkUI_UIInputEvent* event, int32_t* pressedKeyCodes, int32_t* length)
309 {
310 if (!event || !pressedKeyCodes || !length) {
311 return ARKUI_ERROR_CODE_PARAM_INVALID;
312 }
313 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
314 if (!keyEvent) {
315 return ARKUI_ERROR_CODE_PARAM_INVALID;
316 }
317 auto inputLength = *length;
318 if (keyEvent->keyCodesLength > inputLength) {
319 return ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH;
320 }
321 *length = keyEvent->keyCodesLength;
322 for (int i = 0; i < keyEvent->keyCodesLength; i++) {
323 pressedKeyCodes[i] = keyEvent->pressedKeyCodes[i];
324 }
325 return ARKUI_ERROR_CODE_NO_ERROR;
326 }
327
OH_ArkUI_PointerEvent_GetPointerCount(const ArkUI_UIInputEvent * event)328 uint32_t OH_ArkUI_PointerEvent_GetPointerCount(const ArkUI_UIInputEvent* event)
329 {
330 if (!event) {
331 return 0;
332 }
333 switch (event->eventTypeId) {
334 case C_TOUCH_EVENT_ID: {
335 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
336 if (!touchEvent) {
337 return 0;
338 }
339 return touchEvent->touchPointSize;
340 }
341 case C_MOUSE_EVENT_ID: {
342 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
343 if (!mouseEvent) {
344 return 0;
345 }
346 return 1;
347 }
348 case C_AXIS_EVENT_ID: {
349 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
350 if (!axisEvent) {
351 return 0;
352 }
353 return 1;
354 }
355 default:
356 break;
357 }
358 return 0;
359 }
360
OH_ArkUI_PointerEvent_GetPointerId(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)361 int32_t OH_ArkUI_PointerEvent_GetPointerId(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
362 {
363 if (!event) {
364 return 0;
365 }
366 switch (event->eventTypeId) {
367 case C_TOUCH_EVENT_ID: {
368 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
369 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
370 return 0;
371 }
372 return touchEvent->touchPointes[pointerIndex].id;
373 }
374 case C_MOUSE_EVENT_ID: {
375 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
376 if (!mouseEvent || pointerIndex != 0) {
377 return 0;
378 }
379 return mouseEvent->actionTouchPoint.id;
380 }
381 case C_AXIS_EVENT_ID: {
382 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
383 if (!axisEvent || pointerIndex != 0) {
384 return 0;
385 }
386 return axisEvent->actionTouchPoint.id;
387 }
388 default:
389 break;
390 }
391 return 0;
392 }
393
OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent * event)394 float OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent* event)
395 {
396 if (!event) {
397 return 0.0f;
398 }
399 switch (event->eventTypeId) {
400 case C_TOUCH_EVENT_ID: {
401 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
402 if (!touchEvent) {
403 return 0.0f;
404 }
405 return touchEvent->actionTouchPoint.nodeX;
406 }
407 case TOUCH_EVENT_ID: {
408 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
409 if (touchEvent) {
410 return touchEvent->localX;
411 }
412 break;
413 }
414 case AXIS_EVENT_ID: {
415 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
416 if (axisEvent) {
417 return axisEvent->localX;
418 }
419 break;
420 }
421 case C_MOUSE_EVENT_ID: {
422 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
423 if (!mouseEvent) {
424 return 0.0f;
425 }
426 return mouseEvent->actionTouchPoint.nodeX;
427 }
428 case C_AXIS_EVENT_ID: {
429 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
430 if (!axisEvent) {
431 return 0.0f;
432 }
433 return axisEvent->actionTouchPoint.nodeX;
434 }
435 default:
436 break;
437 }
438 return 0.0f;
439 }
440
OH_ArkUI_PointerEvent_GetXByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)441 float OH_ArkUI_PointerEvent_GetXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
442 {
443 if (!event) {
444 return 0.0f;
445 }
446 switch (event->eventTypeId) {
447 case C_TOUCH_EVENT_ID: {
448 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
449 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
450 return 0.0f;
451 }
452 return touchEvent->touchPointes[pointerIndex].nodeX;
453 }
454 case C_MOUSE_EVENT_ID: {
455 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
456 if (!mouseEvent || pointerIndex != 0) {
457 return 0.0f;
458 }
459 return mouseEvent->actionTouchPoint.nodeX;
460 }
461 case C_AXIS_EVENT_ID: {
462 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
463 if (!axisEvent || pointerIndex != 0) {
464 return 0.0f;
465 }
466 return axisEvent->actionTouchPoint.nodeX;
467 }
468 default:
469 break;
470 }
471 return 0.0f;
472 }
473
OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent * event)474 float OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent* event)
475 {
476 if (!event) {
477 return 0.0f;
478 }
479 switch (event->eventTypeId) {
480 case C_TOUCH_EVENT_ID: {
481 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
482 if (!touchEvent) {
483 return 0.0f;
484 }
485 return touchEvent->actionTouchPoint.nodeY;
486 }
487 case TOUCH_EVENT_ID: {
488 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
489 if (touchEvent) {
490 return touchEvent->localY;
491 }
492 break;
493 }
494 case AXIS_EVENT_ID: {
495 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
496 if (axisEvent) {
497 return axisEvent->localY;
498 }
499 break;
500 }
501 case C_MOUSE_EVENT_ID: {
502 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
503 if (!mouseEvent) {
504 return 0.0f;
505 }
506 return mouseEvent->actionTouchPoint.nodeY;
507 }
508 case C_AXIS_EVENT_ID: {
509 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
510 if (!axisEvent) {
511 return 0.0f;
512 }
513 return axisEvent->actionTouchPoint.nodeY;
514 }
515 default:
516 break;
517 }
518 LOGE("The parameter of OH_ArkUI_PointerEvent_GetY is invalid");
519 return 0.0f;
520 }
521
OH_ArkUI_PointerEvent_GetYByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)522 float OH_ArkUI_PointerEvent_GetYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
523 {
524 if (!event) {
525 return 0.0f;
526 }
527 switch (event->eventTypeId) {
528 case C_TOUCH_EVENT_ID: {
529 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
530 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
531 return 0.0f;
532 }
533 return touchEvent->touchPointes[pointerIndex].nodeY;
534 }
535 case C_MOUSE_EVENT_ID: {
536 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
537 if (!mouseEvent || pointerIndex != 0) {
538 return 0.0f;
539 }
540 return mouseEvent->actionTouchPoint.nodeY;
541 }
542 case C_AXIS_EVENT_ID: {
543 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
544 if (!axisEvent || pointerIndex != 0) {
545 return 0.0f;
546 }
547 return axisEvent->actionTouchPoint.nodeY;
548 }
549 default:
550 break;
551 }
552 return 0.0f;
553 }
554
OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent * event)555 float OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent* event)
556 {
557 if (!event) {
558 return 0.0f;
559 }
560 switch (event->eventTypeId) {
561 case C_TOUCH_EVENT_ID: {
562 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
563 if (!touchEvent) {
564 return 0.0f;
565 }
566 return touchEvent->actionTouchPoint.windowX;
567 }
568 case TOUCH_EVENT_ID: {
569 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
570 if (touchEvent) {
571 return touchEvent->x;
572 }
573 break;
574 }
575 case AXIS_EVENT_ID: {
576 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
577 if (axisEvent) {
578 return axisEvent->x;
579 }
580 break;
581 }
582 case C_MOUSE_EVENT_ID: {
583 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
584 if (!mouseEvent) {
585 return 0.0f;
586 }
587 return mouseEvent->actionTouchPoint.windowX;
588 }
589 case C_AXIS_EVENT_ID: {
590 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
591 if (!axisEvent) {
592 return 0.0f;
593 }
594 return axisEvent->actionTouchPoint.windowX;
595 }
596 default:
597 break;
598 }
599 LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowX is invalid");
600 return 0.0f;
601 }
602
OH_ArkUI_PointerEvent_GetWindowXByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)603 float OH_ArkUI_PointerEvent_GetWindowXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
604 {
605 if (!event) {
606 return 0.0f;
607 }
608 switch (event->eventTypeId) {
609 case C_TOUCH_EVENT_ID: {
610 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
611 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
612 return 0.0f;
613 }
614 return touchEvent->touchPointes[pointerIndex].windowX;
615 }
616 case C_MOUSE_EVENT_ID: {
617 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
618 if (!mouseEvent || pointerIndex != 0) {
619 return 0.0f;
620 }
621 return mouseEvent->actionTouchPoint.windowX;
622 }
623 case C_AXIS_EVENT_ID: {
624 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
625 if (!axisEvent || pointerIndex != 0) {
626 return 0.0f;
627 }
628 return axisEvent->actionTouchPoint.windowX;
629 }
630 default:
631 break;
632 }
633 return 0.0f;
634 }
635
OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent * event)636 float OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent* event)
637 {
638 if (!event) {
639 return 0.0f;
640 }
641 switch (event->eventTypeId) {
642 case C_TOUCH_EVENT_ID: {
643 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
644 if (!touchEvent) {
645 return 0.0f;
646 }
647 return touchEvent->actionTouchPoint.windowY;
648 }
649 case TOUCH_EVENT_ID: {
650 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
651 if (touchEvent) {
652 return touchEvent->y;
653 }
654 break;
655 }
656 case AXIS_EVENT_ID: {
657 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
658 if (axisEvent) {
659 return axisEvent->y;
660 }
661 break;
662 }
663 case C_MOUSE_EVENT_ID: {
664 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
665 if (!mouseEvent) {
666 return 0.0f;
667 }
668 return mouseEvent->actionTouchPoint.windowY;
669 }
670 case C_AXIS_EVENT_ID: {
671 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
672 if (!axisEvent) {
673 return 0.0f;
674 }
675 return axisEvent->actionTouchPoint.windowY;
676 }
677 default:
678 break;
679 }
680 LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowY is invalid");
681 return 0.0f;
682 }
683
OH_ArkUI_PointerEvent_GetWindowYByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)684 float OH_ArkUI_PointerEvent_GetWindowYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
685 {
686 if (!event) {
687 return 0.0f;
688 }
689 switch (event->eventTypeId) {
690 case C_TOUCH_EVENT_ID: {
691 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
692 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
693 return 0.0f;
694 }
695 return touchEvent->touchPointes[pointerIndex].windowY;
696 }
697 case C_MOUSE_EVENT_ID: {
698 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
699 if (!mouseEvent || pointerIndex != 0) {
700 return 0.0f;
701 }
702 return mouseEvent->actionTouchPoint.windowY;
703 }
704 case C_AXIS_EVENT_ID: {
705 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
706 if (!axisEvent || pointerIndex != 0) {
707 return 0.0f;
708 }
709 return axisEvent->actionTouchPoint.windowY;
710 }
711 default:
712 break;
713 }
714 return 0.0f;
715 }
716
OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent * event)717 float OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent* event)
718 {
719 if (!event) {
720 return 0.0f;
721 }
722 switch (event->eventTypeId) {
723 case C_TOUCH_EVENT_ID: {
724 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
725 if (!touchEvent) {
726 return 0.0f;
727 }
728 return touchEvent->actionTouchPoint.screenX;
729 }
730 case TOUCH_EVENT_ID: {
731 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
732 if (touchEvent) {
733 return touchEvent->screenX;
734 }
735 break;
736 }
737 case AXIS_EVENT_ID: {
738 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
739 if (axisEvent) {
740 return axisEvent->screenX;
741 }
742 break;
743 }
744 case C_MOUSE_EVENT_ID: {
745 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
746 if (!mouseEvent) {
747 return 0.0f;
748 }
749 return mouseEvent->actionTouchPoint.screenX;
750 }
751 case C_AXIS_EVENT_ID: {
752 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
753 if (!axisEvent) {
754 return 0.0f;
755 }
756 return axisEvent->actionTouchPoint.screenX;
757 }
758 default:
759 break;
760 }
761 LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayX is invalid");
762 return 0.0f;
763 }
764
OH_ArkUI_PointerEvent_GetDisplayXByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)765 float OH_ArkUI_PointerEvent_GetDisplayXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
766 {
767 if (!event) {
768 return 0.0f;
769 }
770 switch (event->eventTypeId) {
771 case C_TOUCH_EVENT_ID: {
772 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
773 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
774 return 0.0f;
775 }
776 return touchEvent->touchPointes[pointerIndex].screenX;
777 }
778 case C_MOUSE_EVENT_ID: {
779 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
780 if (!mouseEvent || pointerIndex != 0) {
781 return 0.0f;
782 }
783 return mouseEvent->actionTouchPoint.screenX;
784 }
785 case C_AXIS_EVENT_ID: {
786 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
787 if (!axisEvent || pointerIndex != 0) {
788 return 0.0f;
789 }
790 return axisEvent->actionTouchPoint.screenX;
791 }
792 default:
793 break;
794 }
795 return 0.0f;
796 }
797
OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent * event)798 float OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent* event)
799 {
800 if (!event) {
801 return 0.0f;
802 }
803 switch (event->eventTypeId) {
804 case C_TOUCH_EVENT_ID: {
805 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
806 if (!touchEvent) {
807 return 0.0f;
808 }
809 return touchEvent->actionTouchPoint.screenY;
810 }
811 case TOUCH_EVENT_ID: {
812 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
813 if (touchEvent) {
814 return touchEvent->screenY;
815 }
816 break;
817 }
818 case AXIS_EVENT_ID: {
819 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
820 if (axisEvent) {
821 return axisEvent->screenY;
822 }
823 break;
824 }
825 case C_MOUSE_EVENT_ID: {
826 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
827 if (!mouseEvent) {
828 return 0.0f;
829 }
830 return mouseEvent->actionTouchPoint.screenY;
831 }
832 case C_AXIS_EVENT_ID: {
833 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
834 if (!axisEvent) {
835 return 0.0f;
836 }
837 return axisEvent->actionTouchPoint.screenY;
838 }
839 default:
840 break;
841 }
842 LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayY is invalid");
843 return 0.0f;
844 }
845
OH_ArkUI_PointerEvent_GetDisplayYByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)846 float OH_ArkUI_PointerEvent_GetDisplayYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
847 {
848 if (!event) {
849 return 0.0f;
850 }
851 switch (event->eventTypeId) {
852 case C_TOUCH_EVENT_ID: {
853 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
854 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
855 return 0.0f;
856 }
857 return touchEvent->touchPointes[pointerIndex].screenY;
858 }
859 case C_MOUSE_EVENT_ID: {
860 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
861 if (!mouseEvent || pointerIndex != 0) {
862 return 0.0f;
863 }
864 return mouseEvent->actionTouchPoint.screenY;
865 }
866 case C_AXIS_EVENT_ID: {
867 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
868 if (!axisEvent || pointerIndex != 0) {
869 return 0.0f;
870 }
871 return axisEvent->actionTouchPoint.screenY;
872 }
873 default:
874 break;
875 }
876 return 0.0f;
877 }
878
OH_ArkUI_PointerEvent_GetPressure(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)879 float OH_ArkUI_PointerEvent_GetPressure(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
880 {
881 if (!event) {
882 return 0.0f;
883 }
884 switch (event->eventTypeId) {
885 case C_TOUCH_EVENT_ID: {
886 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
887 if (!touchEvent || touchEvent->touchPointSize <= 0) {
888 return 0.0f;
889 }
890 return touchEvent->touchPointes[touchEvent->touchPointSize-1].pressure;
891 }
892 default:
893 break;
894 }
895 return 0.0f;
896 }
897
OH_ArkUI_PointerEvent_GetTiltX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)898 float OH_ArkUI_PointerEvent_GetTiltX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
899 {
900 if (!event) {
901 return 0.0f;
902 }
903 switch (event->eventTypeId) {
904 case C_TOUCH_EVENT_ID: {
905 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
906 if (!touchEvent || touchEvent->touchPointSize <= 0) {
907 return 0.0f;
908 }
909 return touchEvent->touchPointes[touchEvent->touchPointSize-1].tiltX;
910 }
911 default:
912 break;
913 }
914 return 0.0f;
915 }
916
OH_ArkUI_PointerEvent_GetTiltY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)917 float OH_ArkUI_PointerEvent_GetTiltY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
918 {
919 if (!event) {
920 return 0.0f;
921 }
922 switch (event->eventTypeId) {
923 case C_TOUCH_EVENT_ID: {
924 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
925 if (!touchEvent || touchEvent->touchPointSize <= 0) {
926 return 0.0f;
927 }
928 return touchEvent->touchPointes[touchEvent->touchPointSize-1].tiltY;
929 }
930 default:
931 break;
932 }
933 return 0.0f;
934 }
935
OH_ArkUI_PointerEvent_GetInteractionHand(const ArkUI_UIInputEvent * event,ArkUI_InteractionHand * hand)936 int32_t OH_ArkUI_PointerEvent_GetInteractionHand(const ArkUI_UIInputEvent *event, ArkUI_InteractionHand *hand)
937 {
938 if (!event || !hand) {
939 return ARKUI_ERROR_CODE_PARAM_INVALID;
940 }
941 switch (event->eventTypeId) {
942 case C_TOUCH_EVENT_ID: {
943 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
944 *hand = static_cast<ArkUI_InteractionHand>(touchEvent->actionTouchPoint.operatingHand);
945 break;
946 }
947 default:
948 break;
949 }
950 return ARKUI_ERROR_CODE_NO_ERROR;
951 }
952
OH_ArkUI_PointerEvent_GetInteractionHandByIndex(const ArkUI_UIInputEvent * event,int32_t pointerIndex,ArkUI_InteractionHand * hand)953 int32_t OH_ArkUI_PointerEvent_GetInteractionHandByIndex(const ArkUI_UIInputEvent *event, int32_t pointerIndex,
954 ArkUI_InteractionHand *hand)
955 {
956 if (!event || !hand) {
957 return ARKUI_ERROR_CODE_PARAM_INVALID;
958 }
959
960 switch (event->eventTypeId) {
961 case C_TOUCH_EVENT_ID: {
962 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
963 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
964 return ARKUI_ERROR_CODE_PARAM_INVALID;
965 }
966 *hand = static_cast<ArkUI_InteractionHand>(touchEvent->touchPointes[pointerIndex].operatingHand);
967 break;
968 }
969 default:
970 break;
971 }
972 return ARKUI_ERROR_CODE_NO_ERROR;
973 }
974
OH_ArkUI_PointerEvent_GetTouchAreaWidth(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)975 float OH_ArkUI_PointerEvent_GetTouchAreaWidth(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
976 {
977 if (!event) {
978 return 0.0f;
979 }
980 switch (event->eventTypeId) {
981 case C_TOUCH_EVENT_ID: {
982 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
983 if (!touchEvent || touchEvent->touchPointSize <= 0) {
984 return 0.0f;
985 }
986 return touchEvent->touchPointes[touchEvent->touchPointSize-1].contactAreaWidth;
987 }
988 default:
989 break;
990 }
991 return 0.0f;
992 }
993
OH_ArkUI_PointerEvent_GetTouchAreaHeight(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)994 float OH_ArkUI_PointerEvent_GetTouchAreaHeight(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
995 {
996 if (!event) {
997 return 0.0f;
998 }
999 switch (event->eventTypeId) {
1000 case C_TOUCH_EVENT_ID: {
1001 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1002 if (!touchEvent || touchEvent->touchPointSize <= 0) {
1003 return 0.0f;
1004 }
1005 return touchEvent->touchPointes[touchEvent->touchPointSize-1].contactAreaHeight;
1006 }
1007 default:
1008 break;
1009 }
1010 return 0.0f;
1011 }
1012
OH_ArkUI_PointerEvent_GetChangedPointerId(const ArkUI_UIInputEvent * event,uint32_t * pointerIndex)1013 int32_t OH_ArkUI_PointerEvent_GetChangedPointerId(const ArkUI_UIInputEvent* event, uint32_t* pointerIndex)
1014 {
1015 if (!event || !pointerIndex) {
1016 return ARKUI_ERROR_CODE_PARAM_INVALID;
1017 }
1018 switch (event->eventTypeId) {
1019 case C_TOUCH_EVENT_ID: {
1020 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1021 if (!touchEvent || touchEvent->touchPointSize <= 0) {
1022 return ARKUI_ERROR_CODE_PARAM_INVALID;
1023 }
1024 *pointerIndex = touchEvent->changedPointerId;
1025 return ARKUI_ERROR_CODE_NO_ERROR;
1026 }
1027 default:
1028 break;
1029 }
1030 return ARKUI_ERROR_CODE_PARAM_INVALID;
1031 }
1032
OH_ArkUI_PointerEvent_GetHistorySize(const ArkUI_UIInputEvent * event)1033 uint32_t OH_ArkUI_PointerEvent_GetHistorySize(const ArkUI_UIInputEvent* event)
1034 {
1035 if (!event) {
1036 return 0;
1037 }
1038 switch (event->eventTypeId) {
1039 case C_TOUCH_EVENT_ID: {
1040 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1041 if (!touchEvent || !touchEvent->historyEvents) {
1042 return 0;
1043 }
1044 return touchEvent->historySize;
1045 }
1046 default:
1047 break;
1048 }
1049 return 0;
1050 }
1051
OH_ArkUI_PointerEvent_GetHistoryEventTime(const ArkUI_UIInputEvent * event,uint32_t historyIndex)1052 int64_t OH_ArkUI_PointerEvent_GetHistoryEventTime(const ArkUI_UIInputEvent* event, uint32_t historyIndex)
1053 {
1054 if (!event) {
1055 return 0;
1056 }
1057 switch (event->eventTypeId) {
1058 case C_TOUCH_EVENT_ID: {
1059 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1060 if (!touchEvent || !touchEvent->historyEvents || touchEvent->historySize <= historyIndex ||
1061 historyIndex < 0) {
1062 return 0;
1063 }
1064 return touchEvent->historyEvents[historyIndex].timeStamp;
1065 }
1066 default:
1067 break;
1068 }
1069 return 0;
1070 }
1071
OH_ArkUI_PointerEvent_GetHistoryPointerCount(const ArkUI_UIInputEvent * event,uint32_t historyIndex)1072 uint32_t OH_ArkUI_PointerEvent_GetHistoryPointerCount(const ArkUI_UIInputEvent* event, uint32_t historyIndex)
1073 {
1074 if (!event) {
1075 return 0;
1076 }
1077 switch (event->eventTypeId) {
1078 case C_TOUCH_EVENT_ID: {
1079 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1080 if (!touchEvent || !touchEvent->historyEvents || touchEvent->historySize <= historyIndex ||
1081 historyIndex < 0) {
1082 return 0;
1083 }
1084 return touchEvent->historyEvents[historyIndex].touchPointSize;
1085 }
1086 default:
1087 break;
1088 }
1089 return 0;
1090 }
1091
OH_ArkUI_PointerEvent_GetHistoryPointerId(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1092 int32_t OH_ArkUI_PointerEvent_GetHistoryPointerId(
1093 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1094 {
1095 if (!event) {
1096 return 0;
1097 }
1098 switch (event->eventTypeId) {
1099 case C_TOUCH_EVENT_ID: {
1100 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1101 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1102 return 0;
1103 }
1104 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].id;
1105 }
1106 default:
1107 break;
1108 }
1109 return 0;
1110 }
1111
OH_ArkUI_PointerEvent_GetHistoryX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1112 float OH_ArkUI_PointerEvent_GetHistoryX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1113 {
1114 if (!event) {
1115 return 0.0f;
1116 }
1117 switch (event->eventTypeId) {
1118 case C_TOUCH_EVENT_ID: {
1119 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1120 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1121 return 0.0f;
1122 }
1123 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].nodeX;
1124 }
1125 default:
1126 break;
1127 }
1128 return 0.0f;
1129 }
1130
OH_ArkUI_PointerEvent_GetHistoryY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1131 float OH_ArkUI_PointerEvent_GetHistoryY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1132 {
1133 if (!event) {
1134 return 0.0f;
1135 }
1136 switch (event->eventTypeId) {
1137 case C_TOUCH_EVENT_ID: {
1138 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1139 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1140 return 0.0f;
1141 }
1142 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].nodeY;
1143 }
1144 default:
1145 break;
1146 }
1147 return 0.0f;
1148 }
1149
OH_ArkUI_PointerEvent_GetHistoryWindowX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1150 float OH_ArkUI_PointerEvent_GetHistoryWindowX(
1151 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1152 {
1153 if (!event) {
1154 return 0.0f;
1155 }
1156 switch (event->eventTypeId) {
1157 case C_TOUCH_EVENT_ID: {
1158 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1159 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1160 return 0.0f;
1161 }
1162 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].windowX;
1163 }
1164 default:
1165 break;
1166 }
1167 return 0.0f;
1168 }
1169
OH_ArkUI_PointerEvent_GetHistoryWindowY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1170 float OH_ArkUI_PointerEvent_GetHistoryWindowY(
1171 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1172 {
1173 if (!event) {
1174 return 0.0f;
1175 }
1176 switch (event->eventTypeId) {
1177 case C_TOUCH_EVENT_ID: {
1178 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1179 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1180 return 0.0f;
1181 }
1182 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].windowY;
1183 }
1184 default:
1185 break;
1186 }
1187 return 0.0f;
1188 }
1189
OH_ArkUI_PointerEvent_GetHistoryDisplayX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1190 float OH_ArkUI_PointerEvent_GetHistoryDisplayX(
1191 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1192 {
1193 if (!event) {
1194 return 0.0f;
1195 }
1196 switch (event->eventTypeId) {
1197 case C_TOUCH_EVENT_ID: {
1198 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1199 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1200 return 0.0f;
1201 }
1202 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].screenX;
1203 }
1204 default:
1205 break;
1206 }
1207 return 0.0f;
1208 }
1209
OH_ArkUI_PointerEvent_GetHistoryDisplayY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1210 float OH_ArkUI_PointerEvent_GetHistoryDisplayY(
1211 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1212 {
1213 if (!event) {
1214 return 0.0f;
1215 }
1216 switch (event->eventTypeId) {
1217 case C_TOUCH_EVENT_ID: {
1218 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1219 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1220 return 0.0f;
1221 }
1222 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].screenY;
1223 }
1224 default:
1225 break;
1226 }
1227 return 0.0f;
1228 }
1229
OH_ArkUI_PointerEvent_GetHistoryPressure(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1230 float OH_ArkUI_PointerEvent_GetHistoryPressure(
1231 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1232 {
1233 if (!event) {
1234 return 0.0f;
1235 }
1236 switch (event->eventTypeId) {
1237 case C_TOUCH_EVENT_ID: {
1238 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1239 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1240 return 0.0f;
1241 }
1242 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].pressure;
1243 }
1244 default:
1245 break;
1246 }
1247 return 0.0f;
1248 }
1249
OH_ArkUI_PointerEvent_GetHistoryTiltX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1250 float OH_ArkUI_PointerEvent_GetHistoryTiltX(
1251 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1252 {
1253 if (!event) {
1254 return 0.0f;
1255 }
1256 switch (event->eventTypeId) {
1257 case C_TOUCH_EVENT_ID: {
1258 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1259 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1260 return 0.0f;
1261 }
1262 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].tiltX;
1263 }
1264 default:
1265 break;
1266 }
1267 return 0.0f;
1268 }
1269
OH_ArkUI_PointerEvent_GetHistoryTiltY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1270 float OH_ArkUI_PointerEvent_GetHistoryTiltY(
1271 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1272 {
1273 if (!event) {
1274 return 0.0f;
1275 }
1276 switch (event->eventTypeId) {
1277 case C_TOUCH_EVENT_ID: {
1278 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1279 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1280 return 0.0f;
1281 }
1282 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].tiltY;
1283 }
1284 default:
1285 break;
1286 }
1287 return 0.0f;
1288 }
1289
OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1290 float OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(
1291 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1292 {
1293 if (!event) {
1294 return 0.0f;
1295 }
1296 switch (event->eventTypeId) {
1297 case C_TOUCH_EVENT_ID: {
1298 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1299 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1300 return 0.0f;
1301 }
1302 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].contactAreaWidth;
1303 }
1304 default:
1305 break;
1306 }
1307 return 0.0f;
1308 }
1309
OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)1310 float OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(
1311 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1312 {
1313 if (!event) {
1314 return 0.0f;
1315 }
1316 switch (event->eventTypeId) {
1317 case C_TOUCH_EVENT_ID: {
1318 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1319 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1320 return 0.0f;
1321 }
1322 return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].contactAreaHeight;
1323 }
1324 default:
1325 break;
1326 }
1327 return 0.0f;
1328 }
1329
OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent * event)1330 double OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent* event)
1331 {
1332 if (!event) {
1333 return 0.0;
1334 }
1335 switch (event->eventTypeId) {
1336 case AXIS_EVENT_ID: {
1337 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1338 if (axisEvent) {
1339 return axisEvent->verticalAxis;
1340 }
1341 break;
1342 }
1343 case C_AXIS_EVENT_ID: {
1344 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1345 if (!axisEvent) {
1346 return 0.0;
1347 }
1348 return axisEvent->verticalAxis;
1349 }
1350 default:
1351 break;
1352 }
1353 return 0.0;
1354 }
1355
OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent * event)1356 double OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent* event)
1357 {
1358 if (!event) {
1359 return 0.0;
1360 }
1361 switch (event->eventTypeId) {
1362 case AXIS_EVENT_ID: {
1363 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1364 if (axisEvent) {
1365 return axisEvent->horizontalAxis;
1366 }
1367 break;
1368 }
1369 case C_AXIS_EVENT_ID: {
1370 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1371 if (!axisEvent) {
1372 return 0.0;
1373 }
1374 return axisEvent->horizontalAxis;
1375 }
1376 default:
1377 break;
1378 }
1379 return 0.0;
1380 }
1381
OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent * event)1382 double OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent* event)
1383 {
1384 if (!event) {
1385 return 0.0;
1386 }
1387 switch (event->eventTypeId) {
1388 case AXIS_EVENT_ID: {
1389 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1390 if (axisEvent) {
1391 return axisEvent->pinchAxisScale;
1392 }
1393 break;
1394 }
1395 case C_AXIS_EVENT_ID: {
1396 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1397 if (!axisEvent) {
1398 return 0.0;
1399 }
1400 return axisEvent->pinchAxisScale;
1401 }
1402 default:
1403 break;
1404 }
1405 return 0.0;
1406 }
1407
OH_ArkUI_AxisEvent_GetAxisAction(const ArkUI_UIInputEvent * event)1408 int32_t OH_ArkUI_AxisEvent_GetAxisAction(const ArkUI_UIInputEvent* event)
1409 {
1410 if (!event) {
1411 return UI_AXIS_EVENT_ACTION_NONE;
1412 }
1413 switch (event->eventTypeId) {
1414 case AXIS_EVENT_ID: {
1415 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1416 if (axisEvent) {
1417 return OHOS::Ace::NodeModel::ConvertToCAxisActionType(static_cast<int32_t>(axisEvent->action));
1418 }
1419 break;
1420 }
1421 case C_AXIS_EVENT_ID: {
1422 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1423 if (axisEvent) {
1424 return OHOS::Ace::NodeModel::ConvertToCAxisActionType(axisEvent->action);
1425 }
1426 break;
1427 }
1428 default:
1429 break;
1430 }
1431 return UI_AXIS_EVENT_ACTION_NONE;
1432 }
1433
OH_ArkUI_PointerEvent_SetInterceptHitTestMode(const ArkUI_UIInputEvent * event,HitTestMode mode)1434 int32_t OH_ArkUI_PointerEvent_SetInterceptHitTestMode(const ArkUI_UIInputEvent* event, HitTestMode mode)
1435 {
1436 if (!event) {
1437 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1438 }
1439 switch (event->eventTypeId) {
1440 case C_TOUCH_EVENT_ID: {
1441 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1442 touchEvent->interceptResult = static_cast<int32_t>(mode);
1443 break;
1444 }
1445 case C_MOUSE_EVENT_ID: {
1446 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1447 if (!mouseEvent) {
1448 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1449 }
1450 return mouseEvent->interceptResult = static_cast<int32_t>(mode);
1451 }
1452 default:
1453 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1454 }
1455 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1456 }
1457
OH_ArkUI_PointerEvent_SetStopPropagation(const ArkUI_UIInputEvent * event,bool stopPropagation)1458 int32_t OH_ArkUI_PointerEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)
1459 {
1460 if (!event) {
1461 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1462 }
1463 switch (event->eventTypeId) {
1464 case C_TOUCH_EVENT_ID: {
1465 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1466 touchEvent->stopPropagation = stopPropagation;
1467 break;
1468 }
1469 default:
1470 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1471 }
1472 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1473 }
1474
OH_ArkUI_MouseEvent_GetMouseButton(const ArkUI_UIInputEvent * event)1475 int32_t OH_ArkUI_MouseEvent_GetMouseButton(const ArkUI_UIInputEvent* event)
1476 {
1477 if (!event) {
1478 return -1;
1479 }
1480 switch (event->eventTypeId) {
1481 case C_MOUSE_EVENT_ID: {
1482 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1483 if (!mouseEvent) {
1484 return -1;
1485 }
1486 return OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(mouseEvent->button);
1487 }
1488 default:
1489 break;
1490 }
1491 return -1;
1492 }
1493
OH_ArkUI_MouseEvent_GetMouseAction(const ArkUI_UIInputEvent * event)1494 int32_t OH_ArkUI_MouseEvent_GetMouseAction(const ArkUI_UIInputEvent* event)
1495 {
1496 if (!event) {
1497 return -1;
1498 }
1499 switch (event->eventTypeId) {
1500 case C_MOUSE_EVENT_ID: {
1501 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1502 if (!mouseEvent) {
1503 return -1;
1504 }
1505 return OHOS::Ace::NodeModel::ConvertToCMouseActionType(mouseEvent->action);
1506 }
1507 default:
1508 break;
1509 }
1510 return -1;
1511 }
1512
OH_ArkUI_PointerEvent_GetPressedTimeByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1513 int64_t OH_ArkUI_PointerEvent_GetPressedTimeByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1514 {
1515 if (!event) {
1516 return 0;
1517 }
1518 switch (event->eventTypeId) {
1519 case C_TOUCH_EVENT_ID: {
1520 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1521 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1522 return 0;
1523 }
1524 return touchEvent->touchPointes[pointerIndex].pressedTime;
1525 }
1526 default:
1527 break;
1528 }
1529 return 0;
1530 }
1531
OH_ArkUI_MouseEvent_GetRawDeltaX(const ArkUI_UIInputEvent * event)1532 float OH_ArkUI_MouseEvent_GetRawDeltaX(const ArkUI_UIInputEvent* event)
1533 {
1534 if (!event) {
1535 return 0.0f;
1536 }
1537 switch (event->eventTypeId) {
1538 case C_MOUSE_EVENT_ID: {
1539 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1540 if (!mouseEvent) {
1541 return 0.0f;
1542 }
1543 return mouseEvent->rawDeltaX;
1544 }
1545 default:
1546 break;
1547 }
1548 return 0.0f;
1549 }
1550
OH_ArkUI_MouseEvent_GetRawDeltaY(const ArkUI_UIInputEvent * event)1551 float OH_ArkUI_MouseEvent_GetRawDeltaY(const ArkUI_UIInputEvent* event)
1552 {
1553 if (!event) {
1554 return 0.0f;
1555 }
1556 switch (event->eventTypeId) {
1557 case C_MOUSE_EVENT_ID: {
1558 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1559 if (!mouseEvent) {
1560 return 0.0f;
1561 }
1562 return mouseEvent->rawDeltaY;
1563 }
1564 default:
1565 break;
1566 }
1567 return 0.0f;
1568 }
1569
OH_ArkUI_UIInputEvent_GetTargetDisplayId(const ArkUI_UIInputEvent * event)1570 int32_t OH_ArkUI_UIInputEvent_GetTargetDisplayId(const ArkUI_UIInputEvent* event)
1571 {
1572 if (!event) {
1573 return 0;
1574 }
1575 auto getTargetDisplayId = [](auto* specificEvent) -> int32_t {
1576 return specificEvent ? specificEvent->targetDisplayId : 0;
1577 };
1578 switch (event->eventTypeId) {
1579 case C_MOUSE_EVENT_ID:
1580 return getTargetDisplayId(reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent));
1581 case C_TOUCH_EVENT_ID:
1582 return getTargetDisplayId(reinterpret_cast<ArkUITouchEvent*>(event->inputEvent));
1583 case C_AXIS_EVENT_ID:
1584 return getTargetDisplayId(reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent));
1585 case C_FOCUS_AXIS_EVENT_ID:
1586 return getTargetDisplayId(reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent));
1587 case TOUCH_EVENT_ID: {
1588 return getTargetDisplayId(reinterpret_cast<OHOS::Ace::TouchEvent*>(event->inputEvent));
1589 }
1590 case AXIS_EVENT_ID: {
1591 return getTargetDisplayId(reinterpret_cast<OHOS::Ace::AxisEvent*>(event->inputEvent));
1592 }
1593 default:
1594 return 0;
1595 }
1596 }
1597
OH_ArkUI_MouseEvent_GetPressedButtons(const ArkUI_UIInputEvent * event,int32_t * pressedButtons,int32_t * length)1598 int32_t OH_ArkUI_MouseEvent_GetPressedButtons(const ArkUI_UIInputEvent* event, int32_t* pressedButtons, int32_t* length)
1599 {
1600 if (!event || !pressedButtons || !length) {
1601 return ARKUI_ERROR_CODE_PARAM_INVALID;
1602 }
1603 switch (event->eventTypeId) {
1604 case C_MOUSE_EVENT_ID: {
1605 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1606 if (!mouseEvent) {
1607 return ARKUI_ERROR_CODE_PARAM_INVALID;
1608 }
1609 auto inputLength = *length;
1610 if (mouseEvent->pressedButtonsLength > inputLength) {
1611 return ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH;
1612 }
1613 *length = mouseEvent->pressedButtonsLength;
1614 for (int i = 0; i < mouseEvent->pressedButtonsLength; i++) {
1615 pressedButtons[i] = mouseEvent->pressedButtons[i];
1616 }
1617 return ARKUI_ERROR_CODE_NO_ERROR;
1618 }
1619 default:
1620 break;
1621 }
1622 return ARKUI_ERROR_CODE_PARAM_INVALID;
1623 }
1624
OH_ArkUI_FocusAxisEvent_GetAxisValue(const ArkUI_UIInputEvent * event,int32_t axis)1625 double OH_ArkUI_FocusAxisEvent_GetAxisValue(const ArkUI_UIInputEvent* event, int32_t axis)
1626 {
1627 if (!event) {
1628 return 0.0;
1629 }
1630 if (event->eventTypeId != C_FOCUS_AXIS_EVENT_ID) {
1631 return 0.0f;
1632 }
1633 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
1634 if (!focusAxisEvent) {
1635 return 0.0;
1636 }
1637 switch (axis) {
1638 case UI_FOCUS_AXIS_EVENT_ABS_X:
1639 return focusAxisEvent->absXValue;
1640 case UI_FOCUS_AXIS_EVENT_ABS_Y:
1641 return focusAxisEvent->absYValue;
1642 case UI_FOCUS_AXIS_EVENT_ABS_Z:
1643 return focusAxisEvent->absZValue;
1644 case UI_FOCUS_AXIS_EVENT_ABS_RZ:
1645 return focusAxisEvent->absRzValue;
1646 case UI_FOCUS_AXIS_EVENT_ABS_GAS:
1647 return focusAxisEvent->absGasValue;
1648 case UI_FOCUS_AXIS_EVENT_ABS_BRAKE:
1649 return focusAxisEvent->absBrakeValue;
1650 case UI_FOCUS_AXIS_EVENT_ABS_HAT0X:
1651 return focusAxisEvent->absHat0XValue;
1652 case UI_FOCUS_AXIS_EVENT_ABS_HAT0Y:
1653 return focusAxisEvent->absHat0YValue;
1654 default:
1655 return 0.0;
1656 }
1657 return 0.0;
1658 }
1659
OH_ArkUI_FocusAxisEvent_SetStopPropagation(const ArkUI_UIInputEvent * event,bool stopPropagation)1660 int32_t OH_ArkUI_FocusAxisEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)
1661 {
1662 if (!event) {
1663 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1664 }
1665 switch (event->eventTypeId) {
1666 case C_FOCUS_AXIS_EVENT_ID: {
1667 auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
1668 focusAxisEvent->stopPropagation = stopPropagation;
1669 break;
1670 }
1671 default:
1672 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1673 }
1674 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1675 }
1676
OH_ArkUI_PointerEvent_CreateClonedEvent(const ArkUI_UIInputEvent * event,ArkUI_UIInputEvent ** clonedEvent)1677 int32_t OH_ArkUI_PointerEvent_CreateClonedEvent(const ArkUI_UIInputEvent* event, ArkUI_UIInputEvent** clonedEvent)
1678 {
1679 if (!event) {
1680 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1681 }
1682 ArkUI_UIInputEvent* currentEvent = new ArkUI_UIInputEvent();
1683 currentEvent->inputType = event->inputType;
1684 currentEvent->eventTypeId = event->eventTypeId;
1685 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1686 if (!touchEvent) {
1687 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1688 }
1689 ArkUITouchEvent* touchEventCloned = new ArkUITouchEvent();
1690 auto fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
1691 if (!fullImpl) {
1692 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1693 }
1694 fullImpl->getNodeModifiers()->getCommonModifier()->createClonedTouchEvent(touchEventCloned, touchEvent);
1695 currentEvent->inputEvent = touchEventCloned;
1696 currentEvent->isCloned = true;
1697 *clonedEvent = currentEvent;
1698 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1699 }
1700
OH_ArkUI_PointerEvent_DestroyClonedEvent(const ArkUI_UIInputEvent * event)1701 int32_t OH_ArkUI_PointerEvent_DestroyClonedEvent(const ArkUI_UIInputEvent* event)
1702 {
1703 if (!event) {
1704 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1705 }
1706 if (!event->isCloned) {
1707 return ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT;
1708 }
1709 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1710 if (touchEvent) {
1711 auto fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
1712 fullImpl->getNodeModifiers()->getCommonModifier()->destroyTouchEvent(touchEvent);
1713 }
1714 delete event;
1715 event = nullptr;
1716 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1717 }
1718
OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(const ArkUI_UIInputEvent * event,float x,float y)1719 int32_t OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(const ArkUI_UIInputEvent* event, float x, float y)
1720 {
1721 if (!event) {
1722 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1723 }
1724 if (!event->isCloned) {
1725 return ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT;
1726 }
1727 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1728 if (!touchEvent) {
1729 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1730 }
1731 touchEvent->actionTouchPoint.nodeX = x;
1732 touchEvent->actionTouchPoint.nodeY = y;
1733 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1734 }
1735
OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(const ArkUI_UIInputEvent * event,float x,float y,int32_t pointerIndex)1736 int32_t OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(
1737 const ArkUI_UIInputEvent* event, float x, float y, int32_t pointerIndex)
1738 {
1739 if (!event) {
1740 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1741 }
1742 if (!event->isCloned) {
1743 return ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT;
1744 }
1745 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1746 if (!touchEvent) {
1747 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1748 }
1749 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1750 return ARKUI_ERROR_CODE_PARAM_INVALID;
1751 }
1752 touchEvent->touchPointes[pointerIndex].nodeX = x;
1753 touchEvent->touchPointes[pointerIndex].nodeY = y;
1754 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1755 }
1756
OH_ArkUI_PointerEvent_SetClonedEventActionType(const ArkUI_UIInputEvent * event,int32_t actionType)1757 int32_t OH_ArkUI_PointerEvent_SetClonedEventActionType(const ArkUI_UIInputEvent* event, int32_t actionType)
1758 {
1759 if (!event) {
1760 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1761 }
1762 if (!event->isCloned) {
1763 return ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT;
1764 }
1765 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1766 if (!touchEvent) {
1767 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1768 }
1769 touchEvent->action = OHOS::Ace::NodeModel::ConvertToOriginTouchActionType(actionType);
1770 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1771 }
1772
OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(const ArkUI_UIInputEvent * event,int32_t fingerId)1773 int32_t OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(const ArkUI_UIInputEvent* event, int32_t fingerId)
1774 {
1775 if (!event) {
1776 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1777 }
1778 if (!event->isCloned) {
1779 return ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT;
1780 }
1781 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1782 if (!touchEvent) {
1783 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1784 }
1785 touchEvent->actionTouchPoint.id = fingerId;
1786 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1787 }
1788
OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(const ArkUI_UIInputEvent * event,int32_t fingerId,int32_t pointerIndex)1789 int32_t OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(
1790 const ArkUI_UIInputEvent* event, int32_t fingerId, int32_t pointerIndex)
1791 {
1792 if (!event) {
1793 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1794 }
1795 if (!event->isCloned) {
1796 return ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT;
1797 }
1798 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1799 if (!touchEvent) {
1800 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1801 }
1802 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1803 return ARKUI_ERROR_CODE_PARAM_INVALID;
1804 }
1805 touchEvent->touchPointes[pointerIndex].id = fingerId;
1806 return OHOS::Ace::ERROR_CODE_NO_ERROR;
1807 }
1808
OH_ArkUI_PointerEvent_PostClonedEvent(ArkUI_NodeHandle node,const ArkUI_UIInputEvent * event)1809 int32_t OH_ArkUI_PointerEvent_PostClonedEvent(ArkUI_NodeHandle node, const ArkUI_UIInputEvent* event)
1810 {
1811 if (!event) {
1812 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1813 }
1814 if (!node) {
1815 return ARKUI_ERROR_CODE_POST_CLONED_COMPONENT_STATUS_ABNORMAL;
1816 }
1817 if (!event->isCloned) {
1818 return ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT;
1819 }
1820 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1821 if (!touchEvent) {
1822 return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1823 }
1824 auto fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
1825 if (!fullImpl) {
1826 return ARKUI_ERROR_CODE_POST_CLONED_COMPONENT_STATUS_ABNORMAL;
1827 }
1828 int32_t res = fullImpl->getNodeModifiers()->getCommonModifier()->postTouchEvent(node->uiNodeHandle, touchEvent);
1829 return res;
1830 }
1831
1832 #ifdef __cplusplus
1833 };
1834 #endif
1835