app_input 0.1.2

Cross-platform mouse and keyboard input
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
122
123
124
125
126
127

// SPDX-License-Identifier: MPL-2.0
use crate::Window;
use crate::keyboard::wasm::ARBITRARY_WINDOW_PTR;
use crate::mouse::MouseWindowLocation;
use std::ptr::NonNull;
use std::sync::Arc;
use wasm_bindgen::prelude::*;
use web_sys::{MouseEvent, WheelEvent};

fn js_button_to_rust(button: i16) -> u8 {
    match button {
        0 => 0,
        1 => 2,
        2 => 1,
        _ => button as u8,
    }
}

#[derive(Debug)]
pub(super) struct PlatformCoalescedMouse {
    _mouse_listener: JsValue,
    _mousedown_listener: JsValue,
    _mouseup_listener: JsValue,
    _wheel_listener: JsValue,
}

unsafe impl Send for PlatformCoalescedMouse {}
unsafe impl Sync for PlatformCoalescedMouse {}

impl PlatformCoalescedMouse {
    pub fn new(shared: &Arc<crate::mouse::Shared>) -> Self {
        let window = web_sys::window().expect("no global window exists");
        let document = window.document().expect("no document on window");

        let weak = Arc::downgrade(&shared);
        let weak_down = weak.clone();
        let weak_up = weak.clone();
        let weak_wheel = weak.clone();

        // Mouse move callback
        let mousemove_callback = Closure::wrap(Box::new(move |event: MouseEvent| {
            if let Some(shared) = weak.upgrade() {
                let width = window
                    .inner_width()
                    .expect("failed to get width")
                    .as_f64()
                    .unwrap_or(0.0);

                let height = window
                    .inner_height()
                    .expect("failed to get height")
                    .as_f64()
                    .unwrap_or(0.0);
                let window = Some(Window(NonNull::new(ARBITRARY_WINDOW_PTR).unwrap()));

                shared.set_window_location(MouseWindowLocation::new(
                    event.page_x() as f64,
                    event.page_y() as f64,
                    width,
                    height,
                    window,
                ));
            }
        }) as Box<dyn FnMut(MouseEvent)>);

        document
            .add_event_listener_with_callback(
                "mousemove",
                mousemove_callback.as_ref().unchecked_ref(),
            )
            .expect("Can't add event listener");

        let mousedown_callback = Closure::wrap(Box::new(move |event: MouseEvent| {
            if let Some(shared) = weak_down.upgrade() {
                shared.set_key_state(
                    js_button_to_rust(event.button()),
                    true,
                    ARBITRARY_WINDOW_PTR,
                );
            }
        }) as Box<dyn FnMut(MouseEvent)>);
        document
            .add_event_listener_with_callback(
                "mousedown",
                mousedown_callback.as_ref().unchecked_ref(),
            )
            .expect("Can't add event listener");

        let mouseup_callback = Closure::wrap(Box::new(move |event: MouseEvent| {
            if let Some(shared) = weak_up.upgrade() {
                shared.set_key_state(
                    js_button_to_rust(event.button()),
                    false,
                    ARBITRARY_WINDOW_PTR,
                );
            }
        }) as Box<dyn FnMut(MouseEvent)>);
        document
            .add_event_listener_with_callback("mouseup", mouseup_callback.as_ref().unchecked_ref())
            .expect("Can't add event listener");

        let wheel_callback = Closure::wrap(Box::new(move |event: WheelEvent| {
            let raw_x = event.delta_x();
            let raw_y = event.delta_y();
            let mode = event.delta_mode();
            let (x, y) = match mode {
                1 => (raw_x * 10.0, raw_y * 10.0),
                2 => (raw_x * 100.0, raw_y * 100.0),
                _ => (raw_x, raw_y),
            };

            if let Some(shared) = weak_wheel.upgrade() {
                shared.add_scroll_delta(x as f64, y as f64, ARBITRARY_WINDOW_PTR);
            }
        }) as Box<dyn FnMut(WheelEvent)>);
        document
            .add_event_listener_with_callback("wheel", wheel_callback.as_ref().unchecked_ref())
            .expect("Can't add event listener");

        Self {
            _mouse_listener: mousemove_callback.into_js_value(),
            _mousedown_listener: mousedown_callback.into_js_value(),
            _mouseup_listener: mouseup_callback.into_js_value(),
            _wheel_listener: wheel_callback.into_js_value(),
        }
    }
}