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

Replace Command with a new Task API with chain support

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2024-06-14 01:47:39 +02:00
parent e6d0b3bda5
commit a25b1af456
No known key found for this signature in database
GPG key ID: 7CC46565708259A7
74 changed files with 1351 additions and 1767 deletions
Download patch file Download diff file Expand all files Collapse all files

98
runtime/src/clipboard.rs
View file

@ -1,80 +1,62 @@
//! Access the clipboard.
use crate::command::{self, Command};
use crate::core::clipboard::Kind;
use crate::futures::MaybeSend;
use crate::futures::futures::channel::oneshot;
use crate::Task;
use std::fmt;
/// A clipboard action to be performed by some [`Command`].
/// A clipboard action to be performed by some [`Task`].
///
/// [`Command`]: crate::Command
pub enum Action<T> {
/// [`Task`]: crate::Task
#[derive(Debug)]
pub enum Action {
/// Read the clipboard and produce `T` with the result.
Read(Box<dyn Fn(Option<String>) -> T>, Kind),
Read {
/// The clipboard target.
target: Kind,
/// The channel to send the read contents.
channel: oneshot::Sender<Option<String>>,
},
/// Write the given contents to the clipboard.
Write(String, Kind),
}
impl<T> Action<T> {
/// Maps the output of a clipboard [`Action`] using the provided closure.
pub fn map<A>(
self,
f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
) -> Action<A>
where
T: 'static,
{
match self {
Self::Read(o, target) => {
Action::Read(Box::new(move |s| f(o(s))), target)
}
Self::Write(content, target) => Action::Write(content, target),
}
}
}
impl<T> fmt::Debug for Action<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Read(_, target) => write!(f, "Action::Read{target:?}"),
Self::Write(_, target) => write!(f, "Action::Write({target:?})"),
}
}
Write {
/// The clipboard target.
target: Kind,
/// The contents to be written.
contents: String,
},
}
/// Read the current contents of the clipboard.
pub fn read<Message>(
f: impl Fn(Option<String>) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Clipboard(Action::Read(
Box::new(f),
Kind::Standard,
)))
pub fn read() -> Task<Option<String>> {
Task::oneshot(|channel| {
crate::Action::Clipboard(Action::Read {
target: Kind::Standard,
channel,
})
})
}
/// Read the current contents of the primary clipboard.
pub fn read_primary<Message>(
f: impl Fn(Option<String>) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Clipboard(Action::Read(
Box::new(f),
Kind::Primary,
)))
pub fn read_primary() -> Task<Option<String>> {
Task::oneshot(|channel| {
crate::Action::Clipboard(Action::Read {
target: Kind::Primary,
channel,
})
})
}
/// Write the given contents to the clipboard.
pub fn write<Message>(contents: String) -> Command<Message> {
Command::single(command::Action::Clipboard(Action::Write(
pub fn write<T>(contents: String) -> Task<T> {
Task::effect(crate::Action::Clipboard(Action::Write {
target: Kind::Standard,
contents,
Kind::Standard,
)))
}))
}
/// Write the given contents to the primary clipboard.
pub fn write_primary<Message>(contents: String) -> Command<Message> {
Command::single(command::Action::Clipboard(Action::Write(
pub fn write_primary<Message>(contents: String) -> Task<Message> {
Task::effect(crate::Action::Clipboard(Action::Write {
target: Kind::Primary,
contents,
Kind::Primary,
)))
}))
}

147
runtime/src/command.rs
View file

@ -1,147 +0,0 @@
//! Run asynchronous actions.
mod action;
pub use action::Action;
use crate::core::widget;
use crate::futures::futures;
use crate::futures::MaybeSend;
use futures::channel::mpsc;
use futures::Stream;
use std::fmt;
use std::future::Future;
/// A set of asynchronous actions to be performed by some runtime.
#[must_use = "`Command` must be returned to runtime to take effect"]
pub struct Command<T>(Internal<Action<T>>);
#[derive(Debug)]
enum Internal<T> {
None,
Single(T),
Batch(Vec<T>),
}
impl<T> Command<T> {
/// Creates an empty [`Command`].
///
/// In other words, a [`Command`] that does nothing.
pub const fn none() -> Self {
Self(Internal::None)
}
/// Creates a [`Command`] that performs a single [`Action`].
pub const fn single(action: Action<T>) -> Self {
Self(Internal::Single(action))
}
/// Creates a [`Command`] that performs a [`widget::Operation`].
pub fn widget(operation: impl widget::Operation<T> + 'static) -> Self {
Self::single(Action::Widget(Box::new(operation)))
}
/// Creates a [`Command`] that performs the action of the given future.
pub fn perform<A>(
future: impl Future<Output = A> + 'static + MaybeSend,
f: impl FnOnce(A) -> T + 'static + MaybeSend,
) -> Command<T> {
use futures::FutureExt;
Command::single(Action::Future(Box::pin(future.map(f))))
}
/// Creates a [`Command`] that runs the given stream to completion.
pub fn run<A>(
stream: impl Stream<Item = A> + 'static + MaybeSend,
f: impl Fn(A) -> T + 'static + MaybeSend,
) -> Command<T> {
use futures::StreamExt;
Command::single(Action::Stream(Box::pin(stream.map(f))))
}
/// Creates a [`Command`] that performs the actions of all the given
/// commands.
///
/// Once this command is run, all the commands will be executed at once.
pub fn batch(commands: impl IntoIterator<Item = Command<T>>) -> Self {
let mut batch = Vec::new();
for Command(command) in commands {
match command {
Internal::None => {}
Internal::Single(command) => batch.push(command),
Internal::Batch(commands) => batch.extend(commands),
}
}
Self(Internal::Batch(batch))
}
/// Applies a transformation to the result of a [`Command`].
pub fn map<A>(
self,
f: impl Fn(T) -> A + 'static + MaybeSend + Sync + Clone,
) -> Command<A>
where
T: 'static,
A: 'static,
{
match self.0 {
Internal::None => Command::none(),
Internal::Single(action) => Command::single(action.map(f)),
Internal::Batch(batch) => Command(Internal::Batch(
batch
.into_iter()
.map(|action| action.map(f.clone()))
.collect(),
)),
}
}
/// Returns all of the actions of the [`Command`].
pub fn actions(self) -> Vec<Action<T>> {
let Command(command) = self;
match command {
Internal::None => Vec::new(),
Internal::Single(action) => vec![action],
Internal::Batch(batch) => batch,
}
}
}
impl<Message> From<()> for Command<Message> {
fn from(_value: ()) -> Self {
Self::none()
}
}
impl<T> fmt::Debug for Command<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let Command(command) = self;
command.fmt(f)
}
}
/// Creates a [`Command`] that produces the `Message`s published from a [`Future`]
/// to an [`mpsc::Sender`] with the given bounds.
pub fn channel<Fut, Message>(
size: usize,
f: impl FnOnce(mpsc::Sender<Message>) -> Fut + MaybeSend + 'static,
) -> Command<Message>
where
Fut: Future<Output = ()> + MaybeSend + 'static,
Message: 'static + MaybeSend,
{
use futures::future;
use futures::stream::{self, StreamExt};
let (sender, receiver) = mpsc::channel(size);
let runner = stream::once(f(sender)).filter_map(|_| future::ready(None));
Command::single(Action::Stream(Box::pin(stream::select(receiver, runner))))
}

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

