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

32
core/src/window/event.rs
View file

@ -6,6 +6,22 @@ use std::path::PathBuf;
/// A window-related event. /// A window-related event.
#[derive(PartialEq, Clone, Debug)] #[derive(PartialEq, Clone, Debug)]
pub enum Event { pub enum Event {
/// A window was opened.
Opened {
/// The position of the opened window. This is relative to the top-left corner of the desktop
/// the window is on, including virtual desktops. Refers to window's "inner" position,
/// or the client area, in logical pixels.
///
/// **Note**: Not available in Wayland.
position: Option<Point>,
/// The size of the created window. This is its "inner" size, or the size of the
/// client area, in logical pixels.
size: Size,
},
/// A window was closed.
Closed,
/// A window was moved. /// A window was moved.
Moved { Moved {
/// The new logical x location of the window /// The new logical x location of the window
@ -30,22 +46,6 @@ pub enum Event {
/// The user has requested for the window to close. /// The user has requested for the window to close.
CloseRequested, CloseRequested,
/// A window was created.
Created {
/// The position of the created window. This is relative to the top-left corner of the desktop
/// the window is on, including virtual desktops. Refers to window's "inner" position,
/// or the client area, in logical pixels.
///
/// **Note**: Not available in Wayland.
position: Option<Point>,
/// The size of the created window. This is its "inner" size, or the size of the
/// client area, in logical pixels.
size: Size,
},
/// A window was destroyed by the runtime.
Destroyed,
/// A window was focused. /// A window was focused.
Focused, Focused,

14
core/src/window/id.rs
View file

@ -1,5 +1,6 @@
use std::collections::hash_map::DefaultHasher; use std::hash::Hash;
use std::hash::{Hash, Hasher};
use std::sync::atomic::{self, AtomicU64};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
/// The id of the window. /// The id of the window.
@ -7,15 +8,14 @@ use std::hash::{Hash, Hasher};
/// Internally Iced reserves `window::Id::MAIN` for the first window spawned. /// Internally Iced reserves `window::Id::MAIN` for the first window spawned.
pub struct Id(u64); pub struct Id(u64);
static COUNT: AtomicU64 = AtomicU64::new(1);
impl Id { impl Id {
/// The reserved window [`Id`] for the first window in an Iced application. /// The reserved window [`Id`] for the first window in an Iced application.
pub const MAIN: Self = Id(0); pub const MAIN: Self = Id(0);
/// Creates a new unique window [`Id`]. /// Creates a new unique window [`Id`].
pub fn new(id: impl Hash) -> Id { pub fn unique() -> Id {
let mut hasher = DefaultHasher::new(); Id(COUNT.fetch_add(1, atomic::Ordering::Relaxed))
id.hash(&mut hasher);
Id(hasher.finish())
} }
} }

49
examples/multi_window/src/main.rs
View file

@ -35,8 +35,8 @@ enum Message {
ScaleChanged(window::Id, String), ScaleChanged(window::Id, String),
TitleChanged(window::Id, String), TitleChanged(window::Id, String),
CloseWindow(window::Id), CloseWindow(window::Id),
WindowCreated(window::Id, Option<Point>), WindowOpened(window::Id, Option<Point>),
WindowDestroyed(window::Id), WindowClosed(window::Id),
NewWindow, NewWindow,
} }
@ -69,6 +69,8 @@ impl multi_window::Application for Example {
let window = let window =
self.windows.get_mut(&id).expect("Window not found!"); self.windows.get_mut(&id).expect("Window not found!");
window.scale_input = scale; window.scale_input = scale;
Command::none()
} }
Message::ScaleChanged(id, scale) => { Message::ScaleChanged(id, scale) => {
let window = let window =
@ -78,20 +80,23 @@ impl multi_window::Application for Example {
.parse::<f64>() .parse::<f64>()
.unwrap_or(window.current_scale) .unwrap_or(window.current_scale)
.clamp(0.5, 5.0); .clamp(0.5, 5.0);
Command::none()
} }
Message::TitleChanged(id, title) => { Message::TitleChanged(id, title) => {
let window = let window =
self.windows.get_mut(&id).expect("Window not found."); self.windows.get_mut(&id).expect("Window not found.");
window.title = title; window.title = title;
Command::none()
} }
Message::CloseWindow(id) => { Message::CloseWindow(id) => window::close(id),
return window::close(id); Message::WindowClosed(id) => {
}
Message::WindowDestroyed(id) => {
self.windows.remove(&id); self.windows.remove(&id);
Command::none()
} }
Message::WindowCreated(id, position) => { Message::WindowOpened(id, position) => {
if let Some(position) = position { if let Some(position) = position {
self.next_window_pos = window::Position::Specific( self.next_window_pos = window::Position::Specific(
position + Vector::new(20.0, 20.0), position + Vector::new(20.0, 20.0),
@ -99,27 +104,25 @@ impl multi_window::Application for Example {
} }
if let Some(window) = self.windows.get(&id) { if let Some(window) = self.windows.get(&id) {
return text_input::focus(window.input_id.clone()); text_input::focus(window.input_id.clone())
} else {
Command::none()
} }
} }
Message::NewWindow => { Message::NewWindow => {
let count = self.windows.len() + 1; let count = self.windows.len() + 1;
let id = window::Id::new(count);
let (id, spawn_window) = window::spawn(window::Settings {
position: self.next_window_pos,
exit_on_close_request: count % 2 == 0,
..Default::default()
});
self.windows.insert(id, Window::new(count)); self.windows.insert(id, Window::new(count));
return window::spawn( spawn_window
id,
window::Settings {
position: self.next_window_pos,
exit_on_close_request: count % 2 == 0,
..Default::default()
},
);
} }
} }
Command::none()
} }
fn view(&self, window: window::Id) -> Element<Message> { fn view(&self, window: window::Id) -> Element<Message> {
@ -151,12 +154,10 @@ impl multi_window::Application for Example {
window::Event::CloseRequested => { window::Event::CloseRequested => {
Some(Message::CloseWindow(id)) Some(Message::CloseWindow(id))
} }
window::Event::Destroyed => { window::Event::Opened { position, .. } => {
Some(Message::WindowDestroyed(id)) Some(Message::WindowOpened(id, position))
}
window::Event::Created { position, .. } => {
Some(Message::WindowCreated(id, position))
} }
window::Event::Closed => Some(Message::WindowClosed(id)),
_ => None, _ => None,
} }
} else { } else {

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

@ -27,7 +27,7 @@ pub enum Action<T> {
Clipboard(clipboard::Action<T>), Clipboard(clipboard::Action<T>),
/// Run a window action. /// Run a window action.
Window(window::Id, window::Action<T>), Window(window::Action<T>),
/// Run a system action. /// Run a system action.
System(system::Action<T>), System(system::Action<T>),
@ -63,7 +63,7 @@ impl<T> Action<T> {
Self::Future(future) => Action::Future(Box::pin(future.map(f))), Self::Future(future) => Action::Future(Box::pin(future.map(f))),
Self::Stream(stream) => Action::Stream(Box::pin(stream.map(f))), Self::Stream(stream) => Action::Stream(Box::pin(stream.map(f))),
Self::Clipboard(action) => Action::Clipboard(action.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::System(system) => Action::System(system.map(f)),
Self::Widget(operation) => { Self::Widget(operation) => {
Action::Widget(Box::new(widget::operation::map(operation, f))) Action::Widget(Box::new(widget::operation::map(operation, f)))
@ -84,8 +84,8 @@ impl<T> fmt::Debug for Action<T> {
Self::Clipboard(action) => { Self::Clipboard(action) => {
write!(f, "Action::Clipboard({action:?})") write!(f, "Action::Clipboard({action:?})")
} }
Self::Window(id, action) => { Self::Window(action) => {
write!(f, "Action::Window({id:?}, {action:?})") write!(f, "Action::Window({action:?})")
} }
Self::System(action) => write!(f, "Action::System({action:?})"), Self::System(action) => write!(f, "Action::System({action:?})"),
Self::Widget(_action) => write!(f, "Action::Widget"), 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. //! Build interactive programs using The Elm Architecture.
use crate::{window, Command};
use crate::core::text; use crate::core::text;
use crate::core::window;
use crate::core::{Element, Renderer}; use crate::core::{Element, Renderer};
use crate::Command;
/// The core of a user interface for a multi-window application following The Elm Architecture. /// The core of a user interface for a multi-window application following The Elm Architecture.
pub trait Program: Sized { pub trait Program: Sized {

99
runtime/src/window.rs
View file

@ -3,13 +3,14 @@ mod action;
pub mod screenshot; pub mod screenshot;
pub use crate::core::window::Id;
pub use action::Action; pub use action::Action;
pub use screenshot::Screenshot; pub use screenshot::Screenshot;
use crate::command::{self, Command}; use crate::command::{self, Command};
use crate::core::time::Instant; 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::core::{Point, Size};
use crate::futures::event; use crate::futures::event;
use crate::futures::Subscription; use crate::futures::Subscription;
@ -29,73 +30,77 @@ pub fn frames() -> Subscription<Instant> {
}) })
} }
/// Spawns a new window with the given `id` and `settings`. /// Spawns a new window with the given `settings`.
pub fn spawn<Message>( ///
id: window::Id, /// Returns the new window [`Id`] alongside the [`Command`].
settings: window::Settings, pub fn spawn<Message>(settings: Settings) -> (Id, Command<Message>) {
) -> Command<Message> { let id = Id::unique();
Command::single(command::Action::Window(id, Action::Spawn { settings }))
(
id,
Command::single(command::Action::Window(Action::Spawn(id, settings))),
)
} }
/// Closes the window with `id`. /// Closes the window with `id`.
pub fn close<Message>(id: window::Id) -> Command<Message> { pub fn close<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Close)) Command::single(command::Action::Window(Action::Close(id)))
} }
/// Begins dragging the window while the left mouse button is held. /// Begins dragging the window while the left mouse button is held.
pub fn drag<Message>(id: window::Id) -> Command<Message> { pub fn drag<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Drag)) Command::single(command::Action::Window(Action::Drag(id)))
} }
/// Resizes the window to the given logical dimensions. /// Resizes the window to the given logical dimensions.
pub fn resize<Message>(id: window::Id, new_size: Size) -> Command<Message> { pub fn resize<Message>(id: Id, new_size: Size) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Resize(new_size))) Command::single(command::Action::Window(Action::Resize(id, new_size)))
} }
/// Fetches the window's size in logical dimensions. /// Fetches the window's size in logical dimensions.
pub fn fetch_size<Message>( pub fn fetch_size<Message>(
id: window::Id, id: Id,
f: impl FnOnce(Size) -> Message + 'static, f: impl FnOnce(Size) -> Message + 'static,
) -> Command<Message> { ) -> 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. /// Maximizes the window.
pub fn maximize<Message>(id: window::Id, maximized: bool) -> Command<Message> { pub fn maximize<Message>(id: Id, maximized: bool) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Maximize(maximized))) Command::single(command::Action::Window(Action::Maximize(id, maximized)))
} }
/// Minimizes the window. /// Minimizes the window.
pub fn minimize<Message>(id: window::Id, minimized: bool) -> Command<Message> { pub fn minimize<Message>(id: Id, minimized: bool) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Minimize(minimized))) Command::single(command::Action::Window(Action::Minimize(id, minimized)))
} }
/// Moves the window to the given logical coordinates. /// Moves the window to the given logical coordinates.
pub fn move_to<Message>(id: window::Id, position: Point) -> Command<Message> { pub fn move_to<Message>(id: Id, position: Point) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Move(position))) Command::single(command::Action::Window(Action::Move(id, position)))
} }
/// Changes the [`Mode`] of the window. /// Changes the [`Mode`] of the window.
pub fn change_mode<Message>(id: window::Id, mode: Mode) -> Command<Message> { pub fn change_mode<Message>(id: Id, mode: Mode) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeMode(mode))) Command::single(command::Action::Window(Action::ChangeMode(id, mode)))
} }
/// Fetches the current [`Mode`] of the window. /// Fetches the current [`Mode`] of the window.
pub fn fetch_mode<Message>( pub fn fetch_mode<Message>(
id: window::Id, id: Id,
f: impl FnOnce(Mode) -> Message + 'static, f: impl FnOnce(Mode) -> Message + 'static,
) -> Command<Message> { ) -> 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. /// Toggles the window to maximized or back.
pub fn toggle_maximize<Message>(id: window::Id) -> Command<Message> { pub fn toggle_maximize<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ToggleMaximize)) Command::single(command::Action::Window(Action::ToggleMaximize(id)))
} }
/// Toggles the window decorations. /// Toggles the window decorations.
pub fn toggle_decorations<Message>(id: window::Id) -> Command<Message> { pub fn toggle_decorations<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ToggleDecorations)) Command::single(command::Action::Window(Action::ToggleDecorations(id)))
} }
/// 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
@ -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 /// 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. /// user attention might not be done automatically by the WM when the window receives input.
pub fn request_user_attention<Message>( pub fn request_user_attention<Message>(
id: window::Id, id: Id,
user_attention: Option<UserAttention>, user_attention: Option<UserAttention>,
) -> Command<Message> { ) -> Command<Message> {
Command::single(command::Action::Window( Command::single(command::Action::Window(Action::RequestUserAttention(
id, id,
Action::RequestUserAttention(user_attention), user_attention,
)) )))
} }
/// Brings the window to the front and sets input focus. Has no effect if the window is /// 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 /// 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 /// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive
/// user experience. /// user experience.
pub fn gain_focus<Message>(id: window::Id) -> Command<Message> { pub fn gain_focus<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::GainFocus)) Command::single(command::Action::Window(Action::GainFocus(id)))
} }
/// Changes the window [`Level`]. /// Changes the window [`Level`].
pub fn change_level<Message>(id: window::Id, level: Level) -> Command<Message> { pub fn change_level<Message>(id: Id, level: Level) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeLevel(level))) Command::single(command::Action::Window(Action::ChangeLevel(id, level)))
} }
/// Fetches an identifier unique to the window, provided by the underlying windowing system. This is /// 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>( pub fn fetch_id<Message>(
id: window::Id, id: Id,
f: impl FnOnce(u64) -> Message + 'static, f: impl FnOnce(u64) -> Message + 'static,
) -> Command<Message> { ) -> 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. /// Changes the [`Icon`] of the window.
pub fn change_icon<Message>(id: window::Id, icon: Icon) -> Command<Message> { pub fn change_icon<Message>(id: Id, icon: Icon) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeIcon(icon))) Command::single(command::Action::Window(Action::ChangeIcon(id, icon)))
} }
/// Captures a [`Screenshot`] from the window. /// Captures a [`Screenshot`] from the window.
pub fn screenshot<Message>( pub fn screenshot<Message>(
id: window::Id, id: Id,
f: impl FnOnce(Screenshot) -> Message + Send + 'static, f: impl FnOnce(Screenshot) -> Message + Send + 'static,
) -> Command<Message> { ) -> Command<Message> {
Command::single(command::Action::Window( Command::single(command::Action::Window(Action::Screenshot(
id, 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::core::{Point, Size};
use crate::futures::MaybeSend; use crate::futures::MaybeSend;
use crate::window::Screenshot; use crate::window::Screenshot;
@ -7,43 +7,40 @@ use std::fmt;
/// An operation to be performed on some window. /// An operation to be performed on some window.
pub enum Action<T> { pub enum Action<T> {
/// Close the current window and exits the application. /// Spawns a new window with some [`Settings`].
Close, Spawn(Id, Settings),
/// Close the window and exits the application.
Close(Id),
/// Move the window with the left mouse button until the button is /// Move the window with the left mouse button until the button is
/// released. /// released.
/// ///
/// There’s no guarantee that this will work unless the left mouse /// There’s no guarantee that this will work unless the left mouse
/// button was pressed immediately before this function is called. /// button was pressed immediately before this function is called.
Drag, Drag(Id),
/// Spawns a new window.
Spawn {
/// The settings of the window.
settings: Settings,
},
/// Resize the window to the given logical dimensions. /// Resize the window to the given logical dimensions.
Resize(Size), Resize(Id, Size),
/// Fetch the current logical dimensions of the window. /// 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 /// Set the window to maximized or back
Maximize(bool), Maximize(Id, bool),
/// Set the window to minimized or back /// Set the window to minimized or back
Minimize(bool), Minimize(Id, bool),
/// Move the window to the given logical coordinates. /// Move the window to the given logical coordinates.
/// ///
/// Unsupported on Wayland. /// Unsupported on Wayland.
Move(Point), Move(Id, Point),
/// Change the [`Mode`] of the window. /// Change the [`Mode`] of the window.
ChangeMode(Mode), ChangeMode(Id, Mode),
/// Fetch the current [`Mode`] of the window. /// 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 /// Toggle the window to maximized or back
ToggleMaximize, ToggleMaximize(Id),
/// Toggle whether window has decorations. /// Toggle whether window has decorations.
/// ///
/// ## Platform-specific /// ## Platform-specific
/// - **X11:** Not implemented. /// - **X11:** Not implemented.
/// - **Web:** Unsupported. /// - **Web:** Unsupported.
ToggleDecorations, ToggleDecorations(Id),
/// 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, /// is already focused. How requesting for user attention manifests is platform dependent,
/// see [`UserAttention`] for details. /// see [`UserAttention`] for details.
@ -57,7 +54,7 @@ pub enum Action<T> {
/// - **macOS:** `None` has no effect. /// - **macOS:** `None` has no effect.
/// - **X11:** Requests for user attention must be manually cleared. /// - **X11:** Requests for user attention must be manually cleared.
/// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect. /// - **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 /// Bring the window to the front and sets input focus. Has no effect if the window is
/// already in focus, minimized, or not visible. /// already in focus, minimized, or not visible.
/// ///
@ -68,11 +65,11 @@ pub enum Action<T> {
/// ## Platform-specific /// ## Platform-specific
/// ///
/// - **Web / Wayland:** Unsupported. /// - **Web / Wayland:** Unsupported.
GainFocus, GainFocus(Id),
/// Change the window [`Level`]. /// Change the window [`Level`].
ChangeLevel(Level), ChangeLevel(Id, Level),
/// Fetch an identifier unique to the window. /// Fetch the raw identifier unique to the window.
FetchId(Box<dyn FnOnce(u64) -> T + 'static>), FetchId(Id, Box<dyn FnOnce(u64) -> T + 'static>),
/// Change the window [`Icon`]. /// Change the window [`Icon`].
/// ///
/// On Windows and X11, this is typically the small icon in the top-left /// 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 /// - **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. /// said, it's usually in the same ballpark as on Windows.
ChangeIcon(Icon), ChangeIcon(Id, Icon),
/// Screenshot the viewport of the window. /// 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> { impl<T> Action<T> {
@ -102,30 +99,35 @@ impl<T> Action<T> {
T: 'static, T: 'static,
{ {
match self { match self {
Self::Close => Action::Close, Self::Spawn(id, settings) => Action::Spawn(id, settings),
Self::Drag => Action::Drag, Self::Close(id) => Action::Close(id),
Self::Spawn { settings } => Action::Spawn { settings }, Self::Drag(id) => Action::Drag(id),
Self::Resize(size) => Action::Resize(size), Self::Resize(id, size) => Action::Resize(id, size),
Self::FetchSize(o) => Action::FetchSize(Box::new(move |s| f(o(s)))), Self::FetchSize(id, o) => {
Self::Maximize(maximized) => Action::Maximize(maximized), Action::FetchSize(id, Box::new(move |s| f(o(s))))
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::GainFocus => Action::GainFocus, Self::Maximize(id, maximized) => Action::Maximize(id, maximized),
Self::ChangeLevel(level) => Action::ChangeLevel(level), Self::Minimize(id, minimized) => Action::Minimize(id, minimized),
Self::FetchId(o) => Action::FetchId(Box::new(move |s| f(o(s)))), Self::Move(id, position) => Action::Move(id, position),
Self::ChangeIcon(icon) => Action::ChangeIcon(icon), Self::ChangeMode(id, mode) => Action::ChangeMode(id, mode),
Self::Screenshot(tag) => { Self::FetchMode(id, o) => {
Action::Screenshot(Box::new(move |screenshot| { Action::FetchMode(id, Box::new(move |s| f(o(s))))
f(tag(screenshot))
}))
} }
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> { impl<T> fmt::Debug for Action<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {
Self::Close => write!(f, "Action::Close"), Self::Spawn(id, settings) => {
Self::Drag => write!(f, "Action::Drag"), write!(f, "Action::Spawn({id:?}, {settings:?})")
Self::Spawn { settings } => {
write!(f, "Action::Spawn {{ settings: {:?} }}", settings)
} }
Self::Resize(size) => write!(f, "Action::Resize({size:?})"), Self::Close(id) => write!(f, "Action::Close({id:?})"),
Self::FetchSize(_) => write!(f, "Action::FetchSize"), Self::Drag(id) => write!(f, "Action::Drag({id:?})"),
Self::Maximize(maximized) => { Self::Resize(id, size) => {
write!(f, "Action::Maximize({maximized})") write!(f, "Action::Resize({id:?}, {size:?})")
} }
Self::Minimize(minimized) => { Self::FetchSize(id, _) => write!(f, "Action::FetchSize({id:?})"),
write!(f, "Action::Minimize({minimized}") Self::Maximize(id, maximized) => {
write!(f, "Action::Maximize({id:?}, {maximized})")
} }
Self::Move(position) => { Self::Minimize(id, minimized) => {
write!(f, "Action::Move({position})") write!(f, "Action::Minimize({id:?}, {minimized}")
} }
Self::ChangeMode(mode) => write!(f, "Action::SetMode({mode:?})"), Self::Move(id, position) => {
Self::FetchMode(_) => write!(f, "Action::FetchMode"), write!(f, "Action::Move({id:?}, {position})")
Self::ToggleMaximize => write!(f, "Action::ToggleMaximize"),
Self::ToggleDecorations => write!(f, "Action::ToggleDecorations"),
Self::RequestUserAttention(_) => {
write!(f, "Action::RequestUserAttention")
} }
Self::GainFocus => write!(f, "Action::GainFocus"), Self::ChangeMode(id, mode) => {
Self::ChangeLevel(level) => { write!(f, "Action::SetMode({id:?}, {mode:?})")
write!(f, "Action::ChangeLevel({level:?})")
} }
Self::FetchId(_) => write!(f, "Action::FetchId"), Self::FetchMode(id, _) => write!(f, "Action::FetchMode({id:?})"),
Self::ChangeIcon(_icon) => { Self::ToggleMaximize(id) => {
write!(f, "Action::ChangeIcon(icon)") 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:?})"),
} }
} }
} }

36
winit/src/application.rs
View file

@ -712,11 +712,11 @@ pub fn run_command<A, C, E>(
clipboard.write(contents); clipboard.write(contents);
} }
}, },
command::Action::Window(_, action) => match action { command::Action::Window(action) => match action {
window::Action::Close => { window::Action::Close(_id) => {
*should_exit = true; *should_exit = true;
} }
window::Action::Drag => { window::Action::Drag(_id) => {
let _res = window.drag_window(); let _res = window.drag_window();
} }
window::Action::Spawn { .. } => { window::Action::Spawn { .. } => {
@ -725,13 +725,13 @@ pub fn run_command<A, C, E>(
multi-window applications." multi-window applications."
); );
} }
window::Action::Resize(size) => { window::Action::Resize(_id, size) => {
window.set_inner_size(winit::dpi::LogicalSize { window.set_inner_size(winit::dpi::LogicalSize {
width: size.width, width: size.width,
height: size.height, height: size.height,
}); });
} }
window::Action::FetchSize(callback) => { window::Action::FetchSize(_id, callback) => {
let size = let size =
window.inner_size().to_logical(window.scale_factor()); window.inner_size().to_logical(window.scale_factor());
@ -742,29 +742,29 @@ pub fn run_command<A, C, E>(
))) )))
.expect("Send message to event loop"); .expect("Send message to event loop");
} }
window::Action::Maximize(maximized) => { window::Action::Maximize(_id, maximized) => {
window.set_maximized(maximized); window.set_maximized(maximized);
} }
window::Action::Minimize(minimized) => { window::Action::Minimize(_id, minimized) => {
window.set_minimized(minimized); window.set_minimized(minimized);
} }
window::Action::Move(position) => { window::Action::Move(_id, position) => {
window.set_outer_position(winit::dpi::LogicalPosition { window.set_outer_position(winit::dpi::LogicalPosition {
x: position.x, x: position.x,
y: position.y, y: position.y,
}); });
} }
window::Action::ChangeMode(mode) => { window::Action::ChangeMode(_id, mode) => {
window.set_visible(conversion::visible(mode)); window.set_visible(conversion::visible(mode));
window.set_fullscreen(conversion::fullscreen( window.set_fullscreen(conversion::fullscreen(
window.current_monitor(), window.current_monitor(),
mode, mode,
)); ));
} }
window::Action::ChangeIcon(icon) => { window::Action::ChangeIcon(_id, icon) => {
window.set_window_icon(conversion::icon(icon)); window.set_window_icon(conversion::icon(icon));
} }
window::Action::FetchMode(tag) => { window::Action::FetchMode(_id, tag) => {
let mode = if window.is_visible().unwrap_or(true) { let mode = if window.is_visible().unwrap_or(true) {
conversion::mode(window.fullscreen()) conversion::mode(window.fullscreen())
} else { } else {
@ -775,29 +775,29 @@ pub fn run_command<A, C, E>(
.send_event(tag(mode)) .send_event(tag(mode))
.expect("Send message to event loop"); .expect("Send message to event loop");
} }
window::Action::ToggleMaximize => { window::Action::ToggleMaximize(_id) => {
window.set_maximized(!window.is_maximized()); window.set_maximized(!window.is_maximized());
} }
window::Action::ToggleDecorations => { window::Action::ToggleDecorations(_id) => {
window.set_decorations(!window.is_decorated()); window.set_decorations(!window.is_decorated());
} }
window::Action::RequestUserAttention(user_attention) => { window::Action::RequestUserAttention(_id, user_attention) => {
window.request_user_attention( window.request_user_attention(
user_attention.map(conversion::user_attention), user_attention.map(conversion::user_attention),
); );
} }
window::Action::GainFocus => { window::Action::GainFocus(_id) => {
window.focus_window(); window.focus_window();
} }
window::Action::ChangeLevel(level) => { window::Action::ChangeLevel(_id, level) => {
window.set_window_level(conversion::window_level(level)); window.set_window_level(conversion::window_level(level));
} }
window::Action::FetchId(tag) => { window::Action::FetchId(_id, tag) => {
proxy proxy
.send_event(tag(window.id().into())) .send_event(tag(window.id().into()))
.expect("Send message to event loop"); .expect("Send message to event loop");
} }
window::Action::Screenshot(tag) => { window::Action::Screenshot(_id, tag) => {
let bytes = compositor.screenshot( let bytes = compositor.screenshot(
renderer, renderer,
surface, surface,

44
winit/src/multi_window.rs
View file

@ -361,7 +361,7 @@ async fn run_instance<A, E, C>(
Some(window::Id::MAIN), Some(window::Id::MAIN),
core::Event::Window( core::Event::Window(
window::Id::MAIN, window::Id::MAIN,
window::Event::Created { position, size }, window::Event::Opened { position, size },
), ),
)] )]
}; };
@ -402,7 +402,7 @@ async fn run_instance<A, E, C>(
Some(id), Some(id),
core::Event::Window( core::Event::Window(
id, id,
window::Event::Created { position, size }, window::Event::Opened { position, size },
), ),
)); ));
} }
@ -761,7 +761,7 @@ async fn run_instance<A, E, C>(
None, None,
core::Event::Window( core::Event::Window(
id, id,
window::Event::Destroyed, window::Event::Closed,
), ),
)); ));
} }
@ -884,8 +884,8 @@ fn run_command<A, C, E>(
clipboard.write(contents); clipboard.write(contents);
} }
}, },
command::Action::Window(id, action) => match action { command::Action::Window(action) => match action {
window::Action::Spawn { settings } => { window::Action::Spawn(id, settings) => {
let monitor = windows.last_monitor(); let monitor = windows.last_monitor();
control_sender control_sender
@ -897,7 +897,7 @@ fn run_command<A, C, E>(
}) })
.expect("Send control action"); .expect("Send control action");
} }
window::Action::Close => { window::Action::Close(id) => {
use winit::event_loop::ControlFlow; use winit::event_loop::ControlFlow;
let i = windows.delete(id); let i = windows.delete(id);
@ -911,10 +911,10 @@ fn run_command<A, C, E>(
.expect("Send control action"); .expect("Send control action");
} }
} }
window::Action::Drag => { window::Action::Drag(id) => {
let _ = windows.with_raw(id).drag_window(); let _ = windows.with_raw(id).drag_window();
} }
window::Action::Resize(size) => { window::Action::Resize(id, size) => {
windows.with_raw(id).set_inner_size( windows.with_raw(id).set_inner_size(
winit::dpi::LogicalSize { winit::dpi::LogicalSize {
width: size.width, width: size.width,
@ -922,7 +922,7 @@ fn run_command<A, C, E>(
}, },
); );
} }
window::Action::FetchSize(callback) => { window::Action::FetchSize(id, callback) => {
let window = windows.with_raw(id); let window = windows.with_raw(id);
let size = let size =
window.inner_size().to_logical(window.scale_factor()); window.inner_size().to_logical(window.scale_factor());
@ -934,13 +934,13 @@ fn run_command<A, C, E>(
))) )))
.expect("Send message to event loop"); .expect("Send message to event loop");
} }
window::Action::Maximize(maximized) => { window::Action::Maximize(id, maximized) => {
windows.with_raw(id).set_maximized(maximized); windows.with_raw(id).set_maximized(maximized);
} }
window::Action::Minimize(minimized) => { window::Action::Minimize(id, minimized) => {
windows.with_raw(id).set_minimized(minimized); windows.with_raw(id).set_minimized(minimized);
} }
window::Action::Move(position) => { window::Action::Move(id, position) => {
windows.with_raw(id).set_outer_position( windows.with_raw(id).set_outer_position(
winit::dpi::LogicalPosition { winit::dpi::LogicalPosition {
x: position.x, x: position.x,
@ -948,7 +948,7 @@ fn run_command<A, C, E>(
}, },
); );
} }
window::Action::ChangeMode(mode) => { window::Action::ChangeMode(id, mode) => {
let window = windows.with_raw(id); let window = windows.with_raw(id);
window.set_visible(conversion::visible(mode)); window.set_visible(conversion::visible(mode));
window.set_fullscreen(conversion::fullscreen( window.set_fullscreen(conversion::fullscreen(
@ -956,12 +956,12 @@ fn run_command<A, C, E>(
mode, mode,
)); ));
} }
window::Action::ChangeIcon(icon) => { window::Action::ChangeIcon(id, icon) => {
windows windows
.with_raw(id) .with_raw(id)
.set_window_icon(conversion::icon(icon)); .set_window_icon(conversion::icon(icon));
} }
window::Action::FetchMode(tag) => { window::Action::FetchMode(id, tag) => {
let window = windows.with_raw(id); let window = windows.with_raw(id);
let mode = if window.is_visible().unwrap_or(true) { let mode = if window.is_visible().unwrap_or(true) {
conversion::mode(window.fullscreen()) conversion::mode(window.fullscreen())
@ -973,33 +973,33 @@ fn run_command<A, C, E>(
.send_event(tag(mode)) .send_event(tag(mode))
.expect("Event loop doesn't exist."); .expect("Event loop doesn't exist.");
} }
window::Action::ToggleMaximize => { window::Action::ToggleMaximize(id) => {
let window = windows.with_raw(id); let window = windows.with_raw(id);
window.set_maximized(!window.is_maximized()); window.set_maximized(!window.is_maximized());
} }
window::Action::ToggleDecorations => { window::Action::ToggleDecorations(id) => {
let window = windows.with_raw(id); let window = windows.with_raw(id);
window.set_decorations(!window.is_decorated()); window.set_decorations(!window.is_decorated());
} }
window::Action::RequestUserAttention(attention_type) => { window::Action::RequestUserAttention(id, attention_type) => {
windows.with_raw(id).request_user_attention( windows.with_raw(id).request_user_attention(
attention_type.map(conversion::user_attention), attention_type.map(conversion::user_attention),
); );
} }
window::Action::GainFocus => { window::Action::GainFocus(id) => {
windows.with_raw(id).focus_window(); windows.with_raw(id).focus_window();
} }
window::Action::ChangeLevel(level) => { window::Action::ChangeLevel(id, level) => {
windows windows
.with_raw(id) .with_raw(id)
.set_window_level(conversion::window_level(level)); .set_window_level(conversion::window_level(level));
} }
window::Action::FetchId(tag) => { window::Action::FetchId(id, tag) => {
proxy proxy
.send_event(tag(windows.with_raw(id).id().into())) .send_event(tag(windows.with_raw(id).id().into()))
.expect("Event loop doesn't exist."); .expect("Event loop doesn't exist.");
} }
window::Action::Screenshot(tag) => { window::Action::Screenshot(id, tag) => {
let i = windows.index_from_id(id); let i = windows.index_from_id(id);
let state = &windows.states[i]; let state = &windows.states[i];
let surface = &mut windows.surfaces[i]; let surface = &mut windows.surfaces[i];