inset-gestures 0.8.1

Gesture arena and recognizers for Inset
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//! Flutter counterpart: `gestures/eager.dart`.
//!
//! Leaf object. Superclass bags and `super` namespaces are in `recognizer.rs`.

use inset_foundation::{App, Handle};

use crate::arena::GestureDisposition;
use crate::events::{PointerDownEvent, PointerEvent};
use crate::recognizer::{
    GestureRecognizerData, OneSequenceData, OneSequenceGestureRecognizer, OneSequenceLeafData,
    RecognizerLeaf, RecognizerLeafData,
};

/// A gesture recognizer that eagerly claims victory in all gesture arenas.
///
/// This is typically passed in `AndroidView.gestureRecognizers` in order to immediately dispatch
/// all touch events inside the view bounds to the embedded Android view.
pub struct EagerGestureRecognizer {
    recognizer: GestureRecognizerData,
    one_sequence: OneSequenceData,
}

impl EagerGestureRecognizer {
    pub fn new(app: &mut App) -> Handle<EagerGestureRecognizer> {
        app.create(EagerGestureRecognizer {
            recognizer: GestureRecognizerData::new(),
            one_sequence: OneSequenceData::new(),
        })
    }
}

impl RecognizerLeafData for EagerGestureRecognizer {
    fn recognizer(&self) -> &GestureRecognizerData {
        &self.recognizer
    }

    fn recognizer_mut(&mut self) -> &mut GestureRecognizerData {
        &mut self.recognizer
    }
}

impl OneSequenceLeafData for EagerGestureRecognizer {
    fn one_sequence(&self) -> &OneSequenceData {
        &self.one_sequence
    }

    fn one_sequence_mut(&mut self) -> &mut OneSequenceData {
        &mut self.one_sequence
    }
}

impl RecognizerLeaf for EagerGestureRecognizer {
    fn handle_non_allowed_pointer(self: Handle<Self>, app: &mut App, _event: &PointerDownEvent) {
        OneSequenceGestureRecognizer::handle_non_allowed_pointer(self, app);
    }

    fn dispose(self: Handle<Self>, app: &mut App) {
        OneSequenceGestureRecognizer::dispose(self, app);
    }

    fn add_allowed_pointer(self: Handle<Self>, app: &mut App, event: PointerDownEvent) {
        self.start_tracking_pointer(app, event.pointer, event.transform);
        self.resolve(app, GestureDisposition::Accepted);
        OneSequenceGestureRecognizer::stop_tracking_pointer(self, app, event.pointer);
    }

    fn handle_event(self: Handle<Self>, _app: &mut App, _event: PointerEvent) {}

    fn did_stop_tracking_last_pointer(self: Handle<Self>, _app: &mut App, _pointer: i64) {}

    fn debug_description(self: Handle<Self>) -> &'static str {
        "eager"
    }
}