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/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 +- 6 files changed, 385 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/src') 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 From 7def3ee38a3f0f24a331d722b09f325fc9584625 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 29 Nov 2023 22:37:54 +0100 Subject: Fix `clippy` lints --- runtime/src/multi_window/state.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'runtime/src') diff --git a/runtime/src/multi_window/state.rs b/runtime/src/multi_window/state.rs index 78c35e6c..05036a07 100644 --- a/runtime/src/multi_window/state.rs +++ b/runtime/src/multi_window/state.rs @@ -228,7 +228,7 @@ where match operation.finish() { operation::Outcome::None => {} operation::Outcome::Some(message) => { - self.queued_messages.push(message) + self.queued_messages.push(message); } operation::Outcome::Chain(next) => { current_operation = Some(next); -- cgit From 6740c2c5d6b24399dab1343abdfec5daf4b03c98 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 29 Nov 2023 22:46:47 +0100 Subject: Fix broken intra-doc links --- runtime/src/multi_window/state.rs | 2 +- runtime/src/window/action.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'runtime/src') diff --git a/runtime/src/multi_window/state.rs b/runtime/src/multi_window/state.rs index 05036a07..49f72c39 100644 --- a/runtime/src/multi_window/state.rs +++ b/runtime/src/multi_window/state.rs @@ -201,7 +201,7 @@ where (uncaptured_events, commands) } - /// Applies [`widget::Operation`]s to the [`State`] + /// Applies widget [`Operation`]s to the [`State`]. pub fn operate( &mut self, renderer: &mut P::Renderer, diff --git a/runtime/src/window/action.rs b/runtime/src/window/action.rs index d631cee1..2a31bbd6 100644 --- a/runtime/src/window/action.rs +++ b/runtime/src/window/action.rs @@ -17,7 +17,7 @@ pub enum Action { Drag, /// Spawns a new window. Spawn { - /// The settings of the [`Window`]. + /// The settings of the window. settings: Settings, }, /// Resize the window. -- cgit From 67408311f45d341509538f8cc185978da66b6ace Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Thu, 30 Nov 2023 23:40:33 +0100 Subject: Use actual floats for logical coordinates --- runtime/src/window.rs | 13 +++++-------- runtime/src/window/action.rs | 25 ++++++++++--------------- 2 files changed, 15 insertions(+), 23 deletions(-) (limited to 'runtime/src') diff --git a/runtime/src/window.rs b/runtime/src/window.rs index 375ce889..f46ac1b8 100644 --- a/runtime/src/window.rs +++ b/runtime/src/window.rs @@ -10,7 +10,7 @@ pub use screenshot::Screenshot; use crate::command::{self, Command}; use crate::core::time::Instant; use crate::core::window::{self, Event, Icon, Level, Mode, UserAttention}; -use crate::core::Size; +use crate::core::{Point, Size}; use crate::futures::event; use crate::futures::Subscription; @@ -48,17 +48,14 @@ pub fn drag(id: window::Id) -> Command { } /// Resizes the window to the given logical dimensions. -pub fn resize( - id: window::Id, - new_size: Size, -) -> Command { +pub fn resize(id: window::Id, new_size: Size) -> Command { Command::single(command::Action::Window(id, Action::Resize(new_size))) } /// Fetches the window's size in logical dimensions. pub fn fetch_size( id: window::Id, - f: impl FnOnce(Size) -> Message + 'static, + f: impl FnOnce(Size) -> Message + 'static, ) -> Command { Command::single(command::Action::Window(id, Action::FetchSize(Box::new(f)))) } @@ -74,8 +71,8 @@ pub fn minimize(id: window::Id, minimized: bool) -> Command { } /// 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 })) +pub fn move_to(id: window::Id, position: Point) -> Command { + Command::single(command::Action::Window(id, Action::Move(position))) } /// Changes the [`Mode`] of the window. diff --git a/runtime/src/window/action.rs b/runtime/src/window/action.rs index 2a31bbd6..5afe0389 100644 --- a/runtime/src/window/action.rs +++ b/runtime/src/window/action.rs @@ -1,5 +1,5 @@ use crate::core::window::{Icon, Level, Mode, Settings, UserAttention}; -use crate::core::Size; +use crate::core::{Point, Size}; use crate::futures::MaybeSend; use crate::window::Screenshot; @@ -20,23 +20,18 @@ pub enum Action { /// The settings of the window. settings: Settings, }, - /// Resize the window. - Resize(Size), - /// Fetch the current size of the window. - FetchSize(Box) -> T + 'static>), + /// Resize the window to the given logical dimensions. + Resize(Size), + /// Fetch the current logical dimensions of the window. + FetchSize(Box T + 'static>), /// Set the window to maximized or back Maximize(bool), /// Set the window to minimized or back Minimize(bool), - /// Move the window. + /// Move the window to the given logical coordinates. /// /// Unsupported on Wayland. - Move { - /// The new logical x location of the window - x: i32, - /// The new logical y location of the window - y: i32, - }, + Move(Point), /// Change the [`Mode`] of the window. ChangeMode(Mode), /// Fetch the current [`Mode`] of the window. @@ -114,7 +109,7 @@ impl Action { Self::FetchSize(o) => Action::FetchSize(Box::new(move |s| f(o(s)))), Self::Maximize(maximized) => Action::Maximize(maximized), Self::Minimize(minimized) => Action::Minimize(minimized), - Self::Move { x, y } => Action::Move { x, y }, + Self::Move(position) => Action::Move(position), Self::ChangeMode(mode) => Action::ChangeMode(mode), Self::FetchMode(o) => Action::FetchMode(Box::new(move |s| f(o(s)))), Self::ToggleMaximize => Action::ToggleMaximize, @@ -151,8 +146,8 @@ impl fmt::Debug for Action { Self::Minimize(minimized) => { write!(f, "Action::Minimize({minimized}") } - Self::Move { x, y } => { - write!(f, "Action::Move {{ x: {x}, y: {y} }}") + Self::Move(position) => { + write!(f, "Action::Move({position})") } Self::ChangeMode(mode) => write!(f, "Action::SetMode({mode:?})"), Self::FetchMode(_) => write!(f, "Action::FetchMode"), -- cgit From ea42af766f345715ff7a7168182d3896ee79cfbc Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sat, 2 Dec 2023 20:41:58 +0100 Subject: Use `AtomicU64` for `window::Id` --- runtime/src/command/action.rs | 8 +- runtime/src/multi_window/program.rs | 4 +- runtime/src/window.rs | 99 ++++++++++++----------- runtime/src/window/action.rs | 154 +++++++++++++++++++----------------- 4 files changed, 140 insertions(+), 125 deletions(-) (limited to 'runtime/src') diff --git a/runtime/src/command/action.rs b/runtime/src/command/action.rs index 7a70920e..cb0936df 100644 --- a/runtime/src/command/action.rs +++ b/runtime/src/command/action.rs @@ -27,7 +27,7 @@ pub enum Action { Clipboard(clipboard::Action), /// Run a window action. - Window(window::Id, window::Action), + Window(window::Action), /// Run a system action. System(system::Action), @@ -63,7 +63,7 @@ impl Action { Self::Future(future) => Action::Future(Box::pin(future.map(f))), Self::Stream(stream) => Action::Stream(Box::pin(stream.map(f))), Self::Clipboard(action) => Action::Clipboard(action.map(f)), - Self::Window(id, window) => Action::Window(id, window.map(f)), + Self::Window(window) => Action::Window(window.map(f)), Self::System(system) => Action::System(system.map(f)), Self::Widget(operation) => { Action::Widget(Box::new(widget::operation::map(operation, f))) @@ -84,8 +84,8 @@ impl fmt::Debug for Action { Self::Clipboard(action) => { write!(f, "Action::Clipboard({action:?})") } - Self::Window(id, action) => { - write!(f, "Action::Window({id:?}, {action:?})") + Self::Window(action) => { + write!(f, "Action::Window({action:?})") } Self::System(action) => write!(f, "Action::System({action:?})"), Self::Widget(_action) => write!(f, "Action::Widget"), diff --git a/runtime/src/multi_window/program.rs b/runtime/src/multi_window/program.rs index c3989d0d..591b3e9a 100644 --- a/runtime/src/multi_window/program.rs +++ b/runtime/src/multi_window/program.rs @@ -1,8 +1,8 @@ //! Build interactive programs using The Elm Architecture. -use crate::{window, Command}; - use crate::core::text; +use crate::core::window; use crate::core::{Element, Renderer}; +use crate::Command; /// The core of a user interface for a multi-window application following The Elm Architecture. pub trait Program: Sized { diff --git a/runtime/src/window.rs b/runtime/src/window.rs index f46ac1b8..f9d943f6 100644 --- a/runtime/src/window.rs +++ b/runtime/src/window.rs @@ -3,13 +3,14 @@ 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::{self, Event, Icon, Level, Mode, UserAttention}; +use crate::core::window::{ + Event, Icon, Id, Level, Mode, Settings, UserAttention, +}; use crate::core::{Point, Size}; use crate::futures::event; use crate::futures::Subscription; @@ -29,73 +30,77 @@ pub fn frames() -> Subscription { }) } -/// 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 })) +/// Spawns a new window with the given `settings`. +/// +/// Returns the new window [`Id`] alongside the [`Command`]. +pub fn spawn(settings: Settings) -> (Id, Command) { + let id = Id::unique(); + + ( + id, + Command::single(command::Action::Window(Action::Spawn(id, settings))), + ) } /// Closes the window with `id`. -pub fn close(id: window::Id) -> Command { - Command::single(command::Action::Window(id, Action::Close)) +pub fn close(id: Id) -> Command { + Command::single(command::Action::Window(Action::Close(id))) } /// Begins dragging the window while the left mouse button is held. -pub fn drag(id: window::Id) -> Command { - Command::single(command::Action::Window(id, Action::Drag)) +pub fn drag(id: Id) -> Command { + Command::single(command::Action::Window(Action::Drag(id))) } /// Resizes the window to the given logical dimensions. -pub fn resize(id: window::Id, new_size: Size) -> Command { - Command::single(command::Action::Window(id, Action::Resize(new_size))) +pub fn resize(id: Id, new_size: Size) -> Command { + Command::single(command::Action::Window(Action::Resize(id, new_size))) } /// Fetches the window's size in logical dimensions. pub fn fetch_size( - id: window::Id, + id: Id, f: impl FnOnce(Size) -> Message + 'static, ) -> Command { - Command::single(command::Action::Window(id, Action::FetchSize(Box::new(f)))) + Command::single(command::Action::Window(Action::FetchSize(id, Box::new(f)))) } /// Maximizes the window. -pub fn maximize(id: window::Id, maximized: bool) -> Command { - Command::single(command::Action::Window(id, Action::Maximize(maximized))) +pub fn maximize(id: Id, maximized: bool) -> Command { + Command::single(command::Action::Window(Action::Maximize(id, maximized))) } /// Minimizes the window. -pub fn minimize(id: window::Id, minimized: bool) -> Command { - Command::single(command::Action::Window(id, Action::Minimize(minimized))) +pub fn minimize(id: Id, minimized: bool) -> Command { + Command::single(command::Action::Window(Action::Minimize(id, minimized))) } /// Moves the window to the given logical coordinates. -pub fn move_to(id: window::Id, position: Point) -> Command { - Command::single(command::Action::Window(id, Action::Move(position))) +pub fn move_to(id: Id, position: Point) -> Command { + Command::single(command::Action::Window(Action::Move(id, position))) } /// Changes the [`Mode`] of the window. -pub fn change_mode(id: window::Id, mode: Mode) -> Command { - Command::single(command::Action::Window(id, Action::ChangeMode(mode))) +pub fn change_mode(id: Id, mode: Mode) -> Command { + Command::single(command::Action::Window(Action::ChangeMode(id, mode))) } /// Fetches the current [`Mode`] of the window. pub fn fetch_mode( - id: window::Id, + id: Id, f: impl FnOnce(Mode) -> Message + 'static, ) -> Command { - Command::single(command::Action::Window(id, Action::FetchMode(Box::new(f)))) + Command::single(command::Action::Window(Action::FetchMode(id, Box::new(f)))) } /// Toggles the window to maximized or back. -pub fn toggle_maximize(id: window::Id) -> Command { - Command::single(command::Action::Window(id, Action::ToggleMaximize)) +pub fn toggle_maximize(id: Id) -> Command { + Command::single(command::Action::Window(Action::ToggleMaximize(id))) } /// Toggles the window decorations. -pub fn toggle_decorations(id: window::Id) -> Command { - Command::single(command::Action::Window(id, Action::ToggleDecorations)) +pub fn toggle_decorations(id: Id) -> Command { + Command::single(command::Action::Window(Action::ToggleDecorations(id))) } /// Request user attention to the window. This has no effect if the application @@ -105,13 +110,13 @@ pub fn toggle_decorations(id: window::Id) -> Command { /// 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, + id: Id, user_attention: Option, ) -> Command { - Command::single(command::Action::Window( + Command::single(command::Action::Window(Action::RequestUserAttention( id, - Action::RequestUserAttention(user_attention), - )) + user_attention, + ))) } /// Brings the window to the front and sets input focus. Has no effect if the window is @@ -120,36 +125,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(id: window::Id) -> Command { - Command::single(command::Action::Window(id, Action::GainFocus)) +pub fn gain_focus(id: Id) -> Command { + Command::single(command::Action::Window(Action::GainFocus(id))) } /// Changes the window [`Level`]. -pub fn change_level(id: window::Id, level: Level) -> Command { - Command::single(command::Action::Window(id, Action::ChangeLevel(level))) +pub fn change_level(id: Id, level: Level) -> Command { + Command::single(command::Action::Window(Action::ChangeLevel(id, level))) } /// Fetches an identifier unique to the window, provided by the underlying windowing system. This is -/// not to be confused with [`window::Id`]. +/// not to be confused with [`Id`]. pub fn fetch_id( - id: window::Id, + id: Id, f: impl FnOnce(u64) -> Message + 'static, ) -> Command { - Command::single(command::Action::Window(id, Action::FetchId(Box::new(f)))) + Command::single(command::Action::Window(Action::FetchId(id, Box::new(f)))) } /// Changes the [`Icon`] of the window. -pub fn change_icon(id: window::Id, icon: Icon) -> Command { - Command::single(command::Action::Window(id, Action::ChangeIcon(icon))) +pub fn change_icon(id: Id, icon: Icon) -> Command { + Command::single(command::Action::Window(Action::ChangeIcon(id, icon))) } /// Captures a [`Screenshot`] from the window. pub fn screenshot( - id: window::Id, + id: Id, f: impl FnOnce(Screenshot) -> Message + Send + 'static, ) -> Command { - Command::single(command::Action::Window( + Command::single(command::Action::Window(Action::Screenshot( id, - Action::Screenshot(Box::new(f)), - )) + Box::new(f), + ))) } diff --git a/runtime/src/window/action.rs b/runtime/src/window/action.rs index 5afe0389..2d98b607 100644 --- a/runtime/src/window/action.rs +++ b/runtime/src/window/action.rs @@ -1,4 +1,4 @@ -use crate::core::window::{Icon, Level, Mode, Settings, UserAttention}; +use crate::core::window::{Icon, Id, Level, Mode, Settings, UserAttention}; use crate::core::{Point, Size}; use crate::futures::MaybeSend; use crate::window::Screenshot; @@ -7,43 +7,40 @@ use std::fmt; /// An operation to be performed on some window. pub enum Action { - /// Close the current window and exits the application. - Close, + /// Spawns a new window with some [`Settings`]. + Spawn(Id, Settings), + /// Close the window and exits the application. + Close(Id), /// Move the window with the left mouse button until the button is /// released. /// /// 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. - Spawn { - /// The settings of the window. - settings: Settings, - }, + Drag(Id), /// Resize the window to the given logical dimensions. - Resize(Size), + Resize(Id, Size), /// Fetch the current logical dimensions of the window. - FetchSize(Box T + 'static>), + FetchSize(Id, Box T + 'static>), /// Set the window to maximized or back - Maximize(bool), + Maximize(Id, bool), /// Set the window to minimized or back - Minimize(bool), + Minimize(Id, bool), /// Move the window to the given logical coordinates. /// /// Unsupported on Wayland. - Move(Point), + Move(Id, Point), /// Change the [`Mode`] of the window. - ChangeMode(Mode), + ChangeMode(Id, Mode), /// Fetch the current [`Mode`] of the window. - FetchMode(Box T + 'static>), + FetchMode(Id, Box T + 'static>), /// Toggle the window to maximized or back - ToggleMaximize, + ToggleMaximize(Id), /// Toggle whether window has decorations. /// /// ## Platform-specific /// - **X11:** Not implemented. /// - **Web:** Unsupported. - ToggleDecorations, + ToggleDecorations(Id), /// 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. @@ -57,7 +54,7 @@ pub enum Action { /// - **macOS:** `None` has no effect. /// - **X11:** Requests for user attention must be manually cleared. /// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect. - RequestUserAttention(Option), + RequestUserAttention(Id, Option), /// Bring the window to the front and sets input focus. Has no effect if the window is /// already in focus, minimized, or not visible. /// @@ -68,11 +65,11 @@ pub enum Action { /// ## Platform-specific /// /// - **Web / Wayland:** Unsupported. - GainFocus, + GainFocus(Id), /// Change the window [`Level`]. - ChangeLevel(Level), - /// Fetch an identifier unique to the window. - FetchId(Box T + 'static>), + ChangeLevel(Id, Level), + /// Fetch the raw identifier unique to the window. + FetchId(Id, Box T + 'static>), /// Change the window [`Icon`]. /// /// On Windows and X11, this is typically the small icon in the top-left @@ -87,9 +84,9 @@ pub enum Action { /// /// - **X11:** Has no universal guidelines for icon sizes, so you're at the whims of the WM. That /// said, it's usually in the same ballpark as on Windows. - ChangeIcon(Icon), + ChangeIcon(Id, Icon), /// Screenshot the viewport of the window. - Screenshot(Box T + 'static>), + Screenshot(Id, Box T + 'static>), } impl Action { @@ -102,30 +99,35 @@ impl Action { T: 'static, { match self { - Self::Close => Action::Close, - Self::Drag => Action::Drag, - Self::Spawn { settings } => Action::Spawn { settings }, - Self::Resize(size) => Action::Resize(size), - Self::FetchSize(o) => Action::FetchSize(Box::new(move |s| f(o(s)))), - Self::Maximize(maximized) => Action::Maximize(maximized), - Self::Minimize(minimized) => Action::Minimize(minimized), - Self::Move(position) => Action::Move(position), - Self::ChangeMode(mode) => Action::ChangeMode(mode), - Self::FetchMode(o) => Action::FetchMode(Box::new(move |s| f(o(s)))), - Self::ToggleMaximize => Action::ToggleMaximize, - Self::ToggleDecorations => Action::ToggleDecorations, - Self::RequestUserAttention(attention_type) => { - Action::RequestUserAttention(attention_type) + Self::Spawn(id, settings) => Action::Spawn(id, settings), + Self::Close(id) => Action::Close(id), + Self::Drag(id) => Action::Drag(id), + Self::Resize(id, size) => Action::Resize(id, size), + Self::FetchSize(id, o) => { + Action::FetchSize(id, Box::new(move |s| f(o(s)))) } - Self::GainFocus => Action::GainFocus, - Self::ChangeLevel(level) => Action::ChangeLevel(level), - Self::FetchId(o) => Action::FetchId(Box::new(move |s| f(o(s)))), - Self::ChangeIcon(icon) => Action::ChangeIcon(icon), - Self::Screenshot(tag) => { - Action::Screenshot(Box::new(move |screenshot| { - f(tag(screenshot)) - })) + Self::Maximize(id, maximized) => Action::Maximize(id, maximized), + Self::Minimize(id, minimized) => Action::Minimize(id, minimized), + Self::Move(id, position) => Action::Move(id, position), + Self::ChangeMode(id, mode) => Action::ChangeMode(id, mode), + Self::FetchMode(id, o) => { + Action::FetchMode(id, Box::new(move |s| f(o(s)))) } + Self::ToggleMaximize(id) => Action::ToggleMaximize(id), + Self::ToggleDecorations(id) => Action::ToggleDecorations(id), + Self::RequestUserAttention(id, attention_type) => { + Action::RequestUserAttention(id, attention_type) + } + Self::GainFocus(id) => Action::GainFocus(id), + Self::ChangeLevel(id, level) => Action::ChangeLevel(id, level), + Self::FetchId(id, o) => { + Action::FetchId(id, Box::new(move |s| f(o(s)))) + } + Self::ChangeIcon(id, icon) => Action::ChangeIcon(id, icon), + Self::Screenshot(id, tag) => Action::Screenshot( + id, + Box::new(move |screenshot| f(tag(screenshot))), + ), } } } @@ -133,38 +135,46 @@ impl Action { impl fmt::Debug for Action { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - Self::Close => write!(f, "Action::Close"), - Self::Drag => write!(f, "Action::Drag"), - Self::Spawn { settings } => { - write!(f, "Action::Spawn {{ settings: {:?} }}", settings) + Self::Spawn(id, settings) => { + write!(f, "Action::Spawn({id:?}, {settings:?})") + } + Self::Close(id) => write!(f, "Action::Close({id:?})"), + Self::Drag(id) => write!(f, "Action::Drag({id:?})"), + Self::Resize(id, size) => { + write!(f, "Action::Resize({id:?}, {size:?})") + } + Self::FetchSize(id, _) => write!(f, "Action::FetchSize({id:?})"), + Self::Maximize(id, maximized) => { + write!(f, "Action::Maximize({id:?}, {maximized})") + } + Self::Minimize(id, minimized) => { + write!(f, "Action::Minimize({id:?}, {minimized}") + } + Self::Move(id, position) => { + write!(f, "Action::Move({id:?}, {position})") } - Self::Resize(size) => write!(f, "Action::Resize({size:?})"), - Self::FetchSize(_) => write!(f, "Action::FetchSize"), - Self::Maximize(maximized) => { - write!(f, "Action::Maximize({maximized})") + Self::ChangeMode(id, mode) => { + write!(f, "Action::SetMode({id:?}, {mode:?})") } - Self::Minimize(minimized) => { - write!(f, "Action::Minimize({minimized}") + Self::FetchMode(id, _) => write!(f, "Action::FetchMode({id:?})"), + Self::ToggleMaximize(id) => { + write!(f, "Action::ToggleMaximize({id:?})") } - Self::Move(position) => { - write!(f, "Action::Move({position})") + Self::ToggleDecorations(id) => { + write!(f, "Action::ToggleDecorations({id:?})") } - Self::ChangeMode(mode) => write!(f, "Action::SetMode({mode:?})"), - Self::FetchMode(_) => write!(f, "Action::FetchMode"), - Self::ToggleMaximize => write!(f, "Action::ToggleMaximize"), - Self::ToggleDecorations => write!(f, "Action::ToggleDecorations"), - Self::RequestUserAttention(_) => { - write!(f, "Action::RequestUserAttention") + Self::RequestUserAttention(id, _) => { + write!(f, "Action::RequestUserAttention({id:?})") } - Self::GainFocus => write!(f, "Action::GainFocus"), - Self::ChangeLevel(level) => { - write!(f, "Action::ChangeLevel({level:?})") + Self::GainFocus(id) => write!(f, "Action::GainFocus({id:?})"), + Self::ChangeLevel(id, level) => { + write!(f, "Action::ChangeLevel({id:?}, {level:?})") } - Self::FetchId(_) => write!(f, "Action::FetchId"), - Self::ChangeIcon(_icon) => { - write!(f, "Action::ChangeIcon(icon)") + Self::FetchId(id, _) => write!(f, "Action::FetchId({id:?})"), + Self::ChangeIcon(id, _icon) => { + write!(f, "Action::ChangeIcon({id:?})") } - Self::Screenshot(_) => write!(f, "Action::Screenshot"), + Self::Screenshot(id, _) => write!(f, "Action::Screenshot({id:?})"), } } } -- cgit