1 /*
2 * Copyright (c) 2025 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 "frameworks/bridge/declarative_frontend/engine/functions/js_gesture_recognizer.h"
17
18 #include "ui/base/utils/utils.h"
19
20 #include "core/components_ng/gestures/recognizers/pan_recognizer.h"
21 #include "core/components_ng/gestures/tap_gesture.h"
22
23 namespace OHOS::Ace::Framework {
24
CreateEventTargetInfo(RefPtr<NG::FrameNode> attachNode)25 JSRef<JSObject> CreateEventTargetInfo(RefPtr<NG::FrameNode> attachNode)
26 {
27 if (!attachNode) {
28 return JSClass<JSEventTargetInfo>::NewInstance();
29 }
30 RefPtr<NG::Pattern> pattern;
31 auto scrollablePattern = attachNode->GetPattern<NG::ScrollablePattern>();
32 if (scrollablePattern) {
33 pattern = scrollablePattern;
34 }
35 auto swiperPattern = attachNode->GetPattern<NG::SwiperPattern>();
36 if (swiperPattern) {
37 pattern = swiperPattern;
38 }
39 if (pattern) {
40 JSRef<JSObject> scrollableTargetObj = JSClass<JSScrollableTargetInfo>::NewInstance();
41 auto scrollableTarget = Referenced::Claim(scrollableTargetObj->Unwrap<JSScrollableTargetInfo>());
42 scrollableTarget->SetPattern(pattern);
43 scrollableTarget->SetInspectorId(attachNode->GetInspectorIdValue(""));
44 return scrollableTargetObj;
45 }
46 auto eventTargetObj = JSClass<JSEventTargetInfo>::NewInstance();
47 auto eventTarget = Referenced::Claim(eventTargetObj->Unwrap<JSEventTargetInfo>());
48 eventTarget->SetInspectorId(attachNode->GetInspectorIdValue(""));
49 return eventTargetObj;
50 }
51
IsBegin(const JSCallbackInfo & args)52 void JSScrollableTargetInfo::IsBegin(const JSCallbackInfo& args)
53 {
54 auto pattern = pattern_.Upgrade();
55 if (!pattern) {
56 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(false)));
57 return;
58 }
59 auto scrollablePattern = AceType::DynamicCast<NG::ScrollablePattern>(pattern);
60 if (scrollablePattern) {
61 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(scrollablePattern->IsAtTop())));
62 return;
63 }
64 auto swiperPattern = AceType::DynamicCast<NG::SwiperPattern>(pattern);
65 if (swiperPattern) {
66 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(swiperPattern->IsAtStart())));
67 }
68 }
69
IsEnd(const JSCallbackInfo & args)70 void JSScrollableTargetInfo::IsEnd(const JSCallbackInfo& args)
71 {
72 auto pattern = pattern_.Upgrade();
73 if (!pattern) {
74 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(false)));
75 return;
76 }
77 auto scrollablePattern = AceType::DynamicCast<NG::ScrollablePattern>(pattern);
78 if (scrollablePattern) {
79 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(scrollablePattern->IsAtBottom())));
80 return;
81 }
82 auto swiperPattern = AceType::DynamicCast<NG::SwiperPattern>(pattern);
83 if (swiperPattern) {
84 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(swiperPattern->IsAtEnd())));
85 }
86 }
87
GetTag(const JSCallbackInfo & args)88 void JSGestureRecognizer::GetTag(const JSCallbackInfo& args)
89 {
90 std::string tag;
91 auto recognizer = recognizer_.Upgrade();
92 if (recognizer) {
93 auto gestureInfo = recognizer->GetGestureInfo();
94 if (gestureInfo->GetTag().has_value()) {
95 tag = gestureInfo->GetTag().value();
96 }
97 }
98 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(tag)));
99 }
100
GetType(const JSCallbackInfo & args)101 void JSGestureRecognizer::GetType(const JSCallbackInfo& args)
102 {
103 GestureTypeName type = GestureTypeName::UNKNOWN;
104 auto recognizer = recognizer_.Upgrade();
105 if (recognizer) {
106 auto gestureInfo = recognizer->GetGestureInfo();
107 type = gestureInfo->GetRecognizerType();
108 }
109 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(static_cast<int32_t>(type))));
110 }
111
GetFingers(const JSCallbackInfo & args)112 void JSGestureRecognizer::GetFingers(const JSCallbackInfo& args)
113 {
114 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(fingers_)));
115 }
116
IsFingerCountLimit(const JSCallbackInfo & args)117 void JSGestureRecognizer::IsFingerCountLimit(const JSCallbackInfo& args)
118 {
119 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(isLimitFingerCount_)));
120 }
121
IsBuiltInRecognizer(const JSCallbackInfo & args)122 void JSGestureRecognizer::IsBuiltInRecognizer(const JSCallbackInfo& args)
123 {
124 bool isBuiltIn = false;
125 auto recognizer = recognizer_.Upgrade();
126 if (recognizer) {
127 auto gestureInfo = recognizer->GetGestureInfo();
128 isBuiltIn = gestureInfo->IsSystemGesture();
129 }
130 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(isBuiltIn)));
131 }
132
SetEnabled(const JSCallbackInfo & args)133 void JSGestureRecognizer::SetEnabled(const JSCallbackInfo& args)
134 {
135 auto recognizer = recognizer_.Upgrade();
136 CHECK_NULL_VOID(recognizer);
137 bool enabled = true;
138 if (args[0]->IsBoolean()) {
139 enabled = args[0]->ToBoolean();
140 }
141 recognizer->SetEnabled(enabled);
142 }
143
PreventBegin(const JSCallbackInfo & args)144 void JSGestureRecognizer::PreventBegin(const JSCallbackInfo& args)
145 {
146 auto recognizer = recognizer_.Upgrade();
147 CHECK_NULL_VOID(recognizer);
148 recognizer->SetPreventBegin(true);
149 }
150
IsEnabled(const JSCallbackInfo & args)151 void JSGestureRecognizer::IsEnabled(const JSCallbackInfo& args)
152 {
153 bool isEnabled = false;
154 auto recognizer = recognizer_.Upgrade();
155 if (recognizer) {
156 isEnabled = recognizer->IsEnabled();
157 }
158 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(isEnabled)));
159 }
160
GetEventTargetInfo(const JSCallbackInfo & args)161 void JSGestureRecognizer::GetEventTargetInfo(const JSCallbackInfo& args)
162 {
163 auto recognizer = recognizer_.Upgrade();
164 if (!recognizer) {
165 args.SetReturnValue(JSClass<JSEventTargetInfo>::NewInstance());
166 return;
167 }
168 auto attachNode = recognizer->GetAttachedNode().Upgrade();
169 if (!attachNode) {
170 args.SetReturnValue(JSClass<JSEventTargetInfo>::NewInstance());
171 return;
172 }
173 auto eventTargetObj = CreateEventTargetInfo(attachNode);
174 args.SetReturnValue(eventTargetObj);
175 }
176
GetRefereeState(const JSCallbackInfo & args)177 void JSGestureRecognizer::GetRefereeState(const JSCallbackInfo& args)
178 {
179 GestureRecognizerState state = GestureRecognizerState::FAIL;
180 auto recognizer = recognizer_.Upgrade();
181 if (recognizer) {
182 state = ConvertRefereeState(recognizer->GetRefereeState());
183 }
184 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(static_cast<int32_t>(state))));
185 }
186
IsValid(const JSCallbackInfo & args)187 void JSGestureRecognizer::IsValid(const JSCallbackInfo& args)
188 {
189 bool isValid = false;
190 auto recognizer = recognizer_.Upgrade();
191 if (recognizer && recognizer->IsInResponseLinkRecognizers()) {
192 isValid = true;
193 }
194 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(isValid)));
195 }
196
GetDirection(const JSCallbackInfo & args)197 void JSPanRecognizer::GetDirection(const JSCallbackInfo& args)
198 {
199 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(direction_.type)));
200 }
201
GetPanDistance(const JSCallbackInfo & args)202 void JSPanRecognizer::GetPanDistance(const JSCallbackInfo& args)
203 {
204 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
205 if (recognizer) {
206 auto context = PipelineContext::GetCurrentContextSafely();
207 CHECK_NULL_VOID(context);
208 double distance = context->ConvertPxToVp(Dimension(distance_, DimensionUnit::PX));
209 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(RoundToMaxPrecision(distance))));
210 }
211 }
212
GetPanDistanceMap(const JSCallbackInfo & args)213 void JSPanRecognizer::GetPanDistanceMap(const JSCallbackInfo& args)
214 {
215 auto vm = args.GetVm();
216 CHECK_NULL_VOID(vm);
217 auto distanceMap = panda::MapRef::New(vm);
218 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
219 if (!recognizer) {
220 args.SetReturnValue(JsiRef<JsiObject>(JsiObject(distanceMap)));
221 return;
222 }
223 auto panRecognizer = AceType::DynamicCast<NG::PanRecognizer>(recognizer);
224 if (!panRecognizer) {
225 args.SetReturnValue(JsiRef<JsiObject>(JsiObject(distanceMap)));
226 return;
227 }
228 auto context = PipelineContext::GetCurrentContextSafely();
229 CHECK_NULL_VOID(context);
230 auto panDistanceMap = panRecognizer->GetDistanceMap();
231 for (const auto& item : panDistanceMap) {
232 double distance = context->ConvertPxToVp(item.second);
233 distanceMap->Set(vm, panda::NumberRef::New(vm, static_cast<int32_t>(item.first)),
234 panda::NumberRef::New(vm, RoundToMaxPrecision(distance)));
235 }
236 args.SetReturnValue(JsiRef<JsiObject>(JsiObject(distanceMap)));
237 }
238
GetDistance(const JSCallbackInfo & args)239 void JSPinchRecognizer::GetDistance(const JSCallbackInfo& args)
240 {
241 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
242 if (recognizer) {
243 auto context = PipelineContext::GetCurrentContextSafely();
244 CHECK_NULL_VOID(context);
245 double distance = context->ConvertPxToVp(Dimension(distance_, DimensionUnit::PX));
246 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(RoundToMaxPrecision(distance))));
247 }
248 }
249
GetCount(const JSCallbackInfo & args)250 void JSTapRecognizer::GetCount(const JSCallbackInfo& args)
251 {
252 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
253 if (recognizer) {
254 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(count_)));
255 }
256 }
257
GetDuration(const JSCallbackInfo & args)258 void JSLongPressRecognizer::GetDuration(const JSCallbackInfo& args)
259 {
260 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
261 if (recognizer) {
262 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(duration_)));
263 }
264 }
265
SetRepeat(bool repeat)266 void JSLongPressRecognizer::SetRepeat(bool repeat)
267 {
268 repeat_ = repeat;
269 }
270
GetRepeat(const JSCallbackInfo & args)271 void JSLongPressRecognizer::GetRepeat(const JSCallbackInfo& args)
272 {
273 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
274 if (recognizer) {
275 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(repeat_)));
276 }
277 }
278
GetAngle(const JSCallbackInfo & args)279 void JSRotationRecognizer::GetAngle(const JSCallbackInfo& args)
280 {
281 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
282 if (recognizer) {
283 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(angle_)));
284 }
285 }
286
GetDirection(const JSCallbackInfo & args)287 void JSSwipeRecognizer::GetDirection(const JSCallbackInfo& args)
288 {
289 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
290 if (recognizer) {
291 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(direction_.type)));
292 }
293 }
294
GetSpeed(const JSCallbackInfo & args)295 void JSSwipeRecognizer::GetSpeed(const JSCallbackInfo& args)
296 {
297 auto recognizer = JSGestureRecognizer::GetRecognizer().Upgrade();
298 if (recognizer) {
299 auto context = PipelineContext::GetCurrentContextSafely();
300 CHECK_NULL_VOID(context);
301 double speed = context->ConvertPxToVp(Dimension(speed_, DimensionUnit::PX));
302 args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(RoundToMaxPrecision(speed))));
303 }
304 }
305
CancelTouch(const JSCallbackInfo & args)306 void JSTouchRecognizer::CancelTouch(const JSCallbackInfo& args)
307 {
308 if (fingerIds_.empty()) {
309 TAG_LOGW(AceLogTag::ACE_GESTURE, "fingerIds_ is empty.");
310 return;
311 }
312 auto target = target_.Upgrade();
313 CHECK_NULL_VOID(target);
314 auto node = target->GetAttachedNode().Upgrade();
315 CHECK_NULL_VOID(node);
316 auto pipeline = node->GetContext();
317 CHECK_NULL_VOID(pipeline);
318 auto eventManager = pipeline->GetEventManager();
319 CHECK_NULL_VOID(eventManager);
320 auto& touchTestResult = eventManager->touchTestResults_;
321 std::vector<std::pair<int32_t, TouchTestResult::iterator>> legacyTarget;
322 for (const auto& fingerId : fingerIds_) {
323 if (touchTestResult.find(fingerId) == touchTestResult.end()) {
324 continue;
325 }
326
327 auto& targetsList = touchTestResult[fingerId];
328 auto it = std::find_if(targetsList.begin(), targetsList.end(),
329 [&target](const RefPtr<TouchEventTarget>& t) { return t == target; });
330
331 if (it != targetsList.end()) {
332 legacyTarget.emplace_back(fingerId, it);
333 }
334 }
335
336 eventManager->DispatchTouchCancelToRecognizer(RawPtr(target), legacyTarget);
337 fingerIds_.clear();
338 }
339
GetEventTargetInfo(const JSCallbackInfo & args)340 void JSTouchRecognizer::GetEventTargetInfo(const JSCallbackInfo& args)
341 {
342 auto target = target_.Upgrade();
343 if (!target) {
344 args.SetReturnValue(JSClass<JSEventTargetInfo>::NewInstance());
345 return;
346 }
347 auto attachNode = target->GetAttachedNode().Upgrade();
348 if (!attachNode) {
349 args.SetReturnValue(JSClass<JSEventTargetInfo>::NewInstance());
350 return;
351 }
352 auto eventTargetObj = CreateEventTargetInfo(attachNode);
353 args.SetReturnValue(eventTargetObj);
354 }
355
JSBind(BindingTarget globalObj)356 void JSEventTargetInfo::JSBind(BindingTarget globalObj)
357 {
358 JSClass<JSEventTargetInfo>::Declare("EventTargetInfo");
359 JSClass<JSEventTargetInfo>::CustomMethod("getId", &JSEventTargetInfo::GetInspectorId);
360 JSClass<JSEventTargetInfo>::Bind(globalObj, &JSEventTargetInfo::Constructor, &JSEventTargetInfo::Destructor);
361 }
362
JSBind(BindingTarget globalObj)363 void JSScrollableTargetInfo::JSBind(BindingTarget globalObj)
364 {
365 JSClass<JSScrollableTargetInfo>::Declare("ScrollableTargetInfo");
366 JSClass<JSScrollableTargetInfo>::CustomMethod("isBegin", &JSScrollableTargetInfo::IsBegin);
367 JSClass<JSScrollableTargetInfo>::CustomMethod("isEnd", &JSScrollableTargetInfo::IsEnd);
368 JSClass<JSScrollableTargetInfo>::CustomMethod("getId", &JSEventTargetInfo::GetInspectorId);
369 JSClass<JSScrollableTargetInfo>::Inherit<JSEventTargetInfo>();
370 JSClass<JSScrollableTargetInfo>::Bind(
371 globalObj, &JSScrollableTargetInfo::Constructor, &JSScrollableTargetInfo::Destructor);
372 }
373
JSBind(BindingTarget globalObj)374 void JSGestureRecognizer::JSBind(BindingTarget globalObj)
375 {
376 JSClass<JSGestureRecognizer>::Declare("GestureRecognizer");
377 JSClass<JSGestureRecognizer>::CustomMethod("getTag", &JSGestureRecognizer::GetTag);
378 JSClass<JSGestureRecognizer>::CustomMethod("getType", &JSGestureRecognizer::GetType);
379 JSClass<JSGestureRecognizer>::CustomMethod("getFingerCount", &JSGestureRecognizer::GetFingers);
380 JSClass<JSGestureRecognizer>::CustomMethod("isFingerCountLimit", &JSGestureRecognizer::IsFingerCountLimit);
381 JSClass<JSGestureRecognizer>::CustomMethod("isBuiltIn", &JSGestureRecognizer::IsBuiltInRecognizer);
382 JSClass<JSGestureRecognizer>::CustomMethod("setEnabled", &JSGestureRecognizer::SetEnabled);
383 JSClass<JSGestureRecognizer>::CustomMethod("preventBegin", &JSGestureRecognizer::PreventBegin);
384 JSClass<JSGestureRecognizer>::CustomMethod("isEnabled", &JSGestureRecognizer::IsEnabled);
385 JSClass<JSGestureRecognizer>::CustomMethod("getEventTargetInfo", &JSGestureRecognizer::GetEventTargetInfo);
386 JSClass<JSGestureRecognizer>::CustomMethod("getState", &JSGestureRecognizer::GetRefereeState);
387 JSClass<JSGestureRecognizer>::CustomMethod("isValid", &JSGestureRecognizer::IsValid);
388 JSClass<JSGestureRecognizer>::Bind(globalObj, &JSGestureRecognizer::Constructor, &JSGestureRecognizer::Destructor);
389 }
390
JSBind(BindingTarget globalObj)391 void JSPanRecognizer::JSBind(BindingTarget globalObj)
392 {
393 JSClass<JSPanRecognizer>::Declare("PanRecognizer");
394 JSClass<JSPanRecognizer>::CustomMethod("getTag", &JSGestureRecognizer::GetTag);
395 JSClass<JSPanRecognizer>::CustomMethod("getType", &JSGestureRecognizer::GetType);
396 JSClass<JSPanRecognizer>::CustomMethod("getFingerCount", &JSGestureRecognizer::GetFingers);
397 JSClass<JSPanRecognizer>::CustomMethod("isFingerCountLimit", &JSGestureRecognizer::IsFingerCountLimit);
398 JSClass<JSPanRecognizer>::CustomMethod("isBuiltIn", &JSGestureRecognizer::IsBuiltInRecognizer);
399 JSClass<JSPanRecognizer>::CustomMethod("setEnabled", &JSGestureRecognizer::SetEnabled);
400 JSClass<JSPanRecognizer>::CustomMethod("preventBegin", &JSGestureRecognizer::PreventBegin);
401 JSClass<JSPanRecognizer>::CustomMethod("isEnabled", &JSGestureRecognizer::IsEnabled);
402 JSClass<JSPanRecognizer>::CustomMethod("getEventTargetInfo", &JSGestureRecognizer::GetEventTargetInfo);
403 JSClass<JSPanRecognizer>::CustomMethod("getState", &JSGestureRecognizer::GetRefereeState);
404 JSClass<JSPanRecognizer>::CustomMethod("getPanGestureOptions", &JSPanRecognizer::GetPanGestureOptions);
405 JSClass<JSPanRecognizer>::CustomMethod("isValid", &JSGestureRecognizer::IsValid);
406 JSClass<JSPanRecognizer>::CustomMethod("getDirection", &JSPanRecognizer::GetDirection);
407 JSClass<JSPanRecognizer>::CustomMethod("getDistance", &JSPanRecognizer::GetPanDistance);
408 JSClass<JSPanRecognizer>::CustomMethod("getDistanceMap", &JSPanRecognizer::GetPanDistanceMap);
409 JSClass<JSPanRecognizer>::Inherit<JSGestureRecognizer>();
410 JSClass<JSPanRecognizer>::Bind(globalObj, &JSPanRecognizer::Constructor, &JSPanRecognizer::Destructor);
411 }
412
JSBind(BindingTarget globalObj)413 void JSPinchRecognizer::JSBind(BindingTarget globalObj)
414 {
415 JSClass<JSPinchRecognizer>::Declare("PinchRecognizer");
416 JSClass<JSPinchRecognizer>::CustomMethod("getTag", &JSGestureRecognizer::GetTag);
417 JSClass<JSPinchRecognizer>::CustomMethod("getType", &JSGestureRecognizer::GetType);
418 JSClass<JSPinchRecognizer>::CustomMethod("getFingerCount", &JSGestureRecognizer::GetFingers);
419 JSClass<JSPinchRecognizer>::CustomMethod("isFingerCountLimit", &JSGestureRecognizer::IsFingerCountLimit);
420 JSClass<JSPinchRecognizer>::CustomMethod("getDistance", &JSPinchRecognizer::GetDistance);
421 JSClass<JSPinchRecognizer>::CustomMethod("isBuiltIn", &JSGestureRecognizer::IsBuiltInRecognizer);
422 JSClass<JSPinchRecognizer>::CustomMethod("preventBegin", &JSGestureRecognizer::PreventBegin);
423 JSClass<JSPinchRecognizer>::CustomMethod("setEnabled", &JSGestureRecognizer::SetEnabled);
424 JSClass<JSPinchRecognizer>::CustomMethod("isEnabled", &JSGestureRecognizer::IsEnabled);
425 JSClass<JSPinchRecognizer>::CustomMethod("getEventTargetInfo", &JSGestureRecognizer::GetEventTargetInfo);
426 JSClass<JSPinchRecognizer>::CustomMethod("getState", &JSGestureRecognizer::GetRefereeState);
427 JSClass<JSPinchRecognizer>::CustomMethod("isValid", &JSGestureRecognizer::IsValid);
428 JSClass<JSPinchRecognizer>::Inherit<JSGestureRecognizer>();
429 JSClass<JSPinchRecognizer>::Bind(globalObj, &JSPinchRecognizer::Constructor, &JSPinchRecognizer::Destructor);
430 }
431
JSBind(BindingTarget globalObj)432 void JSTapRecognizer::JSBind(BindingTarget globalObj)
433 {
434 JSClass<JSTapRecognizer>::Declare("TapRecognizer");
435 JSClass<JSTapRecognizer>::CustomMethod("getTag", &JSGestureRecognizer::GetTag);
436 JSClass<JSTapRecognizer>::CustomMethod("getType", &JSGestureRecognizer::GetType);
437 JSClass<JSTapRecognizer>::CustomMethod("getFingerCount", &JSGestureRecognizer::GetFingers);
438 JSClass<JSTapRecognizer>::CustomMethod("isFingerCountLimit", &JSGestureRecognizer::IsFingerCountLimit);
439 JSClass<JSTapRecognizer>::CustomMethod("getTapCount", &JSTapRecognizer::GetCount);
440 JSClass<JSTapRecognizer>::CustomMethod("isBuiltIn", &JSGestureRecognizer::IsBuiltInRecognizer);
441 JSClass<JSTapRecognizer>::CustomMethod("preventBegin", &JSGestureRecognizer::PreventBegin);
442 JSClass<JSTapRecognizer>::CustomMethod("setEnabled", &JSGestureRecognizer::SetEnabled);
443 JSClass<JSTapRecognizer>::CustomMethod("isEnabled", &JSGestureRecognizer::IsEnabled);
444 JSClass<JSTapRecognizer>::CustomMethod("getEventTargetInfo", &JSGestureRecognizer::GetEventTargetInfo);
445 JSClass<JSTapRecognizer>::CustomMethod("getState", &JSGestureRecognizer::GetRefereeState);
446 JSClass<JSTapRecognizer>::CustomMethod("isValid", &JSGestureRecognizer::IsValid);
447 JSClass<JSTapRecognizer>::Inherit<JSGestureRecognizer>();
448 JSClass<JSTapRecognizer>::Bind(globalObj, &JSTapRecognizer::Constructor, &JSTapRecognizer::Destructor);
449 }
450
JSBind(BindingTarget globalObj)451 void JSLongPressRecognizer::JSBind(BindingTarget globalObj)
452 {
453 JSClass<JSLongPressRecognizer>::Declare("LongPressRecognizer");
454 JSClass<JSLongPressRecognizer>::CustomMethod("getTag", &JSGestureRecognizer::GetTag);
455 JSClass<JSLongPressRecognizer>::CustomMethod("getType", &JSGestureRecognizer::GetType);
456 JSClass<JSLongPressRecognizer>::CustomMethod("getFingerCount", &JSGestureRecognizer::GetFingers);
457 JSClass<JSLongPressRecognizer>::CustomMethod("isFingerCountLimit", &JSGestureRecognizer::IsFingerCountLimit);
458 JSClass<JSLongPressRecognizer>::CustomMethod("isRepeat", &JSLongPressRecognizer::GetRepeat);
459 JSClass<JSLongPressRecognizer>::CustomMethod("getDuration", &JSLongPressRecognizer::GetDuration);
460 JSClass<JSLongPressRecognizer>::CustomMethod("isBuiltIn", &JSGestureRecognizer::IsBuiltInRecognizer);
461 JSClass<JSLongPressRecognizer>::CustomMethod("preventBegin", &JSGestureRecognizer::PreventBegin);
462 JSClass<JSLongPressRecognizer>::CustomMethod("setEnabled", &JSGestureRecognizer::SetEnabled);
463 JSClass<JSLongPressRecognizer>::CustomMethod("isEnabled", &JSGestureRecognizer::IsEnabled);
464 JSClass<JSLongPressRecognizer>::CustomMethod("getEventTargetInfo", &JSGestureRecognizer::GetEventTargetInfo);
465 JSClass<JSLongPressRecognizer>::CustomMethod("getState", &JSGestureRecognizer::GetRefereeState);
466 JSClass<JSLongPressRecognizer>::CustomMethod("isValid", &JSGestureRecognizer::IsValid);
467 JSClass<JSLongPressRecognizer>::Inherit<JSGestureRecognizer>();
468 JSClass<JSLongPressRecognizer>::Bind(
469 globalObj, &JSLongPressRecognizer::Constructor, &JSLongPressRecognizer::Destructor);
470 }
471
JSBind(BindingTarget globalObj)472 void JSRotationRecognizer::JSBind(BindingTarget globalObj)
473 {
474 JSClass<JSRotationRecognizer>::Declare("RotationRecognizer");
475 JSClass<JSRotationRecognizer>::CustomMethod("getTag", &JSGestureRecognizer::GetTag);
476 JSClass<JSRotationRecognizer>::CustomMethod("getType", &JSGestureRecognizer::GetType);
477 JSClass<JSRotationRecognizer>::CustomMethod("getFingerCount", &JSGestureRecognizer::GetFingers);
478 JSClass<JSRotationRecognizer>::CustomMethod("isFingerCountLimit", &JSGestureRecognizer::IsFingerCountLimit);
479 JSClass<JSRotationRecognizer>::CustomMethod("getAngle", &JSRotationRecognizer::GetAngle);
480 JSClass<JSRotationRecognizer>::CustomMethod("isBuiltIn", &JSGestureRecognizer::IsBuiltInRecognizer);
481 JSClass<JSRotationRecognizer>::CustomMethod("preventBegin", &JSGestureRecognizer::PreventBegin);
482 JSClass<JSRotationRecognizer>::CustomMethod("setEnabled", &JSGestureRecognizer::SetEnabled);
483 JSClass<JSRotationRecognizer>::CustomMethod("isEnabled", &JSGestureRecognizer::IsEnabled);
484 JSClass<JSRotationRecognizer>::CustomMethod("getEventTargetInfo", &JSGestureRecognizer::GetEventTargetInfo);
485 JSClass<JSRotationRecognizer>::CustomMethod("getState", &JSGestureRecognizer::GetRefereeState);
486 JSClass<JSRotationRecognizer>::CustomMethod("isValid", &JSGestureRecognizer::IsValid);
487 JSClass<JSRotationRecognizer>::Inherit<JSGestureRecognizer>();
488 JSClass<JSRotationRecognizer>::Bind(
489 globalObj, &JSRotationRecognizer::Constructor, &JSRotationRecognizer::Destructor);
490 }
491
JSBind(BindingTarget globalObj)492 void JSSwipeRecognizer::JSBind(BindingTarget globalObj)
493 {
494 JSClass<JSSwipeRecognizer>::Declare("SwipeRecognizer");
495 JSClass<JSSwipeRecognizer>::CustomMethod("getTag", &JSGestureRecognizer::GetTag);
496 JSClass<JSSwipeRecognizer>::CustomMethod("getType", &JSGestureRecognizer::GetType);
497 JSClass<JSSwipeRecognizer>::CustomMethod("getFingerCount", &JSGestureRecognizer::GetFingers);
498 JSClass<JSSwipeRecognizer>::CustomMethod("isFingerCountLimit", &JSGestureRecognizer::IsFingerCountLimit);
499 JSClass<JSSwipeRecognizer>::CustomMethod("getVelocityThreshold", &JSSwipeRecognizer::GetSpeed);
500 JSClass<JSSwipeRecognizer>::CustomMethod("getDirection", &JSSwipeRecognizer::GetDirection);
501 JSClass<JSSwipeRecognizer>::CustomMethod("isBuiltIn", &JSGestureRecognizer::IsBuiltInRecognizer);
502 JSClass<JSSwipeRecognizer>::CustomMethod("preventBegin", &JSGestureRecognizer::PreventBegin);
503 JSClass<JSSwipeRecognizer>::CustomMethod("setEnabled", &JSGestureRecognizer::SetEnabled);
504 JSClass<JSSwipeRecognizer>::CustomMethod("isEnabled", &JSGestureRecognizer::IsEnabled);
505 JSClass<JSSwipeRecognizer>::CustomMethod("getEventTargetInfo", &JSGestureRecognizer::GetEventTargetInfo);
506 JSClass<JSSwipeRecognizer>::CustomMethod("getState", &JSGestureRecognizer::GetRefereeState);
507 JSClass<JSSwipeRecognizer>::CustomMethod("isValid", &JSGestureRecognizer::IsValid);
508 JSClass<JSSwipeRecognizer>::Inherit<JSGestureRecognizer>();
509 JSClass<JSSwipeRecognizer>::Bind(globalObj, &JSSwipeRecognizer::Constructor, &JSSwipeRecognizer::Destructor);
510 }
511
JSBind(BindingTarget globalObj)512 void JSTouchRecognizer::JSBind(BindingTarget globalObj)
513 {
514 JSClass<JSTouchRecognizer>::Declare("TouchRecognizer");
515 JSClass<JSTouchRecognizer>::CustomMethod("getEventTargetInfo", &JSTouchRecognizer::GetEventTargetInfo);
516 JSClass<JSTouchRecognizer>::CustomMethod("cancelTouch", &JSTouchRecognizer::CancelTouch);
517 JSClass<JSTouchRecognizer>::Bind(globalObj, &JSTouchRecognizer::Constructor, &JSTouchRecognizer::Destructor);
518 }
519 } // namespace OHOS::Ace::Framework