@ -1,100 +0,0 @@
use crate::clipboard;
use crate::core::widget;
use crate::font;
use crate::futures::MaybeSend;
use crate::system;
use crate::window;
use std::any::Any;
use std::borrow::Cow;
use std::fmt;
/// An action that a [`Command`] can perform.
///
/// [`Command`]: crate::Command
pub enum Action<T> {
/// Run a [`Future`] to completion.
///
/// [`Future`]: iced_futures::BoxFuture
Future(iced_futures::BoxFuture<T>),
/// Run a [`Stream`] to completion.
///
/// [`Stream`]: iced_futures::BoxStream
Stream(iced_futures::BoxStream<T>),
/// Run a clipboard action.
Clipboard(clipboard::Action<T>),
/// Run a window action.
Window(window::Action<T>),
/// Run a system action.
System(system::Action<T>),
/// Run a widget action.
Widget(Box<dyn widget::Operation<T>>),
/// Load a font from its bytes.
LoadFont {
/// The bytes of the font to load.
bytes: Cow<'static, [u8]>,
/// The message to produce when the font has been loaded.
tagger: Box<dyn Fn(Result<(), font::Error>) -> T>,
},
/// A custom action supported by a specific runtime.
Custom(Box<dyn Any>),
}
impl<T> Action<T> {
/// Applies a transformation to the result of a [`Command`].
///
/// [`Command`]: crate::Command
pub fn map<A>(
self,
f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
) -> Action<A>
where
A: 'static,
T: 'static,
{
use iced_futures::futures::{FutureExt, StreamExt};
match self {
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(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)))
}
Self::LoadFont { bytes, tagger } => Action::LoadFont {
bytes,
tagger: Box::new(move |result| f(tagger(result))),
},
Self::Custom(custom) => Action::Custom(custom),
}
}
}
impl<T> fmt::Debug for Action<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Future(_) => write!(f, "Action::Future"),
Self::Stream(_) => write!(f, "Action::Stream"),
Self::Clipboard(action) => {
write!(f, "Action::Clipboard({action:?})")
}
Self::Window(action) => {
write!(f, "Action::Window({action:?})")
}
Self::System(action) => write!(f, "Action::System({action:?})"),
Self::Widget(_action) => write!(f, "Action::Widget"),
Self::LoadFont { .. } => write!(f, "Action::LoadFont"),
Self::Custom(_) => write!(f, "Action::Custom"),
}
}
}

12
runtime/src/font.rs
View file

@ -1,7 +1,5 @@
//! Load and use fonts.
pub use iced_core::font::*;
use crate::command::{self, Command};
use crate::{Action, Task};
use std::borrow::Cow;
/// An error while loading a font.
@ -9,11 +7,9 @@ use std::borrow::Cow;
pub enum Error {}
/// Load a font from its bytes.
pub fn load(
bytes: impl Into<Cow<'static, [u8]>>,
) -> Command<Result<(), Error>> {
Command::single(command::Action::LoadFont {
pub fn load(bytes: impl Into<Cow<'static, [u8]>>) -> Task<Result<(), Error>> {
Task::oneshot(|channel| Action::LoadFont {
bytes: bytes.into(),
tagger: Box::new(std::convert::identity),
channel,
})
}

80
runtime/src/lib.rs
View file

@ -10,7 +10,6 @@
)]
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
pub mod clipboard;
pub mod command;
pub mod font;
pub mod keyboard;
pub mod overlay;
@ -22,6 +21,8 @@ pub mod window;
#[cfg(feature = "multi-window")]
pub mod multi_window;
mod task;
// We disable debug capabilities on release builds unless the `debug` feature
// is explicitly enabled.
#[cfg(feature = "debug")]
@ -34,8 +35,81 @@ mod debug;
pub use iced_core as core;
pub use iced_futures as futures;
pub use command::Command;
pub use debug::Debug;
pub use font::Font;
pub use program::Program;
pub use task::Task;
pub use user_interface::UserInterface;
use crate::core::widget;
use crate::futures::futures::channel::oneshot;
use std::borrow::Cow;
use std::fmt;
/// An action that the iced runtime can perform.
pub enum Action<T> {
/// Output some value.
Output(T),
/// Load a font from its bytes.
LoadFont {
/// The bytes of the font to load.
bytes: Cow<'static, [u8]>,
/// The channel to send back the load result.
channel: oneshot::Sender<Result<(), font::Error>>,
},
/// Run a widget operation.
Widget(Box<dyn widget::Operation<()> + Send>),
/// Run a clipboard action.
Clipboard(clipboard::Action),
/// Run a window action.
Window(window::Action),
/// Run a system action.
System(system::Action),
}
impl<T> Action<T> {
/// Creates a new [`Action::Widget`] with the given [`widget::Operation`].
pub fn widget(operation: impl widget::Operation<()> + 'static) -> Self {
Self::Widget(Box::new(operation))
}
fn output<O>(self) -> Result<T, Action<O>> {
match self {
Action::Output(output) => Ok(output),
Action::LoadFont { bytes, channel } => {
Err(Action::LoadFont { bytes, channel })
}
Action::Widget(operation) => Err(Action::Widget(operation)),
Action::Clipboard(action) => Err(Action::Clipboard(action)),
Action::Window(action) => Err(Action::Window(action)),
Action::System(action) => Err(Action::System(action)),
}
}
}
impl<T> fmt::Debug for Action<T>
where
T: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Action::Output(output) => write!(f, "Action::Output({output:?})"),
Action::LoadFont { .. } => {
write!(f, "Action::LoadFont")
}
Action::Widget { .. } => {
write!(f, "Action::Widget")
}
Action::Clipboard(action) => {
write!(f, "Action::Clipboard({action:?})")
}
Action::Window(_) => write!(f, "Action::Window"),
Action::System(action) => write!(f, "Action::System({action:?})"),
}
}
}

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

