me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Use AtomicU64 for window::Id

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2023-12-02 20:41:58 +01:00
parent 67408311f4
commit ea42af766f
No known key found for this signature in database
GPG key ID: 7CC46565708259A7
9 changed files with 228 additions and 212 deletions
Download patch file Download diff file Expand all files Collapse all files

8
runtime/src/command/action.rs
View file

@ -27,7 +27,7 @@ pub enum Action<T> {
Clipboard(clipboard::Action<T>),
/// Run a window action.
Window(window::Id, window::Action<T>),
Window(window::Action<T>),
/// Run a system action.
System(system::Action<T>),
@ -63,7 +63,7 @@ impl<T> Action<T> {
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<T> fmt::Debug for Action<T> {
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"),

4
runtime/src/multi_window/program.rs
View file

@ -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 {

99
runtime/src/window.rs
View file

@ -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<Instant> {
})
}
/// Spawns a new window with the given `id` and `settings`.
pub fn spawn<Message>(
id: window::Id,
settings: window::Settings,
) -> Command<Message> {
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<Message>(settings: Settings) -> (Id, Command<Message>) {
let id = Id::unique();
(
id,
Command::single(command::Action::Window(Action::Spawn(id, settings))),
)
}
/// Closes the window with `id`.
pub fn close<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Close))
pub fn close<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::Close(id)))
}
/// Begins dragging the window while the left mouse button is held.
pub fn drag<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Drag))
pub fn drag<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::Drag(id)))
}
/// Resizes the window to the given logical dimensions.
pub fn resize<Message>(id: window::Id, new_size: Size) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Resize(new_size)))
pub fn resize<Message>(id: Id, new_size: Size) -> Command<Message> {
Command::single(command::Action::Window(Action::Resize(id, new_size)))
}
/// Fetches the window's size in logical dimensions.
pub fn fetch_size<Message>(
id: window::Id,
id: Id,
f: impl FnOnce(Size) -> Message + 'static,
) -> Command<Message> {
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<Message>(id: window::Id, maximized: bool) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Maximize(maximized)))
pub fn maximize<Message>(id: Id, maximized: bool) -> Command<Message> {
Command::single(command::Action::Window(Action::Maximize(id, maximized)))
}
/// Minimizes the window.
pub fn minimize<Message>(id: window::Id, minimized: bool) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Minimize(minimized)))
pub fn minimize<Message>(id: Id, minimized: bool) -> Command<Message> {
Command::single(command::Action::Window(Action::Minimize(id, minimized)))
}
/// Moves the window to the given logical coordinates.
pub fn move_to<Message>(id: window::Id, position: Point) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Move(position)))
pub fn move_to<Message>(id: Id, position: Point) -> Command<Message> {
Command::single(command::Action::Window(Action::Move(id, position)))
}
/// Changes the [`Mode`] of the window.
pub fn change_mode<Message>(id: window::Id, mode: Mode) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeMode(mode)))
pub fn change_mode<Message>(id: Id, mode: Mode) -> Command<Message> {
Command::single(command::Action::Window(Action::ChangeMode(id, mode)))
}
/// Fetches the current [`Mode`] of the window.
pub fn fetch_mode<Message>(
id: window::Id,
id: Id,
f: impl FnOnce(Mode) -> Message + 'static,
) -> Command<Message> {
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<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ToggleMaximize))
pub fn toggle_maximize<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::ToggleMaximize(id)))
}
/// Toggles the window decorations.
pub fn toggle_decorations<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ToggleDecorations))
pub fn toggle_decorations<Message>(id: Id) -> Command<Message> {
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<Message>(id: window::Id) -> Command<Message> {
/// 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<Message>(
id: window::Id,
id: Id,
user_attention: Option<UserAttention>,
) -> Command<Message> {
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<Message>(
/// 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<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::GainFocus))
pub fn gain_focus<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::GainFocus(id)))
}
/// Changes the window [`Level`].
pub fn change_level<Message>(id: window::Id, level: Level) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeLevel(level)))
pub fn change_level<Message>(id: Id, level: Level) -> Command<Message> {
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<Message>(
id: window::Id,
id: Id,
f: impl FnOnce(u64) -> Message + 'static,
) -> Command<Message> {
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<Message>(id: window::Id, icon: Icon) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeIcon(icon)))
pub fn change_icon<Message>(id: Id, icon: Icon) -> Command<Message> {
Command::single(command::Action::Window(Action::ChangeIcon(id, icon)))
}
/// Captures a [`Screenshot`] from the window.
pub fn screenshot<Message>(
id: window::Id,
id: Id,
f: impl FnOnce(Screenshot) -> Message + Send + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(
Command::single(command::Action::Window(Action::Screenshot(
id,
Action::Screenshot(Box::new(f)),
))
Box::new(f),
)))
}

