diff --git a/glutin/src/application.rs b/glutin/src/application.rs index 8718b81f..b8e80ddf 100644 --- a/glutin/src/application.rs +++ b/glutin/src/application.rs @@ -1,13 +1,16 @@ //! Create interactive, native cross-platform applications. use crate::{mouse, Error, Executor, Runtime, Size}; -use iced_graphics::window; -use iced_graphics::Viewport; -use iced_winit::application; -use iced_winit::conversion; -use iced_winit::{Clipboard, Debug, Proxy, Settings}; -pub use iced_winit::Application; -pub use iced_winit::{program, Program}; +pub use iced_winit::application::{self, Application}; + +use iced_graphics::window; +use iced_winit::conversion; +use iced_winit::futures; +use iced_winit::futures::channel::mpsc; +use iced_winit::{Cache, Clipboard, Debug, Proxy, Settings, UserInterface}; + +use glutin::window::Window; +use std::mem::ManuallyDrop; /// Runs an [`Application`] with an executor, compositor, and the provided /// settings. @@ -22,11 +25,10 @@ where E: Executor + 'static, C: window::GLCompositor + 'static, { - use glutin::{ - event, - event_loop::{ControlFlow, EventLoop}, - ContextBuilder, - }; + use futures::task; + use futures::Future; + use glutin::event_loop::EventLoop; + use glutin::ContextBuilder; let mut debug = Debug::new(); debug.startup_started(); @@ -39,22 +41,21 @@ where Runtime::new(executor, proxy) }; - let flags = settings.flags; - let (application, init_command) = runtime.enter(|| A::new(flags)); - runtime.spawn(init_command); + let (application, init_command) = { + let flags = settings.flags; + + runtime.enter(|| A::new(flags)) + }; let subscription = application.subscription(); - runtime.track(subscription); - let mut title = application.title(); - let mut mode = application.mode(); - let mut background_color = application.background_color(); - let mut scale_factor = application.scale_factor(); + runtime.spawn(init_command); + runtime.track(subscription); let context = { let builder = settings.window.into_builder( - &title, - mode, + &application.title(), + application.mode(), event_loop.primary_monitor(), ); @@ -79,190 +80,242 @@ where } }; - let clipboard = Clipboard::new(&context.window()); - let mut cursor_position = glutin::dpi::PhysicalPosition::new(-1.0, -1.0); - let mut mouse_interaction = mouse::Interaction::default(); - let mut modifiers = glutin::event::ModifiersState::default(); - - let physical_size = context.window().inner_size(); - let mut viewport = Viewport::with_physical_size( - Size::new(physical_size.width, physical_size.height), - context.window().scale_factor() * scale_factor, - ); - let mut resized = false; - #[allow(unsafe_code)] - let (mut compositor, mut renderer) = unsafe { + let (compositor, renderer) = unsafe { C::new(compositor_settings, |address| { context.get_proc_address(address) })? }; - let mut state = program::State::new( + let (mut sender, receiver) = mpsc::unbounded(); + + let mut instance = Box::pin(run_instance::( application, - viewport.logical_size(), - conversion::cursor_position(cursor_position, viewport.scale_factor()), + compositor, + renderer, + context, + runtime, + debug, + receiver, + )); + + let mut context = task::Context::from_waker(task::noop_waker_ref()); + + event_loop.run(move |event, _, control_flow| { + use glutin::event_loop::ControlFlow; + + if let ControlFlow::Exit = control_flow { + return; + } + + if let Some(event) = event.to_static() { + sender.start_send(event).expect("Send event"); + + let poll = instance.as_mut().poll(&mut context); + + *control_flow = match poll { + task::Poll::Pending => ControlFlow::Wait, + task::Poll::Ready(_) => ControlFlow::Exit, + }; + } + }); +} + +async fn run_instance( + mut application: A, + mut compositor: C, + mut renderer: A::Renderer, + context: glutin::ContextWrapper, + mut runtime: Runtime, A::Message>, + mut debug: Debug, + mut receiver: mpsc::UnboundedReceiver>, +) where + A: Application + 'static, + E: Executor + 'static, + C: window::GLCompositor + 'static, +{ + use glutin::event; + use iced_winit::futures::stream::StreamExt; + + let mut state = application::State::new(&application, context.window()); + let mut viewport_version = state.viewport_version(); + + let clipboard = Clipboard::new(context.window()); + + let mut user_interface = ManuallyDrop::new(build_user_interface( + &mut application, + Cache::default(), &mut renderer, + state.logical_size(), &mut debug, - ); + )); + + let mut primitive = + user_interface.draw(&mut renderer, state.cursor_position()); + let mut mouse_interaction = mouse::Interaction::default(); + + let mut events = Vec::new(); + let mut external_messages = Vec::new(); + debug.startup_finished(); - event_loop.run(move |event, _, control_flow| match event { - event::Event::MainEventsCleared => { - if state.is_queue_empty() { - return; - } + while let Some(event) = receiver.next().await { + match event { + event::Event::MainEventsCleared => { + if events.is_empty() && external_messages.is_empty() { + continue; + } - let command = runtime.enter(|| { - state.update( - viewport.logical_size(), - conversion::cursor_position( - cursor_position, - viewport.scale_factor(), - ), + debug.event_processing_started(); + let mut messages = user_interface.update( + &events, + state.cursor_position(), clipboard.as_ref().map(|c| c as _), &mut renderer, - &mut debug, - ) - }); - - // If the application was updated - if let Some(command) = command { - runtime.spawn(command); - - let program = state.program(); - - // Update subscriptions - let subscription = program.subscription(); - runtime.track(subscription); - - // Update window title - let new_title = program.title(); - - if title != new_title { - context.window().set_title(&new_title); - - title = new_title; - } - - // Update window mode - let new_mode = program.mode(); - - if mode != new_mode { - context.window().set_fullscreen(conversion::fullscreen( - context.window().current_monitor(), - new_mode, - )); - - mode = new_mode; - } - - // Update background color - background_color = program.background_color(); - - // Update scale factor - let new_scale_factor = program.scale_factor(); - - if scale_factor != new_scale_factor { - let size = context.window().inner_size(); - - viewport = Viewport::with_physical_size( - Size::new(size.width, size.height), - context.window().scale_factor() * new_scale_factor, - ); - - // We relayout the UI with the new logical size. - // The queue is empty, therefore this will never produce - // a `Command`. - // - // TODO: Properly queue `WindowResized` - let _ = state.update( - viewport.logical_size(), - conversion::cursor_position( - cursor_position, - viewport.scale_factor(), - ), - clipboard.as_ref().map(|c| c as _), - &mut renderer, - &mut debug, - ); - - scale_factor = new_scale_factor; - } - } - - context.window().request_redraw(); - } - event::Event::UserEvent(message) => { - state.queue_message(message); - } - event::Event::RedrawRequested(_) => { - debug.render_started(); - - if resized { - let physical_size = viewport.physical_size(); - - context.resize(glutin::dpi::PhysicalSize::new( - physical_size.width, - physical_size.height, - )); - - compositor.resize_viewport(physical_size); - - resized = false; - } - - let new_mouse_interaction = compositor.draw( - &mut renderer, - &viewport, - background_color, - state.primitive(), - &debug.overlay(), - ); - - context.swap_buffers().expect("Swap buffers"); - - debug.render_finished(); - - if new_mouse_interaction != mouse_interaction { - context.window().set_cursor_icon( - conversion::mouse_interaction(new_mouse_interaction), ); - mouse_interaction = new_mouse_interaction; + messages.extend(external_messages.drain(..)); + events.clear(); + debug.event_processing_finished(); + + if messages.is_empty() { + debug.draw_started(); + primitive = user_interface + .draw(&mut renderer, state.cursor_position()); + debug.draw_finished(); + } else { + let cache = + 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(); + + runtime.spawn(command); + } + + // Update subscriptions + let subscription = application.subscription(); + runtime.track(subscription); + + // Update window + state.synchronize(&application, context.window()); + + user_interface = ManuallyDrop::new(build_user_interface( + &mut application, + cache, + &mut renderer, + state.logical_size(), + &mut debug, + )); + + debug.draw_started(); + primitive = user_interface + .draw(&mut renderer, state.cursor_position()); + debug.draw_finished(); + } + + context.window().request_redraw(); } - - // TODO: Handle animations! - // Maybe we can use `ControlFlow::WaitUntil` for this. - } - event::Event::WindowEvent { - event: window_event, - .. - } => { - application::handle_control_flow(&window_event, control_flow); - - application::handle_window_event( - &window_event, - context.window(), - scale_factor, - &mut cursor_position, - &mut modifiers, - &mut viewport, - &mut resized, - &mut debug, - ); - - if let Some(event) = conversion::window_event( - &window_event, - viewport.scale_factor(), - modifiers, - ) { - state.queue_event(event.clone()); - runtime.broadcast(event); + event::Event::UserEvent(message) => { + external_messages.push(message); } + event::Event::RedrawRequested(_) => { + debug.render_started(); + let current_viewport_version = state.viewport_version(); + + if viewport_version != current_viewport_version { + let physical_size = state.physical_size(); + let logical_size = state.logical_size(); + + debug.layout_started(); + user_interface = ManuallyDrop::new( + ManuallyDrop::into_inner(user_interface) + .relayout(logical_size, &mut renderer), + ); + debug.layout_finished(); + + debug.draw_started(); + primitive = user_interface + .draw(&mut renderer, state.cursor_position()); + debug.draw_finished(); + + context.resize(glutin::dpi::PhysicalSize::new( + physical_size.width, + physical_size.height, + )); + + compositor.resize_viewport(physical_size); + + viewport_version = current_viewport_version; + } + + let new_mouse_interaction = compositor.draw( + &mut renderer, + state.viewport(), + state.background_color(), + &primitive, + &debug.overlay(), + ); + + context.swap_buffers().expect("Swap buffers"); + + debug.render_finished(); + + if new_mouse_interaction != mouse_interaction { + context.window().set_cursor_icon( + conversion::mouse_interaction(new_mouse_interaction), + ); + + mouse_interaction = new_mouse_interaction; + } + + // TODO: Handle animations! + // Maybe we can use `ControlFlow::WaitUntil` for this. + } + event::Event::WindowEvent { + event: window_event, + .. + } => { + if application::requests_exit(&window_event, state.modifiers()) + { + break; + } + + state.update(context.window(), &window_event, &mut debug); + + if let Some(event) = conversion::window_event( + &window_event, + state.scale_factor(), + state.modifiers(), + ) { + events.push(event.clone()); + runtime.broadcast(event); + } + } + _ => {} } - _ => { - *control_flow = ControlFlow::Wait; - } - }) + } +} + +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 } diff --git a/winit/src/application.rs b/winit/src/application.rs index 96438d73..07108249 100644 --- a/winit/src/application.rs +++ b/winit/src/application.rs @@ -145,6 +145,7 @@ where let (application, init_command) = { let flags = settings.flags; + runtime.enter(|| A::new(flags)) }; @@ -408,8 +409,6 @@ pub fn requests_exit( } } -/// Handles a `WindowEvent` and mutates the keyboard modifiers, viewport, and -/// resized flag accordingly. fn build_user_interface<'a, A: Application>( application: &'a mut A, cache: Cache,