dioxus-gestures 0.2.2

Drag, Pinch, and Hover gestures for dioxus components.
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use paste;
use std::{cell::RefCell, rc::Rc};

use dioxus::{
    core::{AttributeValue, Event, ListenerCallback},
    html::PlatformEventData,
    prelude::{use_hook, Attribute},
};

use crate::state::{
    events::PointerEventReceiver,
    gestures::{drag::Drag, hover::Hover, pinch::Pinch}, options::UseGesturesOptions,
};
use crate::state::{external_handlers::ExternalHandlers, state::UseGesturesState};

#[derive(Clone)]
pub struct UseGestures {
    state: Rc<RefCell<UseGesturesState>>,
}

impl From<Gestures> for UseGestures {
    fn from(value: Gestures) -> Self {
        let Gestures {
            external_handlers,
            hover,
            drag,
            pinch,
            options
        } = value;
        Self {
            state: Rc::new(RefCell::new(UseGesturesState::new(
                external_handlers,
                hover,
                drag,
                pinch,
                options
            ))),
        }
    }
}

impl UseGestures {
    pub fn event_handlers(self) -> Vec<Attribute> {
        macro_rules! pointer_event_handler {
            ($attribute_name: ident, $function_name: ident) => {{
                let pointer_ref = Rc::clone(&self.state);
                Attribute::new(
                    paste::paste! { stringify!([<$attribute_name:camel:lower>])},
                    AttributeValue::Listener(
                        ListenerCallback::new(move |e: Event<PlatformEventData>| {
                            let _ = pointer_ref
                                .try_borrow_mut()
                                .map(|mut s| s.$function_name(e.map(|data| data.into())));
                        })
                        .erase(),
                    ),
                    None,
                    true,
                )
            }};
        }

        vec![
            Attribute::new(
                self.state.borrow().options.target_id_attribute_name,
                AttributeValue::Text(self.state.borrow().options.target_id.to_string()),
                None,
                true,
            ),
            pointer_event_handler!(on_pointer_over, pointer_over),
            pointer_event_handler!(on_pointer_enter, pointer_enter),
            pointer_event_handler!(on_pointer_down, pointer_down),
            pointer_event_handler!(on_pointer_move, pointer_move),
            pointer_event_handler!(on_pointer_up, pointer_up),
            pointer_event_handler!(on_pointer_cancel, pointer_cancel),
            pointer_event_handler!(on_pointer_out, pointer_out),
            pointer_event_handler!(on_pointer_leave, pointer_leave),
        ]
    }
}

pub fn use_gestures<'a>(props: Gestures) -> UseGestures {
    use_hook(|| UseGestures::from(props))
}

#[derive(Default)]
pub struct Gestures {
    pub external_handlers: ExternalHandlers,
    pub hover: Hover,
    pub drag: Drag,
    pub pinch: Pinch,
    pub options: UseGesturesOptions
}

impl Gestures {
    pub fn external_handlers(mut self, external_handlers: ExternalHandlers) -> Self {
        self.external_handlers = external_handlers;
        self
    }

    pub fn hover(mut self, hover: Hover) -> Self {
        self.hover = hover;
        self
    }

    pub fn drag(mut self, drag: Drag) -> Self {
        self.drag = drag;
        self
    }

    pub fn pinch(mut self, pinch: Pinch) -> Self {
        self.pinch = pinch;
        self
    }

    pub fn options(mut self, options: UseGesturesOptions) -> Self {
        self.options = options;
        self
    }
}