@ -2,7 +2,7 @@
use crate::core::text;
use crate::core::window;
use crate::core::{Element, Renderer};
use crate::Command;
use crate::Task;
/// The core of a user interface for a multi-window application following The Elm Architecture.
pub trait Program: Sized {
@ -21,9 +21,9 @@ pub trait Program: Sized {
/// 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<Self::Message>;
/// Any [`Task`] returned will be executed immediately in the background by the
/// runtime.
fn update(&mut self, message: Self::Message) -> Task<Self::Message>;
/// Returns the widgets to display in the [`Program`] for the `window`.
///

18
runtime/src/multi_window/state.rs
View file

@ -5,7 +5,7 @@ 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};
use crate::{Debug, Program, Task};
/// The execution state of a multi-window [`Program`]. It leverages caching, event
/// processing, and rendering primitive storage.
@ -85,7 +85,7 @@ where
/// 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`]
/// captured by any widget, and the [`Task`] obtained from [`Program`]
/// after updating it, only if an update was necessary.
pub fn update(
&mut self,
@ -96,7 +96,7 @@ where
style: &renderer::Style,
clipboard: &mut dyn Clipboard,
debug: &mut Debug,
) -> (Vec<Event>, Option<Command<P::Message>>) {
) -> (Vec<Event>, Option<Task<P::Message>>) {
let mut user_interfaces = build_user_interfaces(
&self.program,
self.caches.take().unwrap(),
@ -163,14 +163,14 @@ where
drop(user_interfaces);
let commands = Command::batch(messages.into_iter().map(|msg| {
let commands = Task::batch(messages.into_iter().map(|msg| {
debug.log_message(&msg);
debug.update_started();
let command = self.program.update(msg);
let task = self.program.update(msg);
debug.update_finished();
command
task
}));
let mut user_interfaces = build_user_interfaces(
@ -205,7 +205,7 @@ where
pub fn operate(
&mut self,
renderer: &mut P::Renderer,
operations: impl Iterator<Item = Box<dyn Operation<P::Message>>>,
operations: impl Iterator<Item = Box<dyn Operation<()>>>,
bounds: Size,
debug: &mut Debug,
) {
@ -227,9 +227,7 @@ where
match operation.finish() {
operation::Outcome::None => {}
operation::Outcome::Some(message) => {
self.queued_messages.push(message);
}
operation::Outcome::Some(()) => {}
operation::Outcome::Chain(next) => {
current_operation = Some(next);
}

4
runtime/src/overlay/nested.rs
View file

@ -131,13 +131,13 @@ where
&mut self,
layout: Layout<'_>,
renderer: &Renderer,
operation: &mut dyn widget::Operation<Message>,
operation: &mut dyn widget::Operation<()>,
) {
fn recurse<Message, Theme, Renderer>(
element: &mut overlay::Element<'_, Message, Theme, Renderer>,
layout: Layout<'_>,
renderer: &Renderer,
operation: &mut dyn widget::Operation<Message>,
operation: &mut dyn widget::Operation<()>,
) where
Renderer: renderer::Renderer,
{

6
runtime/src/program.rs
View file

@ -1,5 +1,5 @@
//! Build interactive programs using The Elm Architecture.
use crate::Command;
use crate::Task;
use iced_core::text;
use iced_core::Element;
@ -25,9 +25,9 @@ pub trait Program: Sized {
/// produced by either user interactions or commands, will be handled by
/// this method.
///
/// Any [`Command`] returned will be executed immediately in the
/// Any [`Task`] returned will be executed immediately in the
/// background by shells.
fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
fn update(&mut self, message: Self::Message) -> Task<Self::Message>;
/// Returns the widgets to display in the [`Program`].
///

33
runtime/src/program/state.rs
View file

@ -4,7 +4,7 @@ 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};
use crate::{Debug, Program, Task};
/// The execution state of a [`Program`]. It leverages caching, event
/// processing, and rendering primitive storage.
@ -84,7 +84,7 @@ where
/// 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`]
/// captured by any widget, and the [`Task`] obtained from [`Program`]
/// after updating it, only if an update was necessary.
pub fn update(
&mut self,
@ -95,7 +95,7 @@ where
style: &renderer::Style,
clipboard: &mut dyn Clipboard,
debug: &mut Debug,
) -> (Vec<Event>, Option<Command<P::Message>>) {
) -> (Vec<Event>, Option<Task<P::Message>>) {
let mut user_interface = build_user_interface(
&mut self.program,
self.cache.take().unwrap(),
@ -129,7 +129,7 @@ where
messages.append(&mut self.queued_messages);
debug.event_processing_finished();
let command = if messages.is_empty() {
let task = if messages.is_empty() {
debug.draw_started();
self.mouse_interaction =
user_interface.draw(renderer, theme, style, cursor);
@ -143,16 +143,15 @@ where
// for now :^)
let temp_cache = user_interface.into_cache();
let commands =
Command::batch(messages.into_iter().map(|message| {
debug.log_message(&message);
let tasks = Task::batch(messages.into_iter().map(|message| {
debug.log_message(&message);
debug.update_started();
let command = self.program.update(message);
debug.update_finished();
debug.update_started();
let task = self.program.update(message);
debug.update_finished();
command
}));
task
}));
let mut user_interface = build_user_interface(
&mut self.program,
@ -169,17 +168,17 @@ where
self.cache = Some(user_interface.into_cache());
Some(commands)
Some(tasks)
};
(uncaptured_events, command)
(uncaptured_events, task)
}
/// Applies [`Operation`]s to the [`State`]
pub fn operate(
&mut self,
renderer: &mut P::Renderer,
operations: impl Iterator<Item = Box<dyn Operation<P::Message>>>,
operations: impl Iterator<Item = Box<dyn Operation<()>>>,
bounds: Size,
debug: &mut Debug,
) {
@ -199,9 +198,7 @@ where
match operation.finish() {
operation::Outcome::None => {}
operation::Outcome::Some(message) => {
self.queued_messages.push(message);
}
operation::Outcome::Some(()) => {}
operation::Outcome::Chain(next) => {
current_operation = Some(next);
}

41
runtime/src/system.rs
View file

@ -1,6 +1,39 @@
//! Access the native system.
mod action;
mod information;
use crate::futures::futures::channel::oneshot;
pub use action::Action;
pub use information::Information;
/// An operation to be performed on the system.
#[derive(Debug)]
pub enum Action {
/// Query system information and produce `T` with the result.
QueryInformation(oneshot::Sender<Information>),
}
/// Contains informations about the system (e.g. system name, processor, memory, graphics adapter).
#[derive(Clone, Debug)]
pub struct Information {
/// The operating system name
pub system_name: Option<String>,
/// Operating system kernel version
pub system_kernel: Option<String>,
/// Long operating system version
///
/// Examples:
/// - MacOS 10.15 Catalina
/// - Windows 10 Pro
/// - Ubuntu 20.04 LTS (Focal Fossa)
pub system_version: Option<String>,
/// Short operating system version number
pub system_short_version: Option<String>,
/// Detailed processor model information
pub cpu_brand: String,
/// The number of physical cores on the processor
pub cpu_cores: Option<usize>,
/// Total RAM size, in bytes
pub memory_total: u64,
/// Memory used by this process, in bytes
pub memory_used: Option<u64>,
/// Underlying graphics backend for rendering
pub graphics_backend: String,
/// Model information for the active graphics adapter
pub graphics_adapter: String,
}

39
runtime/src/system/action.rs
View file

@ -1,39 +0,0 @@
use crate::system;
use iced_futures::MaybeSend;
use std::fmt;
/// An operation to be performed on the system.
pub enum Action<T> {
/// Query system information and produce `T` with the result.
QueryInformation(Box<dyn Closure<T>>),
}
pub trait Closure<T>: Fn(system::Information) -> T + MaybeSend {}
impl<T, O> Closure<O> for T where T: Fn(system::Information) -> O + MaybeSend {}
impl<T> Action<T> {
/// Maps the output of a system [`Action`] using the provided closure.
pub fn map<A>(
self,
f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
) -> Action<A>
where
T: 'static,
{
match self {
Self::QueryInformation(o) => {
Action::QueryInformation(Box::new(move |s| f(o(s))))
}
}
}
}
impl<T> fmt::Debug for Action<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::QueryInformation(_) => write!(f, "Action::QueryInformation"),
}
}
}

29
runtime/src/system/information.rs
View file

@ -1,29 +0,0 @@
/// Contains informations about the system (e.g. system name, processor, memory, graphics adapter).
#[derive(Clone, Debug)]
pub struct Information {
/// The operating system name
pub system_name: Option<String>,
/// Operating system kernel version
pub system_kernel: Option<String>,
/// Long operating system version
///
/// Examples:
/// - MacOS 10.15 Catalina
/// - Windows 10 Pro
/// - Ubuntu 20.04 LTS (Focal Fossa)
pub system_version: Option<String>,
/// Short operating system version number
pub system_short_version: Option<String>,
/// Detailed processor model information
pub cpu_brand: String,
/// The number of physical cores on the processor
pub cpu_cores: Option<usize>,
/// Total RAM size, in bytes
pub memory_total: u64,
/// Memory used by this process, in bytes
pub memory_used: Option<u64>,
/// Underlying graphics backend for rendering
pub graphics_backend: String,
/// Model information for the active graphics adapter
pub graphics_adapter: String,
}

214
runtime/src/task.rs Normal file
View file

@ -0,0 +1,214 @@
use crate::core::widget;
use crate::core::MaybeSend;
use crate::futures::futures::channel::mpsc;
use crate::futures::futures::channel::oneshot;
use crate::futures::futures::future::{self, FutureExt};
use crate::futures::futures::never::Never;
use crate::futures::futures::stream::{self, Stream, StreamExt};
use crate::futures::{boxed_stream, BoxStream};
use crate::Action;
use std::future::Future;
/// A set of concurrent actions to be performed by the iced runtime.
///
/// A [`Task`] _may_ produce a bunch of values of type `T`.
#[allow(missing_debug_implementations)]
pub struct Task<T>(Option<BoxStream<Action<T>>>);
impl<T> Task<T> {
/// Creates a [`Task`] that does nothing.
pub fn none() -> Self {
Self(None)
}
/// Creates a new [`Task`] that instantly produces the given value.
pub fn done(value: T) -> Self
where
T: MaybeSend + 'static,
{
Self::future(future::ready(value))
}
/// Creates a new [`Task`] that runs the given [`Future`] and produces
/// its output.
pub fn future(future: impl Future<Output = T> + MaybeSend + 'static) -> Self
where
T: 'static,
{
Self::stream(stream::once(future))
}
/// Creates a new [`Task`] that runs the given [`Stream`] and produces
/// each of its items.
pub fn stream(stream: impl Stream<Item = T> + MaybeSend + 'static) -> Self
where
T: 'static,
{
Self(Some(boxed_stream(stream.map(Action::Output))))
}
/// Creates a new [`Task`] that runs the given [`widget::Operation`] and produces
/// its output.
pub fn widget(operation: impl widget::Operation<T> + 'static) -> Task<T>
where
T: MaybeSend + 'static,
{
Self::channel(move |sender| {
let operation =
widget::operation::map(Box::new(operation), move |value| {
let _ = sender.clone().try_send(value);
});
Action::Widget(Box::new(operation))
})
}
/// Creates a new [`Task`] that executes the [`Action`] returned by the closure and
/// produces the value fed to the [`oneshot::Sender`].
pub fn oneshot(f: impl FnOnce(oneshot::Sender<T>) -> Action<T>) -> Task<T>
where
T: MaybeSend + 'static,
{
let (sender, receiver) = oneshot::channel();
let action = f(sender);
Self(Some(boxed_stream(
stream::once(async move { action }).chain(
receiver.into_stream().filter_map(|result| async move {
Some(Action::Output(result.ok()?))
}),
),
)))
}
/// Creates a new [`Task`] that executes the [`Action`] returned by the closure and
/// produces the values fed to the [`mpsc::Sender`].
pub fn channel(f: impl FnOnce(mpsc::Sender<T>) -> Action<T>) -> Task<T>
where
T: MaybeSend + 'static,
{
let (sender, receiver) = mpsc::channel(1);
let action = f(sender);
Self(Some(boxed_stream(
stream::once(async move { action })
.chain(receiver.map(|result| Action::Output(result))),
)))
}
/// Creates a new [`Task`] that executes the given [`Action`] and produces no output.
pub fn effect(action: impl Into<Action<Never>>) -> Self {
let action = action.into();
Self(Some(boxed_stream(stream::once(async move {
action.output().expect_err("no output")
}))))
}
/// Maps the output of a [`Task`] with the given closure.
pub fn map<O>(
self,
mut f: impl FnMut(T) -> O + MaybeSend + 'static,
) -> Task<O>
where
T: MaybeSend + 'static,
O: MaybeSend + 'static,
{
self.then(move |output| Task::done(f(output)))
}
/// Performs a new [`Task`] for every output of the current [`Task`] using the
/// given closure.
///
/// This is the monadic interface of [`Task`]—analogous to [`Future`] and
/// [`Stream`].
pub fn then<O>(
self,
mut f: impl FnMut(T) -> Task<O> + MaybeSend + 'static,
) -> Task<O>
where
T: MaybeSend + 'static,
O: MaybeSend + 'static,
{
Task(match self.0 {
None => None,
Some(stream) => {
Some(boxed_stream(stream.flat_map(move |action| {
match action.output() {
Ok(output) => f(output)
.0
.unwrap_or_else(|| boxed_stream(stream::empty())),
Err(action) => {
boxed_stream(stream::once(async move { action }))
}
}
})))
}
})
}
/// Chains a new [`Task`] to be performed once the current one finishes completely.
pub fn chain(self, task: Self) -> Self
where
T: 'static,
{
match self.0 {
None => task,
Some(first) => match task.0 {
None => Task::none(),
Some(second) => Task(Some(boxed_stream(first.chain(second)))),
},
}
}
/// Creates a [`Task`] that runs the given [`Future`] to completion.
pub fn perform<A>(
future: impl Future<Output = A> + MaybeSend + 'static,
f: impl Fn(A) -> T + MaybeSend + 'static,
) -> Self
where
T: MaybeSend + 'static,
A: MaybeSend + 'static,
{
Self::future(future.map(f))
}
/// Creates a [`Task`] that runs the given [`Stream`] to completion.
pub fn run<A>(
stream: impl Stream<Item = A> + MaybeSend + 'static,
f: impl Fn(A) -> T + 'static + MaybeSend,
) -> Self
where
T: 'static,
{
Self::stream(stream.map(f))
}
/// Combines the given tasks and produces a single [`Task`] that will run all of them
/// in parallel.
pub fn batch(tasks: impl IntoIterator<Item = Self>) -> Self
where
T: 'static,
{
Self(Some(boxed_stream(stream::select_all(
tasks.into_iter().filter_map(|task| task.0),
))))
}
/// Returns the underlying [`Stream`] of the [`Task`].
pub fn into_stream(self) -> Option<BoxStream<Action<T>>> {
self.0
}
}
impl<T> From<()> for Task<T>
where
T: MaybeSend + 'static,
{
fn from(_value: ()) -> Self {
Self::none()
}
}

2
runtime/src/user_interface.rs
View file

@ -566,7 +566,7 @@ where
pub fn operate(
&mut self,
renderer: &Renderer,
operation: &mut dyn widget::Operation<Message>,
operation: &mut dyn widget::Operation<()>,
) {
self.root.as_widget().operate(
&mut self.state,

295
runtime/src/window.rs
View file

@ -1,24 +1,145 @@
//! Build window-based GUI applications.
mod action;
pub mod screenshot;
pub use action::Action;
pub use screenshot::Screenshot;
use crate::command::{self, Command};
use crate::core::time::Instant;
use crate::core::window::{
Event, Icon, Id, Level, Mode, Settings, UserAttention,
};
use crate::core::{Point, Size};
use crate::core::{MaybeSend, Point, Size};
use crate::futures::event;
use crate::futures::futures::channel::oneshot;
use crate::futures::Subscription;
use crate::Task;
pub use raw_window_handle;
use raw_window_handle::WindowHandle;
/// An operation to be performed on some window.
#[allow(missing_debug_implementations)]
pub enum Action {
/// Opens a new window with some [`Settings`].
Open(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(Id),
/// Resize the window to the given logical dimensions.
Resize(Id, Size),
/// Fetch the current logical dimensions of the window.
FetchSize(Id, oneshot::Sender<Size>),
/// Fetch if the current window is maximized or not.
FetchMaximized(Id, oneshot::Sender<bool>),
/// Set the window to maximized or back
Maximize(Id, bool),
/// Fetch if the current window is minimized or not.
///
/// ## Platform-specific
/// - **Wayland:** Always `None`.
FetchMinimized(Id, oneshot::Sender<Option<bool>>),
/// Set the window to minimized or back
Minimize(Id, bool),
/// Fetch the current logical coordinates of the window.
FetchPosition(Id, oneshot::Sender<Option<Point>>),
/// Move the window to the given logical coordinates.
///
/// Unsupported on Wayland.
Move(Id, Point),
/// Change the [`Mode`] of the window.
ChangeMode(Id, Mode),
/// Fetch the current [`Mode`] of the window.
FetchMode(Id, oneshot::Sender<Mode>),
/// Toggle the window to maximized or back
ToggleMaximize(Id),
/// Toggle whether window has decorations.
///
/// ## Platform-specific
/// - **X11:** Not implemented.
/// - **Web:** Unsupported.
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.
///
/// 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.
///
/// ## Platform-specific
///
/// - **iOS / Android / Web:** Unsupported.
/// - **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(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.
///
/// This method 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.
///
/// ## Platform-specific
///
/// - **Web / Wayland:** Unsupported.
GainFocus(Id),
/// Change the window [`Level`].
ChangeLevel(Id, Level),
/// Show the system menu at cursor position.
///
/// ## Platform-specific
/// Android / iOS / macOS / Orbital / Web / X11: Unsupported.
ShowSystemMenu(Id),
/// Fetch the raw identifier unique to the window.
FetchRawId(Id, oneshot::Sender<u64>),
/// Change the window [`Icon`].
///
/// On Windows and X11, this is typically the small icon in the top-left
/// corner of the titlebar.
///
/// ## Platform-specific
///
/// - **Web / Wayland / macOS:** Unsupported.
///
/// - **Windows:** Sets `ICON_SMALL`. The base size for a window icon is 16x16, but it's
/// recommended to account for screen scaling and pick a multiple of that, i.e. 32x32.
///
/// - **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(Id, Icon),
/// Runs the closure with the native window handle of the window with the given [`Id`].
RunWithHandle(Id, Box<dyn FnOnce(WindowHandle<'_>) + Send>),
/// Screenshot the viewport of the window.
Screenshot(Id, oneshot::Sender<Screenshot>),
}
/// Subscribes to the frames of the window of the running application.
///
/// The resulting [`Subscription`] will produce items at a rate equal to the
@ -34,110 +155,96 @@ pub fn frames() -> Subscription<Instant> {
})
}
/// Spawns a new window with the given `settings`.
/// Opens a new window with the given `settings`.
///
/// Returns the new window [`Id`] alongside the [`Command`].
pub fn spawn<Message>(settings: Settings) -> (Id, Command<Message>) {
/// Returns the new window [`Id`] alongside the [`Task`].
pub fn open<T>(settings: Settings) -> (Id, Task<T>) {
let id = Id::unique();
(
id,
Command::single(command::Action::Window(Action::Spawn(id, settings))),
Task::effect(crate::Action::Window(Action::Open(id, settings))),
)
}
/// Closes the window with `id`.
pub fn close<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::Close(id)))
pub fn close<T>(id: Id) -> Task<T> {
Task::effect(crate::Action::Window(Action::Close(id)))
}
/// Begins dragging the window while the left mouse button is held.
pub fn drag<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::Drag(id)))
pub fn drag<T>(id: Id) -> Task<T> {
Task::effect(crate::Action::Window(Action::Drag(id)))
}
/// Resizes the window to the given logical dimensions.
pub fn resize<Message>(id: Id, new_size: Size) -> Command<Message> {
Command::single(command::Action::Window(Action::Resize(id, new_size)))
pub fn resize<T>(id: Id, new_size: Size) -> Task<T> {
Task::effect(crate::Action::Window(Action::Resize(id, new_size)))
}
/// Fetches the window's size in logical dimensions.
pub fn fetch_size<Message>(
id: Id,
f: impl FnOnce(Size) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(Action::FetchSize(id, Box::new(f))))
pub fn fetch_size(id: Id) -> Task<Size> {
Task::oneshot(move |channel| {
crate::Action::Window(Action::FetchSize(id, channel))
})
}
/// Fetches if the window is maximized.
pub fn fetch_maximized<Message>(
id: Id,
f: impl FnOnce(bool) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(Action::FetchMaximized(
id,
Box::new(f),
)))
pub fn fetch_maximized(id: Id) -> Task<bool> {
Task::oneshot(move |channel| {
crate::Action::Window(Action::FetchMaximized(id, channel))
})
}
/// Maximizes the window.
pub fn maximize<Message>(id: Id, maximized: bool) -> Command<Message> {
Command::single(command::Action::Window(Action::Maximize(id, maximized)))
pub fn maximize<T>(id: Id, maximized: bool) -> Task<T> {
Task::effect(crate::Action::Window(Action::Maximize(id, maximized)))
}
/// Fetches if the window is minimized.
pub fn fetch_minimized<Message>(
id: Id,
f: impl FnOnce(Option<bool>) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(Action::FetchMinimized(
id,
Box::new(f),
)))
pub fn fetch_minimized(id: Id) -> Task<Option<bool>> {
Task::oneshot(move |channel| {
crate::Action::Window(Action::FetchMinimized(id, channel))
})
}
/// Minimizes the window.
pub fn minimize<Message>(id: Id, minimized: bool) -> Command<Message> {
Command::single(command::Action::Window(Action::Minimize(id, minimized)))
pub fn minimize<T>(id: Id, minimized: bool) -> Task<T> {
Task::effect(crate::Action::Window(Action::Minimize(id, minimized)))
}
/// Fetches the current window position in logical coordinates.
pub fn fetch_position<Message>(
id: Id,
f: impl FnOnce(Option<Point>) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(Action::FetchPosition(
id,
Box::new(f),
)))
pub fn fetch_position(id: Id) -> Task<Option<Point>> {
Task::oneshot(move |channel| {
crate::Action::Window(Action::FetchPosition(id, channel))
})
}
/// Moves the window to the given logical coordinates.
pub fn move_to<Message>(id: Id, position: Point) -> Command<Message> {
Command::single(command::Action::Window(Action::Move(id, position)))
pub fn move_to<T>(id: Id, position: Point) -> Task<T> {
Task::effect(crate::Action::Window(Action::Move(id, position)))
}
/// Changes the [`Mode`] of the window.
pub fn change_mode<Message>(id: Id, mode: Mode) -> Command<Message> {
Command::single(command::Action::Window(Action::ChangeMode(id, mode)))
pub fn change_mode<T>(id: Id, mode: Mode) -> Task<T> {
Task::effect(crate::Action::Window(Action::ChangeMode(id, mode)))
}
/// Fetches the current [`Mode`] of the window.
pub fn fetch_mode<Message>(
id: Id,
f: impl FnOnce(Mode) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(Action::FetchMode(id, Box::new(f))))
pub fn fetch_mode(id: Id) -> Task<Mode> {
Task::oneshot(move |channel| {
crate::Action::Window(Action::FetchMode(id, channel))
})
}
/// Toggles the window to maximized or back.
pub fn toggle_maximize<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::ToggleMaximize(id)))
pub fn toggle_maximize<T>(id: Id) -> Task<T> {
Task::effect(crate::Action::Window(Action::ToggleMaximize(id)))
}
/// Toggles the window decorations.
pub fn toggle_decorations<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::ToggleDecorations(id)))
pub fn toggle_decorations<T>(id: Id) -> Task<T> {
Task::effect(crate::Action::Window(Action::ToggleDecorations(id)))
}
/// Request user attention to the window. This has no effect if the application
@ -146,11 +253,11 @@ pub fn toggle_decorations<Message>(id: 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>(
pub fn request_user_attention<T>(
id: Id,
user_attention: Option<UserAttention>,
) -> Command<Message> {
Command::single(command::Action::Window(Action::RequestUserAttention(
) -> Task<T> {
Task::effect(crate::Action::Window(Action::RequestUserAttention(
id,
user_attention,
)))
@ -159,59 +266,61 @@ pub fn request_user_attention<Message>(
/// Brings the window to the front and sets input focus. Has no effect if the window is
/// already in focus, minimized, or not visible.
///
/// This [`Command`] steals input focus from other applications. Do not use this method unless
/// This [`Task`] 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: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::GainFocus(id)))
pub fn gain_focus<T>(id: Id) -> Task<T> {
Task::effect(crate::Action::Window(Action::GainFocus(id)))
}
/// Changes the window [`Level`].
pub fn change_level<Message>(id: Id, level: Level) -> Command<Message> {
Command::single(command::Action::Window(Action::ChangeLevel(id, level)))
pub fn change_level<T>(id: Id, level: Level) -> Task<T> {
Task::effect(crate::Action::Window(Action::ChangeLevel(id, level)))
}
/// Show the [system menu] at cursor position.
///
/// [system menu]: https://en.wikipedia.org/wiki/Common_menus_in_Microsoft_Windows#System_menu
pub fn show_system_menu<Message>(id: Id) -> Command<Message> {
Command::single(command::Action::Window(Action::ShowSystemMenu(id)))
pub fn show_system_menu<T>(id: Id) -> Task<T> {
Task::effect(crate::Action::Window(Action::ShowSystemMenu(id)))
}
/// Fetches an identifier unique to the window, provided by the underlying windowing system. This is
/// not to be confused with [`Id`].
pub fn fetch_id<Message>(
id: Id,
f: impl FnOnce(u64) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(Action::FetchId(id, Box::new(f))))
pub fn fetch_raw_id<Message>(id: Id) -> Task<u64> {
Task::oneshot(|channel| {
crate::Action::Window(Action::FetchRawId(id, channel))
})
}
/// Changes the [`Icon`] of the window.
pub fn change_icon<Message>(id: Id, icon: Icon) -> Command<Message> {
Command::single(command::Action::Window(Action::ChangeIcon(id, icon)))
pub fn change_icon<T>(id: Id, icon: Icon) -> Task<T> {
Task::effect(crate::Action::Window(Action::ChangeIcon(id, icon)))
}
/// Runs the given callback with the native window handle for the window with the given id.
///
/// Note that if the window closes before this call is processed the callback will not be run.
pub fn run_with_handle<Message>(
pub fn run_with_handle<T>(
id: Id,
f: impl FnOnce(WindowHandle<'_>) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(Action::RunWithHandle(
id,
Box::new(f),
)))
f: impl FnOnce(WindowHandle<'_>) -> T + MaybeSend + 'static,
) -> Task<T>
where
T: MaybeSend + 'static,
{
Task::oneshot(move |channel| {
crate::Action::Window(Action::RunWithHandle(
id,
Box::new(move |handle| {
let _ = channel.send(f(handle));
}),
))
})
}
/// Captures a [`Screenshot`] from the window.
pub fn screenshot<Message>(
id: Id,
f: impl FnOnce(Screenshot) -> Message + Send + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(Action::Screenshot(
id,
Box::new(f),
)))
pub fn screenshot(id: Id) -> Task<Screenshot> {
Task::oneshot(move |channel| {
crate::Action::Window(Action::Screenshot(id, channel))
})
}

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

@ -1,230 +0,0 @@
use crate::core::window::{Icon, Id, Level, Mode, Settings, UserAttention};
use crate::core::{Point, Size};
use crate::futures::MaybeSend;
use crate::window::Screenshot;
use raw_window_handle::WindowHandle;
use std::fmt;
/// An operation to be performed on some window.
pub enum Action<T> {
/// 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(Id),
/// Resize the window to the given logical dimensions.
Resize(Id, Size),
/// Fetch the current logical dimensions of the window.
FetchSize(Id, Box<dyn FnOnce(Size) -> T + 'static>),
/// Fetch if the current window is maximized or not.
///
/// ## Platform-specific
/// - **iOS / Android / Web:** Unsupported.
FetchMaximized(Id, Box<dyn FnOnce(bool) -> T + 'static>),
/// Set the window to maximized or back
Maximize(Id, bool),
/// Fetch if the current window is minimized or not.
///
/// ## Platform-specific
/// - **Wayland:** Always `None`.
/// - **iOS / Android / Web:** Unsupported.
FetchMinimized(Id, Box<dyn FnOnce(Option<bool>) -> T + 'static>),
/// Set the window to minimized or back
Minimize(Id, bool),
/// Fetch the current logical coordinates of the window.
FetchPosition(Id, Box<dyn FnOnce(Option<Point>) -> T + 'static>),
/// Move the window to the given logical coordinates.
///
/// Unsupported on Wayland.
Move(Id, Point),
/// Change the [`Mode`] of the window.
ChangeMode(Id, Mode),
/// Fetch the current [`Mode`] of the window.
FetchMode(Id, Box<dyn FnOnce(Mode) -> T + 'static>),
/// Toggle the window to maximized or back
ToggleMaximize(Id),
/// Toggle whether window has decorations.
///
/// ## Platform-specific
/// - **X11:** Not implemented.
/// - **Web:** Unsupported.
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.
///
/// 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.
///
/// ## Platform-specific
///
/// - **iOS / Android / Web:** Unsupported.
/// - **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(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.
///
/// This method 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.
///
/// ## Platform-specific
///
/// - **Web / Wayland:** Unsupported.
GainFocus(Id),
/// Change the window [`Level`].
ChangeLevel(Id, Level),
/// Show the system menu at cursor position.
///
/// ## Platform-specific
/// Android / iOS / macOS / Orbital / Web / X11: Unsupported.
ShowSystemMenu(Id),
/// 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
/// corner of the titlebar.
///
/// ## Platform-specific
///
/// - **Web / Wayland / macOS:** Unsupported.
///
/// - **Windows:** Sets `ICON_SMALL`. The base size for a window icon is 16x16, but it's
/// recommended to account for screen scaling and pick a multiple of that, i.e. 32x32.
///
/// - **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(Id, Icon),
/// Runs the closure with the native window handle of the window with the given [`Id`].
RunWithHandle(Id, Box<dyn FnOnce(WindowHandle<'_>) -> T + 'static>),
/// Screenshot the viewport of the window.
Screenshot(Id, Box<dyn FnOnce(Screenshot) -> T + 'static>),
}
impl<T> Action<T> {
/// Maps the output of a window [`Action`] using the provided closure.
pub fn map<A>(
self,
f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
) -> Action<A>
where
T: 'static,
{
match self {
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::FetchMaximized(id, o) => {
Action::FetchMaximized(id, Box::new(move |s| f(o(s))))
}
Self::Maximize(id, maximized) => Action::Maximize(id, maximized),
Self::FetchMinimized(id, o) => {
Action::FetchMinimized(id, Box::new(move |s| f(o(s))))
}
Self::Minimize(id, minimized) => Action::Minimize(id, minimized),
Self::FetchPosition(id, o) => {
Action::FetchPosition(id, Box::new(move |s| f(o(s))))
}
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::ShowSystemMenu(id) => Action::ShowSystemMenu(id),
Self::FetchId(id, o) => {
Action::FetchId(id, Box::new(move |s| f(o(s))))
}
Self::ChangeIcon(id, icon) => Action::ChangeIcon(id, icon),
Self::RunWithHandle(id, o) => {
Action::RunWithHandle(id, Box::new(move |s| f(o(s))))
}
Self::Screenshot(id, tag) => Action::Screenshot(
id,
Box::new(move |screenshot| f(tag(screenshot))),
),
}
}
}
impl<T> fmt::Debug for Action<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
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::FetchMaximized(id, _) => {
write!(f, "Action::FetchMaximized({id:?})")
}
Self::Maximize(id, maximized) => {
write!(f, "Action::Maximize({id:?}, {maximized})")
}
Self::FetchMinimized(id, _) => {
write!(f, "Action::FetchMinimized({id:?})")
}
Self::Minimize(id, minimized) => {
write!(f, "Action::Minimize({id:?}, {minimized}")
}
Self::FetchPosition(id, _) => {
write!(f, "Action::FetchPosition({id:?})")
}
Self::Move(id, position) => {
write!(f, "Action::Move({id:?}, {position})")
}
Self::ChangeMode(id, mode) => {
write!(f, "Action::SetMode({id:?}, {mode:?})")
}
Self::FetchMode(id, _) => write!(f, "Action::FetchMode({id:?})"),
Self::ToggleMaximize(id) => {
write!(f, "Action::ToggleMaximize({id:?})")
}
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::ShowSystemMenu(id) => {
write!(f, "Action::ShowSystemMenu({id:?})")
}
Self::FetchId(id, _) => write!(f, "Action::FetchId({id:?})"),
Self::ChangeIcon(id, _icon) => {
write!(f, "Action::ChangeIcon({id:?})")
}
Self::RunWithHandle(id, _) => {
write!(f, "Action::RunWithHandle({id:?})")
}
Self::Screenshot(id, _) => write!(f, "Action::Screenshot({id:?})"),
}
}
}