dioxus-gestures 0.1.0

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
121

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

use dioxus::{
    html::{PlatformEventData, PointerData},
    prelude::{use_hook, Attribute, SuperInto},
};

use crate::state::{
    events::PointerEventReceiver,
    gestures::{drag::Drag, hover::Hover, pinch::Pinch},
};
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,
        } = value;
        Self {
            state: Rc::new(RefCell::new(UseGesturesState::new(
                external_handlers,
                hover,
                drag,
                pinch,
            ))),
        }
    }
}

impl UseGestures {
    pub fn event_handlers(self) -> Vec<Attribute> {
        macro_rules! event_handler_attribute {
            ($name:expr, $code:expr) => {{
                let owner =
                    <::generational_box::UnsyncStorage as ::generational_box::AnyStorage>::owner();
                let event_handler: dioxus_core::prelude::EventHandler<
                    dioxus_core::Event<PointerData>,
                > = dioxus_core::prelude::with_owner(owner.clone(), || $code.super_into());
                dioxus_core::Attribute::new(
                    paste::paste! { stringify!([<$name:camel:lower>])},
                    dioxus_core::AttributeValue::listener(
                        move |e: dioxus_core::Event<PlatformEventData>| {
                            _ = &owner;
                            event_handler.call(e.map(|e| e.into()));
                        },
                    ),
                    None,
                    false,
                )
            }};
        }

        macro_rules! pointer_event_handler {
            ($attribute_name: ident, $function_name: ident) => {{
                paste::paste! {
                    let pointer_ref = Rc::clone(&self.state);
                    event_handler_attribute!($attribute_name, move |event: Event<
                        PointerData,
                    >| {
                        pointer_ref.borrow_mut().$function_name(event);
                    })
                }
            }};
        }

        vec![
            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,
}

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
    }
}