app_window 0.3.3

Cross-platform window library
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::input::Window;
use crate::input::keyboard::wasm::ARBITRARY_WINDOW_PTR;
use crate::input::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 {}

impl PlatformCoalescedMouse {
    pub async fn new(shared: &Arc<crate::input::mouse::Shared>) -> Self {
        let shared = shared.clone();

        crate::application::on_main_thread("PlatformCoalescedMouse setup".to_string(), move || {
            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 window = web_sys::window().expect("no global window exists");
                    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.offset_x() as f64,
                        event.offset_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");
            mousemove_callback.forget();

            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");
            mousedown_callback.forget();

            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");
            mouseup_callback.forget();

            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, y, 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");
            wheel_callback.forget();

            PlatformCoalescedMouse {}
        })
        .await
    }
}