winit 0.7.3

Cross-platform window creation 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
128
129
130
131
132
133


//! This temporary module generates types that wrap around the old API (winit v5 and below) and
//! expose the new API (winit v6 and above).
//!
//! This is temporary so that existing backends can smoothly transition. After all implementations
//! have finished transitionning, this module should disappear.

macro_rules! gen_api_transition {
    () => {
        pub struct EventsLoop {
            windows: ::std::sync::Arc<::std::sync::Mutex<Vec<::std::sync::Arc<Window>>>>,
            awakened: ::std::sync::Arc<::std::sync::atomic::AtomicBool>,
        }

        pub struct EventsLoopProxy {
            awakened: ::std::sync::Weak<::std::sync::atomic::AtomicBool>,
        }

        impl EventsLoop {
            pub fn new() -> EventsLoop {
                EventsLoop {
                    windows: ::std::sync::Arc::new(::std::sync::Mutex::new(vec![])),
                    awakened: ::std::sync::Arc::new(::std::sync::atomic::AtomicBool::new(false)),
                }
            }

            pub fn poll_events<F>(&mut self, mut callback: F)
                where F: FnMut(::Event)
            {
                if self.awakened.load(::std::sync::atomic::Ordering::Relaxed) {
                    self.awakened.store(false, ::std::sync::atomic::Ordering::Relaxed);
                    callback(::Event::Awakened);
                }

                let windows = self.windows.lock().unwrap();
                for window in windows.iter() {
                    for event in window.poll_events() {
                        callback(::Event::WindowEvent {
                            window_id: ::WindowId(WindowId(&**window as *const Window as usize)),
                            event: event,
                        })
                    }
                }
            }

            pub fn run_forever<F>(&mut self, mut callback: F)
                where F: FnMut(::Event) -> ::ControlFlow,
            {
                self.awakened.store(false, ::std::sync::atomic::Ordering::Relaxed);

                // Yeah that's a very bad implementation.
                loop {
                    let mut control_flow = ::ControlFlow::Continue;
                    self.poll_events(|e| {
                        if let ::ControlFlow::Break = callback(e) {
                            control_flow = ::ControlFlow::Break;
                        }
                    });
                    if let ::ControlFlow::Break = control_flow {
                        break;
                    }
                    ::std::thread::sleep(::std::time::Duration::from_millis(5));
                }
            }

            pub fn create_proxy(&self) -> EventsLoopProxy {
                EventsLoopProxy {
                    awakened: ::std::sync::Arc::downgrade(&self.awakened),
                }
            }
        }

        impl EventsLoopProxy {
            pub fn wakeup(&self) -> Result<(), ::EventsLoopClosed> {
                match self.awakened.upgrade() {
                    None => Err(::EventsLoopClosed),
                    Some(awakened) => {
                        awakened.store(true, ::std::sync::atomic::Ordering::Relaxed);
                        Ok(())
                    },
                }
            }
        }

        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
        pub struct WindowId(usize);

        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
        pub struct DeviceId;

        pub struct Window2 {
            pub window: ::std::sync::Arc<Window>,
            windows: ::std::sync::Weak<::std::sync::Mutex<Vec<::std::sync::Arc<Window>>>>
        }

        impl ::std::ops::Deref for Window2 {
            type Target = Window;
            #[inline]
            fn deref(&self) -> &Window {
                &*self.window
            }
        }

        impl Window2 {
            pub fn new(events_loop: &EventsLoop,
                       window: &::WindowAttributes,
                       pl_attribs: &PlatformSpecificWindowBuilderAttributes)
                       -> Result<Window2, CreationError>
            {
                let win = ::std::sync::Arc::new(try!(Window::new(window, pl_attribs)));
                events_loop.windows.lock().unwrap().push(win.clone());
                Ok(Window2 {
                    window: win,
                    windows: ::std::sync::Arc::downgrade(&events_loop.windows),
                })
            }

            #[inline]
            pub fn id(&self) -> WindowId {
                WindowId(&*self.window as *const Window as usize)
            }
        }

        impl Drop for Window2 {
            fn drop(&mut self) {
                if let Some(windows) = self.windows.upgrade() {
                    let mut windows = windows.lock().unwrap();
                    windows.retain(|w| &**w as *const Window != &*self.window as *const _);
                }
            }
        }
    };
}