From d53ccc857da4d4cda769904342aeb5a82a64f146 Mon Sep 17 00:00:00 2001 From: Bingus Date: Wed, 12 Jul 2023 19:21:05 -0700 Subject: refactored window storage; new helper window events (Destroyed, Created); clippy + fmt; --- runtime/Cargo.toml | 1 + runtime/src/lib.rs | 3 + runtime/src/multi_window.rs | 6 + runtime/src/multi_window/program.rs | 32 +++++ runtime/src/multi_window/state.rs | 280 ++++++++++++++++++++++++++++++++++++ runtime/src/window.rs | 102 +++++++------ runtime/src/window/action.rs | 4 +- 7 files changed, 386 insertions(+), 42 deletions(-) create mode 100644 runtime/src/multi_window.rs create mode 100644 runtime/src/multi_window/program.rs create mode 100644 runtime/src/multi_window/state.rs (limited to 'runtime') diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index a65f07f2..3d2976a7 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -9,6 +9,7 @@ repository = "https://github.com/iced-rs/iced" [features] debug = [] +multi-window = [] [dependencies] thiserror = "1" diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 4bbf9687..4c39f80f 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -53,6 +53,9 @@ pub mod system; pub mod user_interface; pub mod window; +#[cfg(feature = "multi-window")] +pub mod multi_window; + // We disable debug capabilities on release builds unless the `debug` feature // is explicitly enabled. #[cfg(feature = "debug")] diff --git a/runtime/src/multi_window.rs b/runtime/src/multi_window.rs new file mode 100644 index 00000000..cf778a20 --- /dev/null +++ b/runtime/src/multi_window.rs @@ -0,0 +1,6 @@ +//! A multi-window application. +pub mod program; +pub mod state; + +pub use program::Program; +pub use state::State; diff --git a/runtime/src/multi_window/program.rs b/runtime/src/multi_window/program.rs new file mode 100644 index 00000000..c3989d0d --- /dev/null +++ b/runtime/src/multi_window/program.rs @@ -0,0 +1,32 @@ +//! Build interactive programs using The Elm Architecture. +use crate::{window, Command}; + +use crate::core::text; +use crate::core::{Element, Renderer}; + +/// The core of a user interface for a multi-window application following The Elm Architecture. +pub trait Program: Sized { + /// The graphics backend to use to draw the [`Program`]. + type Renderer: Renderer + text::Renderer; + + /// The type of __messages__ your [`Program`] will produce. + type Message: std::fmt::Debug + Send; + + /// Handles a __message__ and updates the state of the [`Program`]. + /// + /// This is where you define your __update logic__. All the __messages__, + /// produced by either user interactions or commands, will be handled by + /// this method. + /// + /// Any [`Command`] returned will be executed immediately in the + /// background by shells. + fn update(&mut self, message: Self::Message) -> Command; + + /// Returns the widgets to display in the [`Program`] for the `window`. + /// + /// These widgets can produce __messages__ based on user interaction. + fn view( + &self, + window: window::Id, + ) -> Element<'_, Self::Message, Self::Renderer>; +} diff --git a/runtime/src/multi_window/state.rs b/runtime/src/multi_window/state.rs new file mode 100644 index 00000000..78c35e6c --- /dev/null +++ b/runtime/src/multi_window/state.rs @@ -0,0 +1,280 @@ +//! The internal state of a multi-window [`Program`]. +use crate::core::event::{self, Event}; +use crate::core::mouse; +use crate::core::renderer; +use crate::core::widget::operation::{self, Operation}; +use crate::core::{Clipboard, Size}; +use crate::user_interface::{self, UserInterface}; +use crate::{Command, Debug, Program}; + +/// The execution state of a multi-window [`Program`]. It leverages caching, event +/// processing, and rendering primitive storage. +#[allow(missing_debug_implementations)] +pub struct State

+where + P: Program + 'static, +{ + program: P, + caches: Option>, + queued_events: Vec, + queued_messages: Vec, + mouse_interaction: mouse::Interaction, +} + +impl

State

