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

#![feature(arc_new_cyclic)]
#![deny(clippy::all)]

//! Riddle platform system implementation based on `winit`, managing the OS's main
//! event loop and windowing system.
//!
//! # Riddle Example
//!
//! The **recommended** way to use this crate is through the main `riddle` crate.
//! Riddle exposes this crate through `riddle::platform`.
//!
//! ```no_run
//! use riddle::{*, platform::*};
//!
//! fn main() -> Result<(), RiddleError> {
//!     let rdl =  RiddleLib::new()?;
//!     let window = WindowBuilder::new().build(rdl.context())?;
//!
//!     rdl.run(move |rdl| {
//!         match rdl.event() {
//!             Event::Platform(PlatformEvent::WindowClose(_)) => rdl.quit(),
//!             _ => (),
//!          }
//!     })
//! }
//! ```
//!
//! # Direct Example
//!
//! If you don't want to depend on `riddle`, you can use this crate directly. There isn't much point
//! in doing so over using `winit` directly though - the main function of this crate is to integrate
//! `winit` in to Riddle.
//!
//! ```no_run
//! use riddle_platform_winit::{ext::*, *};
//!
//! fn main() -> Result<(), PlatformError> {
//!     let (platform_system, main_thread_state) = PlatformSystem::new_shared();
//!     let window = WindowBuilder::new().build(main_thread_state.borrow_context())?;
//!
//!     main_thread_state.run::<PlatformError, _>(move |ctx| {
//!         match ctx.event() {
//!             PlatformEvent::WindowClose(_) => { ctx.quit(); }
//!             _ => ()
//!         };
//!         Ok(())
//!     })
//! }
//! ```

mod dimensions;
mod error;
mod event;
mod platform_context;
mod platform_system;
mod window;
mod window_map;

pub mod ext;
pub mod winit_ext;

pub use error::PlatformError;
pub use platform_context::*;
pub use platform_system::*;
pub use riddle_platform_common as common;
pub use window::*;

pub use common::PlatformEvent;

use riddle_common::*;
use window_map::*;

type Result<R> = std::result::Result<R, PlatformError>;