async-winit 0.2.1

Use winit like an async runtime
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

/*

`async-winit` is free software: you can redistribute it and/or modify it under the terms of one of
the following licenses:

* GNU Lesser General Public License as published by the Free Software Foundation, either
  version 3 of the License, or (at your option) any later version.
* Mozilla Public License as published by the Mozilla Foundation, version 2.

`async-winit` is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General
Public License and the Patron License for more details.

You should have received a copy of the GNU Lesser General Public License and the Mozilla
Public License along with `async-winit`. If not, see <https://www.gnu.org/licenses/>.

*/

//! Platform specific code.

#[cfg(android_platform)]
pub mod android;

#[cfg(ios_platform)]
pub mod ios;

#[cfg(macos_platform)]
pub mod macos;

#[cfg(orbital_platform)]
pub mod orbital;

#[cfg(x11_platform)]
pub mod x11;

#[cfg(wayland_platform)]
pub mod wayland;

#[cfg(windows)]
pub mod windows;

#[cfg(any(windows, x11_platform, wayland_platform))]
pub mod run_return;

cfg_if::cfg_if! {
    if #[cfg(android_platform)] {
        pub(crate) use android::PlatformSpecific;
    } else if #[cfg(ios_platform)] {
        pub(crate) use ios::PlatformSpecific;
    } else if #[cfg(macos_platform)] {
        pub(crate) use macos::PlatformSpecific;
    } else if #[cfg(orbital_platform)] {
        pub(crate) use orbital::PlatformSpecific;
    } else if #[cfg(any(x11_platform, wayland_platform))] {
        #[cfg(all(feature = "x11", not(feature = "wayland")))]
        pub(crate) use x11::PlatformSpecific;

        #[cfg(all(not(feature = "x11"), feature = "wayland"))]
        pub(crate) use wayland::PlatformSpecific;

        #[cfg(all(feature = "x11", feature = "wayland"))]
        mod free_unix;
        #[cfg(all(feature = "x11", feature = "wayland"))]
        pub(crate) use free_unix::PlatformSpecific;
    } else if #[cfg(windows)] {
        pub(crate) use windows::PlatformSpecific;
    }
}

mod __private {
    use crate::event_loop::{EventLoop, EventLoopBuilder, EventLoopWindowTarget};
    use crate::window::{Window, WindowBuilder};

    #[doc(hidden)]
    pub struct Internal(());

    macro_rules! sealed_trait {
        ($($name: ident $tname: ident)*) => {$(
            #[doc(hidden)]
            pub trait $tname {
                fn __sealed_marker(i: Internal);
            }

            impl $tname for $name {
                fn __sealed_marker(_: Internal) {}
            }
        )*}
    }

    macro_rules! sealed_trait_with_gen {
        ($($name: ident $tname: ident)*) => {$(
            #[doc(hidden)]
            pub trait $tname {
                fn __sealed_marker(i: Internal);
            }

            impl<TS: crate::sync::ThreadSafety> $tname for $name<TS> {
                fn __sealed_marker(_: Internal) {}
            }
        )*}
    }

    sealed_trait! {
        EventLoopBuilder EventLoopBuilderPrivate
        WindowBuilder WindowBuilderPrivate
    }

    sealed_trait_with_gen! {
        EventLoopWindowTarget EventLoopWindowTargetPrivate
        EventLoop EventLoopPrivate
        Window WindowPrivate
    }
}