+where + P: Program + 'static, +{ + /// Creates a new [`State`] with the provided [`Program`], initializing its + /// primitive with the given logical bounds and renderer. + pub fn new( + program: P, + bounds: Size, + renderer: &mut P::Renderer, + debug: &mut Debug, + ) -> Self { + let user_interface = build_user_interface( + &program, + user_interface::Cache::default(), + renderer, + bounds, + debug, + ); + + let caches = Some(vec![user_interface.into_cache()]); + + State { + program, + caches, + queued_events: Vec::new(), + queued_messages: Vec::new(), + mouse_interaction: mouse::Interaction::Idle, + } + } + + /// Returns a reference to the [`Program`] of the [`State`]. + pub fn program(&self) -> &P { + &self.program + } + + /// Queues an event in the [`State`] for processing during an [`update`]. + /// + /// [`update`]: Self::update + pub fn queue_event(&mut self, event: Event) { + self.queued_events.push(event); + } + + /// Queues a message in the [`State`] for processing during an [`update`]. + /// + /// [`update`]: Self::update + pub fn queue_message(&mut self, message: P::Message) { + self.queued_messages.push(message); + } + + /// Returns whether the event queue of the [`State`] is empty or not. + pub fn is_queue_empty(&self) -> bool { + self.queued_events.is_empty() && self.queued_messages.is_empty() + } + + /// Returns the current [`mouse::Interaction`] of the [`State`]. + pub fn mouse_interaction(&self) -> mouse::Interaction { + self.mouse_interaction + } + + /// Processes all the queued events and messages, rebuilding and redrawing + /// the widgets of the linked [`Program`] if necessary. + /// + /// Returns a list containing the instances of [`Event`] that were not + /// captured by any widget, and the [`Command`] obtained from [`Program`] + /// after updating it, only if an update was necessary. + pub fn update( + &mut self, + bounds: Size, + cursor: mouse::Cursor, + renderer: &mut P::Renderer, + theme: &::Theme, + style: &renderer::Style, + clipboard: &mut dyn Clipboard, + debug: &mut Debug, + ) -> (Vec, Option>) { + let mut user_interfaces = build_user_interfaces( + &self.program, + self.caches.take().unwrap(), + renderer, + bounds, + debug, + ); + + debug.event_processing_started(); + let mut messages = Vec::new(); + + let uncaptured_events = user_interfaces.iter_mut().fold( + vec![], + |mut uncaptured_events, ui| { + let (_, event_statuses) = ui.update( + &self.queued_events, + cursor, + renderer, + clipboard, + &mut messages, + ); + + uncaptured_events.extend( + self.queued_events + .iter() + .zip(event_statuses) + .filter_map(|(event, status)| { + matches!(status, event::Status::Ignored) + .then_some(event) + }) + .cloned(), + ); + uncaptured_events + }, + ); + + self.queued_events.clear(); + messages.append(&mut self.queued_messages); + debug.event_processing_finished(); + + let commands = if messages.is_empty() { + debug.draw_started(); + + for ui in &mut user_interfaces { + self.mouse_interaction = + ui.draw(renderer, theme, style, cursor); + } + + debug.draw_finished(); + + self.caches = Some( + user_interfaces + .drain(..) + .map(UserInterface::into_cache) + .collect(), + ); + + None + } else { + let temp_caches = user_interfaces + .drain(..) + .map(UserInterface::into_cache) + .collect(); + + drop(user_interfaces); + + let commands = Command::batch(messages.into_iter().map(|msg| { + debug.log_message(&msg); + + debug.update_started(); + let command = self.program.update(msg); + debug.update_finished(); + + command + })); + + let mut user_interfaces = build_user_interfaces( + &self.program, + temp_caches, + renderer, + bounds, + debug, + ); + + debug.draw_started(); + for ui in &mut user_interfaces { + self.mouse_interaction = + ui.draw(renderer, theme, style, cursor); + } + debug.draw_finished(); + + self.caches = Some( + user_interfaces + .drain(..) + .map(UserInterface::into_cache) + .collect(), + ); + + Some(commands) + }; + + (uncaptured_events, commands) + } + + /// Applies [`widget::Operation`]s to the [`State`] + pub fn operate( + &mut self, + renderer: &mut P::Renderer, + operations: impl Iterator>>, + bounds: Size, + debug: &mut Debug, + ) { + let mut user_interfaces = build_user_interfaces( + &self.program, + self.caches.take().unwrap(), + renderer, + bounds, + debug, + ); + + for operation in operations { + let mut current_operation = Some(operation); + + while let Some(mut operation) = current_operation.take() { + for ui in &mut user_interfaces { + ui.operate(renderer, operation.as_mut()); + } + + match operation.finish() { + operation::Outcome::None => {} + operation::Outcome::Some(message) => { + self.queued_messages.push(message) + } + operation::Outcome::Chain(next) => { + current_operation = Some(next); + } + }; + } + } + + self.caches = Some( + user_interfaces + .drain(..) + .map(UserInterface::into_cache) + .collect(), + ); + } +} + +fn build_user_interfaces<'a, P: Program>( + program: &'a P, + mut caches: Vec, + renderer: &mut P::Renderer, + size: Size, + debug: &mut Debug, +) -> Vec> { + caches + .drain(..) + .map(|cache| { + build_user_interface(program, cache, renderer, size, debug) + }) + .collect() +} + +fn build_user_interface<'a, P: Program>( + program: &'a P, + cache: user_interface::Cache, + renderer: &mut P::Renderer, + size: Size, + debug: &mut Debug, +) -> UserInterface<'a, P::Message, P::Renderer> { + debug.view_started(); + let view = program.view(); + debug.view_finished(); + + debug.layout_started(); + let user_interface = UserInterface::build(view, size, cache, renderer); + debug.layout_finished(); + + user_interface +} diff --git a/runtime/src/window.rs b/runtime/src/window.rs index 5219fbfd..4737dcdd 100644 --- a/runtime/src/window.rs +++ b/runtime/src/window.rs @@ -3,101 +3,117 @@ mod action; pub mod screenshot; +pub use crate::core::window::Id; pub use action::Action; pub use screenshot::Screenshot; use crate::command::{self, Command}; use crate::core::time::Instant; -use crate::core::window::{Event, Icon, Level, Mode, UserAttention}; +use crate::core::window::{self, Event, Icon, Level, Mode, UserAttention}; use crate::core::Size; use crate::futures::subscription::{self, Subscription}; /// Subscribes to the frames of the window of the running application. /// /// The resulting [`Subscription`] will produce items at a rate equal to the -/// refresh rate of the window. Note that this rate may be variable, as it is +/// refresh rate of the first application window. Note that this rate may be variable, as it is /// normally managed by the graphics driver and/or the OS. /// /// In any case, this [`Subscription`] is useful to smoothly draw application-driven /// animations without missing any frames. pub fn frames() -> Subscription { subscription::raw_events(|event, _status| match event { - iced_core::Event::Window(Event::RedrawRequested(at)) => Some(at), + iced_core::Event::Window(_, Event::RedrawRequested(at)) => Some(at), _ => None, }) } -/// Closes the current window and exits the application. -pub fn close() -> Command { - Command::single(command::Action::Window(Action::Close)) +/// Spawns a new window with the given `id` and `settings`. +pub fn spawn( + id: window::Id, + settings: window::Settings, +) -> Command { + Command::single(command::Action::Window(id, Action::Spawn { settings })) +} + +/// Closes the window with `id`. +pub fn close(id: window::Id) -> Command { + Command::single(command::Action::Window(id, Action::Close)) } /// Begins dragging the window while the left mouse button is held. -pub fn drag() -> Command { - Command::single(command::Action::Window(Action::Drag)) +pub fn drag(id: window::Id) -> Command { + Command::single(command::Action::Window(id, Action::Drag)) } /// Resizes the window to the given logical dimensions. -pub fn resize(new_size: Size) -> Command { - Command::single(command::Action::Window(Action::Resize(new_size))) +pub fn resize( + id: window::Id, + new_size: Size, +) -> Command { + Command::single(command::Action::Window(id, Action::Resize(new_size))) } -/// Fetches the current window size in logical dimensions. +/// Fetches the window's size in logical dimensions. pub fn fetch_size( + id: window::Id, f: impl FnOnce(Size) -> Message + 'static, ) -> Command { - Command::single(command::Action::Window(Action::FetchSize(Box::new(f)))) + Command::single(command::Action::Window(id, Action::FetchSize(Box::new(f)))) } /// Maximizes the window. -pub fn maximize(maximized: bool) -> Command { - Command::single(command::Action::Window(Action::Maximize(maximized))) +pub fn maximize(id: window::Id, maximized: bool) -> Command { + Command::single(command::Action::Window(id, Action::Maximize(maximized))) } -/// Minimes the window. -pub fn minimize(minimized: bool) -> Command { - Command::single(command::Action::Window(Action::Minimize(minimized))) +/// Minimizes the window. +pub fn minimize(id: window::Id, minimized: bool) -> Command { + Command::single(command::Action::Window(id, Action::Minimize(minimized))) } -/// Moves a window to the given logical coordinates. -pub fn move_to(x: i32, y: i32) -> Command { - Command::single(command::Action::Window(Action::Move { x, y })) +/// Moves the window to the given logical coordinates. +pub fn move_to(id: window::Id, x: i32, y: i32) -> Command { + Command::single(command::Action::Window(id, Action::Move { x, y })) } /// Changes the [`Mode`] of the window. -pub fn change_mode(mode: Mode) -> Command { - Command::single(command::Action::Window(Action::ChangeMode(mode))) +pub fn change_mode(id: window::Id, mode: Mode) -> Command { + Command::single(command::Action::Window(id, Action::ChangeMode(mode))) } /// Fetches the current [`Mode`] of the window. pub fn fetch_mode( + id: window::Id, f: impl FnOnce(Mode) -> Message + 'static, ) -> Command { - Command::single(command::Action::Window(Action::FetchMode(Box::new(f)))) + Command::single(command::Action::Window(id, Action::FetchMode(Box::new(f)))) } /// Toggles the window to maximized or back. -pub fn toggle_maximize() -> Command { - Command::single(command::Action::Window(Action::ToggleMaximize)) +pub fn toggle_maximize(id: window::Id) -> Command { + Command::single(command::Action::Window(id, Action::ToggleMaximize)) } /// Toggles the window decorations. -pub fn toggle_decorations() -> Command { - Command::single(command::Action::Window(Action::ToggleDecorations)) +pub fn toggle_decorations(id: window::Id) -> Command { + Command::single(command::Action::Window(id, Action::ToggleDecorations)) } -/// Request user attention to the window, this has no effect if the application +/// Request user attention to the window. This has no effect if the application /// is already focused. How requesting for user attention manifests is platform dependent, /// see [`UserAttention`] for details. /// /// Providing `None` will unset the request for user attention. Unsetting the request for /// user attention might not be done automatically by the WM when the window receives input. pub fn request_user_attention( + id: window::Id, user_attention: Option, ) -> Command { - Command::single(command::Action::Window(Action::RequestUserAttention( - user_attention, - ))) + Command::single(command::Action::Window( + id, + Action::RequestUserAttention(user_attention), + )) } /// Brings the window to the front and sets input focus. Has no effect if the window is @@ -106,30 +122,36 @@ pub fn request_user_attention( /// This [`Command`] steals input focus from other applications. Do not use this method unless /// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive /// user experience. -pub fn gain_focus() -> Command { - Command::single(command::Action::Window(Action::GainFocus)) +pub fn gain_focus(id: window::Id) -> Command { + Command::single(command::Action::Window(id, Action::GainFocus)) } /// Changes the window [`Level`]. -pub fn change_level(level: Level) -> Command { - Command::single(command::Action::Window(Action::ChangeLevel(level))) +pub fn change_level(id: window::Id, level: Level) -> Command { + Command::single(command::Action::Window(id, Action::ChangeLevel(level))) } -/// Fetches an identifier unique to the window. +/// Fetches an identifier unique to the window, provided by the underlying windowing system. This is +/// not to be confused with [`window::Id`]. pub fn fetch_id( + id: window::Id, f: impl FnOnce(u64) -> Message + 'static, ) -> Command { - Command::single(command::Action::Window(Action::FetchId(Box::new(f)))) + Command::single(command::Action::Window(id, Action::FetchId(Box::new(f)))) } /// Changes the [`Icon`] of the window. -pub fn change_icon(icon: Icon) -> Command { - Command::single(command::Action::Window(Action::ChangeIcon(icon))) +pub fn change_icon(id: window::Id, icon: Icon) -> Command { + Command::single(command::Action::Window(id, Action::ChangeIcon(icon))) } /// Captures a [`Screenshot`] from the window. pub fn screenshot( + id: window::Id, f: impl FnOnce(Screenshot) -> Message + Send + 'static, ) -> Command { - Command::single(command::Action::Window(Action::Screenshot(Box::new(f)))) + Command::single(command::Action::Window( + id, + Action::Screenshot(Box::new(f)), + )) } diff --git a/runtime/src/window/action.rs b/runtime/src/window/action.rs index cebec4ae..d631cee1 100644 --- a/runtime/src/window/action.rs +++ b/runtime/src/window/action.rs @@ -1,4 +1,4 @@ -use crate::core::window::{Icon, Level, Mode, UserAttention, Settings}; +use crate::core::window::{Icon, Level, Mode, Settings, UserAttention}; use crate::core::Size; use crate::futures::MaybeSend; use crate::window::Screenshot; @@ -15,7 +15,7 @@ pub enum Action { /// There’s no guarantee that this will work unless the left mouse /// button was pressed immediately before this function is called. Drag, - /// Spawns a new window with the provided [`window::Settings`]. + /// Spawns a new window. Spawn { /// The settings of the [`Window`]. settings: Settings, -- cgit