154
runtime/src/window/action.rs
View file

@ -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<T> {
/// 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<dyn FnOnce(Size) -> T + 'static>),
FetchSize(Id, Box<dyn FnOnce(Size) -> 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<dyn FnOnce(Mode) -> T + 'static>),
FetchMode(Id, Box<dyn FnOnce(Mode) -> 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<T> {
/// - **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<UserAttention>),
RequestUserAttention(Id, Option<UserAttention>),
/// 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<T> {
/// ## Platform-specific
///
/// - **Web / Wayland:** Unsupported.
GainFocus,
GainFocus(Id),
/// Change the window [`Level`].
ChangeLevel(Level),
/// Fetch an identifier unique to the window.
FetchId(Box<dyn FnOnce(u64) -> T + 'static>),
ChangeLevel(Id, Level),
/// Fetch the raw identifier unique to the window.
FetchId(Id, Box<dyn FnOnce(u64) -> 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<T> {
///
/// - **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<dyn FnOnce(Screenshot) -> T + 'static>),
Screenshot(Id, Box<dyn FnOnce(Screenshot) -> T + 'static>),
}
impl<T> Action<T> {
@ -102,30 +99,35 @@ impl<T> Action<T> {
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<T> Action<T> {
impl<T> fmt::Debug for Action<T> {
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::Resize(size) => write!(f, "Action::Resize({size:?})"),
Self::FetchSize(_) => write!(f, "Action::FetchSize"),
Self::Maximize(maximized) => {
write!(f, "Action::Maximize({maximized})")
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::Minimize(minimized) => {
write!(f, "Action::Minimize({minimized}")
Self::FetchSize(id, _) => write!(f, "Action::FetchSize({id:?})"),
Self::Maximize(id, maximized) => {
write!(f, "Action::Maximize({id:?}, {maximized})")
}
Self::Move(position) => {
write!(f, "Action::Move({position})")
Self::Minimize(id, minimized) => {
write!(f, "Action::Minimize({id:?}, {minimized}")
}
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::Move(id, position) => {
write!(f, "Action::Move({id:?}, {position})")
}
Self::GainFocus => write!(f, "Action::GainFocus"),
Self::ChangeLevel(level) => {
write!(f, "Action::ChangeLevel({level:?})")
Self::ChangeMode(id, mode) => {
write!(f, "Action::SetMode({id:?}, {mode:?})")
}
Self::FetchId(_) => write!(f, "Action::FetchId"),
Self::ChangeIcon(_icon) => {
write!(f, "Action::ChangeIcon(icon)")
Self::FetchMode(id, _) => write!(f, "Action::FetchMode({id:?})"),
Self::ToggleMaximize(id) => {
write!(f, "Action::ToggleMaximize({id:?})")
}
Self::Screenshot(_) => write!(f, "Action::Screenshot"),
Self::ToggleDecorations(id) => {
write!(f, "Action::ToggleDecorations({id:?})")
}
Self::RequestUserAttention(id, _) => {
write!(f, "Action::RequestUserAttention({id:?})")
}
Self::GainFocus(id) => write!(f, "Action::GainFocus({id:?})"),
Self::ChangeLevel(id, level) => {
write!(f, "Action::ChangeLevel({id:?}, {level:?})")
}
Self::FetchId(id, _) => write!(f, "Action::FetchId({id:?})"),
Self::ChangeIcon(id, _icon) => {
write!(f, "Action::ChangeIcon({id:?})")
}
Self::Screenshot(id, _) => write!(f, "Action::Screenshot({id:?})"),
}
}
}