Struct riddle_platform_winit::PlatformContext

pub struct PlatformContext<'a> { /* fields omitted */ }

The platform system context provided to the application main thread.

It is used to allow the application to deal with platform events, and perform actions which must be done on the main thread (eg. creating windows).

To acquire a context when using riddle (the recommended approach):

• RiddleLib::context() returns a RiddleContext which implements Borrow<PlatformContext>.
• RiddleLib::run() passes a RiddleContext to the application callback.

To acquire a context when using this crate directly:

• PlatformMainThreadState::borrow_context()
• PlatformMainThreadState::run passes it to application callback

Example

use riddle::{*, platform::*};

fn main() -> Result<(), RiddleError> {
    let rdl =  RiddleLib::new()?;

    // Get a context before the application starts the main event loop.
    let window_a: WindowHandle = WindowBuilder::new().build(rdl.context())?;
    let mut window_b: Option<WindowHandle> = None;

    rdl.run(move |rdl| {
        if window_b.is_none() {
            // rdl: RiddleContext, is used to build the second window.
            window_b = Some(WindowBuilder::new().build(rdl).unwrap());
        } else {
            rdl.quit();
        }
    })
}

Implementations

impl<'a> PlatformContext<'a>

pub fn quit(&self) -> Result<(), PlatformError>

Issue a quit request to the underlying platform system.

The application will quit when that message is processed by the main event loop.

pub fn event(&self) -> &PlatformEvent

Get the event associated with the context.

This will be the platform event that triggered the application closure, or PlatformEvent::Unknown if the context was created before the main event loop has started.

pub fn system(&self) -> &PlatformSystem

The platform system associated with this context.