Crate winit_block_on

Expand description

A simple wrapper around winit that allows one to block on a future using the winit event loop.

winit does not support async programming by default. This crate provides a small workaround that allows one to block on a future using the winit event loop.

Examples

use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoopBuilder};
use winit::window::WindowBuilder;
use winit_block_on::prelude::*;

use std::future::pending;
use std::time::Duration;

// Create an event loop.
let event_loop = EventLoopBuilder::new_block_on().build();

// Create a window inside the event loop.
let window = WindowBuilder::new().build(&event_loop).unwrap();

// Create a proxy that can be used to send events to the event loop.
let proxy = event_loop.create_proxy();

// Block on the future indefinitely.
event_loop.block_on(
    move |event, _, control_flow| {
        match event {
            Event::UserEvent(()) => control_flow.set_exit(),
            Event::WindowEvent {
                event: WindowEvent::CloseRequested,
                window_id
            } if window_id == window.id() => control_flow.set_exit(),
            _ => {}
        }
    },
    async move {
        // Wait for one second.
        async_io::Timer::after(Duration::from_secs(1)).await;

        // Tell the event loop to close.
        proxy.send_event(()).unwrap();
    }
)

This is a contrived example, since control_flow.set_wait_deadline() can do the same thing. See the networking example for a more complex and in-depth example of combining async with winit.

In both cases, the user event T needs to be Send and 'static. This is because the event loop proxy needs to be put into a Waker. In addition, if you are not using run_return, the future needs to be 'static. Both of these limitations could be removed if block_on were integrated directly into winit.

Modules

prelude
Import all relevant traits for this crate.

Structs

Signal
The signal used to notify the event loop that it should wake up.

Enums

BlockOnReturnResult
Either one option or another.

Traits