Draft strategy to reuse view result in event loop

glutin/src/application.rs

@@ -239,11 +239,12 @@ where
             event: window_event,
             ..
         } => {
+            application::handle_control_flow(&window_event, control_flow);
+
             application::handle_window_event(
                 &window_event,
                 context.window(),
                 scale_factor,
-                control_flow,
                 &mut cursor_position,
                 &mut modifiers,
                 &mut viewport,

winit/src/application.rs

@@ -7,7 +7,11 @@ use crate::{
 };
 use iced_graphics::window;
 use iced_graphics::Viewport;
-use iced_native::program::{self, Program};
+use iced_native::program::Program;
+use iced_native::{Cache, UserInterface};
+
+use iced_futures::futures;
+use iced_futures::futures::channel::mpsc;
 
 /// An interactive, native cross-platform application.
 ///
@@ -116,24 +120,86 @@ where
     E: Executor + 'static,
     C: window::Compositor<Renderer = A::Renderer> + 'static,
 {
-    use winit::{
+    use futures::{Future, FutureExt};
-        event,
+    use winit::event_loop::EventLoop;
-        event_loop::{ControlFlow, EventLoop},
-    };
 
     let mut debug = Debug::new();
     debug.startup_started();
 
-    let event_loop = EventLoop::with_user_event();
+    let event_loop: EventLoop<A::Message> = EventLoop::with_user_event();
+
+    let window = settings
+        .window
+        .into_builder("", Mode::Windowed, event_loop.primary_monitor())
+        .build(&event_loop)
+        .map_err(Error::WindowCreationFailed)?;
+
+    let (mut sender, receiver) = mpsc::unbounded();
+    let proxy = Proxy::new(event_loop.create_proxy());
+    let flags = settings.flags;
+
+    let mut event_logic = Box::pin(
+        process_events::<A, E, C>(
+            window,
+            proxy,
+            debug,
+            flags,
+            compositor_settings,
+            receiver,
+        )
+        .map(|_| ()),
+    );
+
+    let waker = futures::task::noop_waker();
+
+    event_loop.run(move |event, _, control_flow| {
+        use winit::event_loop::ControlFlow;
+
+        match event {
+            winit::event::Event::WindowEvent { ref event, .. } => {
+                handle_control_flow(event, control_flow);
+            }
+            _ => {
+                *control_flow = ControlFlow::Wait;
+            }
+        }
+
+        if let Some(event) = event.to_static() {
+            sender.start_send(event).expect("Send event");
+
+            let mut context = futures::task::Context::from_waker(&waker);
+            let _ = event_logic.as_mut().poll(&mut context);
+        }
+    });
+}
+
+/// Runs an [`Application`] with an executor, compositor, and the provided
+/// settings.
+///
+/// [`Application`]: trait.Application.html
+pub async fn process_events<A, E, C>(
+    window: winit::window::Window,
+    proxy: Proxy<A::Message>,
+    mut debug: Debug,
+    flags: A::Flags,
+    compositor_settings: C::Settings,
+    mut receiver: mpsc::UnboundedReceiver<winit::event::Event<'_, A::Message>>,
+) -> Result<(), Error>
+where
+    A: Application + 'static,
+    E: Executor + 'static,
+    C: window::Compositor<Renderer = A::Renderer> + 'static,
+{
+    use iced_futures::futures::stream::StreamExt;
+    use winit::event;
+
     let mut runtime = {
         let executor = E::new().map_err(Error::ExecutorCreationFailed)?;
-        let proxy = Proxy::new(event_loop.create_proxy());
 
         Runtime::new(executor, proxy)
     };
 
-    let flags = settings.flags;
+    let (mut application, init_command) = runtime.enter(|| A::new(flags));
-    let (application, init_command) = runtime.enter(|| A::new(flags));
     runtime.spawn(init_command);
 
     let subscription = application.subscription();
@@ -144,12 +210,6 @@ where
     let mut background_color = application.background_color();
     let mut scale_factor = application.scale_factor();
 
-    let window = settings
-        .window
-        .into_builder(&title, mode, event_loop.primary_monitor())
-        .build(&event_loop)
-        .map_err(Error::WindowCreationFailed)?;
-
     let clipboard = Clipboard::new(&window);
     // TODO: Encode cursor availability in the type-system
     let mut cursor_position = winit::dpi::PhysicalPosition::new(-1.0, -1.0);
@@ -173,46 +233,77 @@ where
         physical_size.height,
     );
 
-    let mut state = program::State::new(
+    let mut user_interface = std::mem::ManuallyDrop::new(build_user_interface(
-        application,
+        &mut application,
-        viewport.logical_size(),
+        Cache::default(),
-        conversion::cursor_position(cursor_position, viewport.scale_factor()),
         &mut renderer,
+        viewport.logical_size(),
         &mut debug,
+    ));
+
+    let mut primitive = user_interface.draw(
+        &mut renderer,
+        conversion::cursor_position(cursor_position, viewport.scale_factor()),
     );
+    let mut events = Vec::new();
+    let mut external_messages = Vec::new();
+
     debug.startup_finished();
 
-    event_loop.run(move |event, _, control_flow| match event {
+    while let Some(event) = receiver.next().await {
+        match event {
             event::Event::MainEventsCleared => {
-            if state.is_queue_empty() {
+                if events.is_empty() && external_messages.is_empty() {
-                return;
+                    continue;
                 }
 
-            let command = runtime.enter(|| {
+                debug.event_processing_started();
-                state.update(
+                let mut messages = user_interface.update(
-                    viewport.logical_size(),
+                    &events,
                     conversion::cursor_position(
                         cursor_position,
                         viewport.scale_factor(),
                     ),
                     clipboard.as_ref().map(|c| c as _),
                     &mut renderer,
-                    &mut debug,
+                );
-                )
+
-            });
+                messages.extend(external_messages.drain(..));
+                events.clear();
+                debug.event_processing_finished();
+
+                if messages.is_empty() {
+                    debug.draw_started();
+                    primitive = user_interface.draw(
+                        &mut renderer,
+                        conversion::cursor_position(
+                            cursor_position,
+                            viewport.scale_factor(),
+                        ),
+                    );
+                    debug.draw_finished();
+                } else {
+                    let cache =
+                        std::mem::ManuallyDrop::into_inner(user_interface)
+                            .into_cache();
+
+                    for message in messages.drain(..) {
+                        debug.log_message(&message);
+
+                        debug.update_started();
+                        let command =
+                            runtime.enter(|| application.update(message));
+                        debug.update_finished();
 
-            // If the application was updated
-            if let Some(command) = command {
                         runtime.spawn(command);
-
+                    }
-                let program = state.program();
 
                     // Update subscriptions
-                let subscription = program.subscription();
+                    let subscription = application.subscription();
                     runtime.track(subscription);
 
                     // Update window title
-                let new_title = program.title();
+                    let new_title = application.title();
 
                     if title != new_title {
                         window.set_title(&new_title);
@@ -221,7 +312,7 @@ where
                     }
 
                     // Update window mode
-                let new_mode = program.mode();
+                    let new_mode = application.mode();
 
                     if mode != new_mode {
                         window.set_fullscreen(conversion::fullscreen(
@@ -233,10 +324,10 @@ where
                     }
 
                     // Update background color
-                background_color = program.background_color();
+                    background_color = application.background_color();
 
                     // Update scale factor
-                let new_scale_factor = program.scale_factor();
+                    let new_scale_factor = application.scale_factor();
 
                     if scale_factor != new_scale_factor {
                         let size = window.inner_size();
@@ -246,30 +337,33 @@ where
                             window.scale_factor() * new_scale_factor,
                         );
 
-                    // We relayout the UI with the new logical size.
+                        scale_factor = new_scale_factor;
-                    // The queue is empty, therefore this will never produce
+                    }
-                    // a `Command`.
+
-                    //
+                    user_interface =
-                    // TODO: Properly queue `WindowResized`
+                        std::mem::ManuallyDrop::new(build_user_interface(
-                    let _ = state.update(
+                            &mut application,
+                            cache,
+                            &mut renderer,
                             viewport.logical_size(),
+                            &mut debug,
+                        ));
+
+                    debug.draw_started();
+                    primitive = user_interface.draw(
+                        &mut renderer,
                         conversion::cursor_position(
                             cursor_position,
                             viewport.scale_factor(),
                         ),
-                        clipboard.as_ref().map(|c| c as _),
-                        &mut renderer,
-                        &mut debug,
                     );
-
+                    debug.draw_finished();
-                    scale_factor = new_scale_factor;
-                }
                 }
 
                 window.request_redraw();
             }
             event::Event::UserEvent(message) => {
-            state.queue_message(message);
+                external_messages.push(message);
             }
             event::Event::RedrawRequested(_) => {
                 debug.render_started();
@@ -291,7 +385,7 @@ where
                     &mut swap_chain,
                     &viewport,
                     background_color,
-                state.primitive(),
+                    &primitive,
                     &debug.overlay(),
                 );
 
@@ -316,7 +410,6 @@ where
                     &window_event,
                     &window,
                     scale_factor,
-                control_flow,
                     &mut cursor_position,
                     &mut modifiers,
                     &mut viewport,
@@ -329,30 +422,59 @@ where
                     viewport.scale_factor(),
                     modifiers,
                 ) {
-                state.queue_event(event.clone());
+                    events.push(event.clone());
                     runtime.broadcast(event);
                 }
             }
-        _ => {
+            _ => {}
-            *control_flow = ControlFlow::Wait;
         }
-    })
     }
 
-/// Handles a `WindowEvent` and mutates the provided control flow, keyboard
+    Ok(())
-/// modifiers, viewport, and resized flag accordingly.
+}
+
+/// Handles a `WindowEvent` and mutates the provided control flow to exit
+/// if necessary.
+pub fn handle_control_flow(
+    event: &winit::event::WindowEvent<'_>,
+    control_flow: &mut winit::event_loop::ControlFlow,
+) {
+    use winit::event::WindowEvent;
+    use winit::event_loop::ControlFlow;
+
+    match event {
+        WindowEvent::CloseRequested => {
+            *control_flow = ControlFlow::Exit;
+        }
+        #[cfg(target_os = "macos")]
+        WindowEvent::KeyboardInput {
+            input:
+                winit::event::KeyboardInput {
+                    virtual_keycode: Some(winit::event::VirtualKeyCode::Q),
+                    state: winit::event::ElementState::Pressed,
+                    ..
+                },
+            ..
+        } if modifiers.logo() => {
+            *control_flow = ControlFlow::Exit;
+        }
+        _ => {}
+    }
+}
+
+/// Handles a `WindowEvent` and mutates the keyboard modifiers, viewport, and
+/// resized flag accordingly.
 pub fn handle_window_event(
     event: &winit::event::WindowEvent<'_>,
     window: &winit::window::Window,
     scale_factor: f64,
-    control_flow: &mut winit::event_loop::ControlFlow,
     cursor_position: &mut winit::dpi::PhysicalPosition<f64>,
     modifiers: &mut winit::event::ModifiersState,
     viewport: &mut Viewport,
     resized: &mut bool,
     _debug: &mut Debug,
 ) {
-    use winit::{event::WindowEvent, event_loop::ControlFlow};
+    use winit::event::WindowEvent;
 
     match event {
         WindowEvent::Resized(new_size) => {
@@ -376,9 +498,6 @@ pub fn handle_window_event(
             );
             *resized = true;
         }
-        WindowEvent::CloseRequested => {
-            *control_flow = ControlFlow::Exit;
-        }
         WindowEvent::CursorMoved { position, .. } => {
             *cursor_position = *position;
         }
@@ -389,18 +508,6 @@ pub fn handle_window_event(
         WindowEvent::ModifiersChanged(new_modifiers) => {
             *modifiers = *new_modifiers;
         }
-        #[cfg(target_os = "macos")]
-        WindowEvent::KeyboardInput {
-            input:
-                winit::event::KeyboardInput {
-                    virtual_keycode: Some(winit::event::VirtualKeyCode::Q),
-                    state: winit::event::ElementState::Pressed,
-                    ..
-                },
-            ..
-        } if modifiers.logo() => {
-            *control_flow = ControlFlow::Exit;
-        }
         #[cfg(feature = "debug")]
         WindowEvent::KeyboardInput {
             input:
@@ -414,3 +521,21 @@ pub fn handle_window_event(
         _ => {}
     }
 }
+
+fn build_user_interface<'a, A: Application>(
+    application: &'a mut A,
+    cache: Cache,
+    renderer: &mut A::Renderer,
+    size: Size,
+    debug: &mut Debug,
+) -> UserInterface<'a, A::Message, A::Renderer> {
+    debug.view_started();
+    let view = application.view();
+    debug.view_finished();
+
+    debug.layout_started();
+    let user_interface = UserInterface::build(view, size, cache, renderer);
+    debug.layout_finished();
+
+    user_interface
+}