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

Merge branch 'master' into beacon

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2025-03-04 19:11:37 +01:00
commit 8bd5de72ea
No known key found for this signature in database
GPG key ID: 7CC46565708259A7
371 changed files with 33138 additions and 12950 deletions
Download patch file Download diff file Expand all files Collapse all files

6
runtime/Cargo.toml
View file

@ -13,9 +13,6 @@ keywords.workspace = true
[lints]
workspace = true
[features]
multi-window = []
[dependencies]
bytes.workspace = true
iced_core.workspace = true
@ -24,5 +21,6 @@ iced_debug.workspace = true
iced_futures.workspace = true
iced_futures.features = ["thread-pool"]
thiserror.workspace = true
raw-window-handle.workspace = true
sipper.workspace = true
thiserror.workspace = true

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::{self, 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"),
}
}
}

13
runtime/src/font.rs
View file

@ -1,7 +1,6 @@
//! Load and use fonts.
pub use iced_core::font::*;
use crate::command::{self, Command};
use crate::Action;
use crate::task::{self, Task};
use std::borrow::Cow;
/// An error while loading a font.
@ -9,11 +8,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,
})
}

102
runtime/src/lib.rs
View file

@ -4,29 +4,113 @@
//!
//! `iced_runtime` takes [`iced_core`] and builds a native runtime on top of it.
//!
//! [`iced_core`]: https://github.com/iced-rs/iced/tree/0.12/core
//! [`iced_core`]: https://github.com/iced-rs/iced/tree/0.13/core
#![doc(
html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
)]
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
pub mod clipboard;
pub mod command;
pub mod font;
pub mod keyboard;
pub mod overlay;
pub mod program;
pub mod system;
pub mod task;
pub mod user_interface;
pub mod window;
#[cfg(feature = "multi-window")]
pub mod multi_window;
pub use iced_core as core;
pub use iced_debug as debug;
pub use iced_futures as futures;
pub use command::Command;
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>),
/// Run a clipboard action.
Clipboard(clipboard::Action),
/// Run a window action.
Window(window::Action),
/// Run a system action.
System(system::Action),
/// Exits the runtime.
///
/// This will normally close any application windows and
/// terminate the runtime loop.
Exit,
}
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)),
Action::Exit => Err(Action::Exit),
}
}
}
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:?})"),
Action::Exit => write!(f, "Action::Exit"),
}
}
}
/// Creates a [`Task`] that exits the iced runtime.
///
/// This will normally close any application windows and
/// terminate the runtime loop.
pub fn exit<T>() -> Task<T> {
task::effect(Action::Exit)
}

35
runtime/src/multi_window.rs
View file

@ -1,35 +0,0 @@
//! A multi-window application.
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 {
/// The graphics backend to use to draw the [`Program`].
type Renderer: Renderer + text::Renderer;
/// The type of __messages__ your [`Program`] will produce.
type Message: std::fmt::Debug + Send;
/// The theme used to draw the [`Program`].
type Theme;
/// Handles a __message__ and updates the state of the [`Program`].
///
/// This is where you define your __update logic__. All the __messages__,
/// produced by either user interactions or commands, will be handled by
/// this method.
///
/// Any [`Command`] returned will be executed immediately in the
/// background by shells.
fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
/// Returns the widgets to display in the [`Program`] for the `window`.
///
/// These widgets can produce __messages__ based on user interaction.
fn view(
&self,
window: window::Id,
) -> Element<'_, Self::Message, Self::Theme, Self::Renderer>;
}

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

@ -1,35 +0,0 @@
//! Build interactive programs using The Elm Architecture.
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 {
/// The graphics backend to use to draw the [`Program`].
type Renderer: Renderer + text::Renderer;
/// The type of __messages__ your [`Program`] will produce.
type Message: std::fmt::Debug + Send;
/// The theme used to draw the [`Program`].
type Theme;
/// Handles a __message__ and updates the state of the [`Program`].
///
/// This is where you define your __update logic__. All the __messages__,
/// produced by either user interactions or commands, will be handled by
/// this method.
///
/// Any [`Command`] returned will be executed immediately in the
/// background by shells.
fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
/// Returns the widgets to display in the [`Program`] for the `window`.
///
/// These widgets can produce __messages__ based on user interaction.
fn view(
&self,
window: window::Id,
) -> Element<'_, Self::Message, Self::Theme, Self::Renderer>;
}

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

@ -1,264 +0,0 @@
//! The internal state of a multi-window [`Program`].
use crate::core::event::{self, Event};
use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget::operation::{self, Operation};
use crate::core::{Clipboard, Size};
use crate::debug;
use crate::user_interface::{self, UserInterface};
use crate::{Command, Program};
/// The execution state of a multi-window [`Program`]. It leverages caching, event
/// processing, and rendering primitive storage.
#[allow(missing_debug_implementations)]
pub struct State<P>
where
P: Program + 'static,
{
program: P,
caches: Option<Vec<user_interface::Cache>>,
queued_events: Vec<Event>,
queued_messages: Vec<P::Message>,
mouse_interaction: mouse::Interaction,
}
impl<P> State<P>
where
P: Program + 'static,
{
/// Creates a new [`State`] with the provided [`Program`], initializing its
/// primitive with the given logical bounds and renderer.
pub fn new(program: P, bounds: Size, renderer: &mut P::Renderer) -> Self {
let user_interface = build_user_interface(
&program,
user_interface::Cache::default(),
renderer,
bounds,
);
let caches = Some(vec![user_interface.into_cache()]);
State {
program,
caches,
queued_events: Vec::new(),
queued_messages: Vec::new(),
mouse_interaction: mouse::Interaction::None,
}
}
/// Returns a reference to the [`Program`] of the [`State`].
pub fn program(&self) -> &P {
&self.program
}
/// Queues an event in the [`State`] for processing during an [`update`].
///
/// [`update`]: Self::update
pub fn queue_event(&mut self, event: Event) {
self.queued_events.push(event);
}
/// Queues a message in the [`State`] for processing during an [`update`].
///
/// [`update`]: Self::update
pub fn queue_message(&mut self, message: P::Message) {
self.queued_messages.push(message);
}
/// Returns whether the event queue of the [`State`] is empty or not.
pub fn is_queue_empty(&self) -> bool {
self.queued_events.is_empty() && self.queued_messages.is_empty()
}
/// Returns the current [`mouse::Interaction`] of the [`State`].
pub fn mouse_interaction(&self) -> mouse::Interaction {
self.mouse_interaction
}
/// Processes all the queued events and messages, rebuilding and redrawing
/// the widgets of the linked [`Program`] if necessary.
///
/// Returns a list containing the instances of [`Event`] that were not
/// captured by any widget, and the [`Command`] obtained from [`Program`]
/// after updating it, only if an update was necessary.
pub fn update(
&mut self,
bounds: Size,
cursor: mouse::Cursor,
renderer: &mut P::Renderer,
theme: &P::Theme,
style: &renderer::Style,
clipboard: &mut dyn Clipboard,
) -> (Vec<Event>, Option<Command<P::Message>>) {
let mut user_interfaces = build_user_interfaces(
&self.program,
self.caches.take().unwrap(),
renderer,
bounds,
);
let mut messages = Vec::new();
let uncaptured_events = user_interfaces.iter_mut().fold(
vec![],
|mut uncaptured_events, ui| {
let interact_timer = debug::interact_time();
let (_, event_statuses) = ui.update(
&self.queued_events,
cursor,
renderer,
clipboard,
&mut messages,
);
interact_timer.finish();
uncaptured_events.extend(
self.queued_events
.iter()
.zip(event_statuses)
.filter_map(|(event, status)| {
matches!(status, event::Status::Ignored)
.then_some(event)
})
.cloned(),
);
uncaptured_events
},
);
self.queued_events.clear();
messages.append(&mut self.queued_messages);
let commands = if messages.is_empty() {
let draw_timer = debug::draw_time();
for ui in &mut user_interfaces {
self.mouse_interaction =
ui.draw(renderer, theme, style, cursor);
}
drop(draw_timer);
self.caches = Some(
user_interfaces
.drain(..)
.map(UserInterface::into_cache)
.collect(),
);
None
} else {
let temp_caches = user_interfaces
.drain(..)
.map(UserInterface::into_cache)
.collect();
drop(user_interfaces);
let commands = Command::batch(messages.into_iter().map(|msg| {
debug::log_message(&msg);
let update_timer = debug::update_time();
let command = self.program.update(msg);
drop(update_timer);
command
}));
let mut user_interfaces = build_user_interfaces(
&self.program,
temp_caches,
renderer,
bounds,
);
let draw_timer = debug::draw_time();
for ui in &mut user_interfaces {
self.mouse_interaction =
ui.draw(renderer, theme, style, cursor);
}
drop(draw_timer);
self.caches = Some(
user_interfaces
.drain(..)
.map(UserInterface::into_cache)
.collect(),
);
Some(commands)
};
(uncaptured_events, commands)
}
/// Applies widget [`Operation`]s to the [`State`].
pub fn operate(
&mut self,
renderer: &mut P::Renderer,
operations: impl Iterator<Item = Box<dyn Operation<P::Message>>>,
bounds: Size,
) {
let mut user_interfaces = build_user_interfaces(
&self.program,
self.caches.take().unwrap(),
renderer,
bounds,
);
for operation in operations {
let mut current_operation = Some(operation);
while let Some(mut operation) = current_operation.take() {
for ui in &mut user_interfaces {
ui.operate(renderer, operation.as_mut());
}
match operation.finish() {
operation::Outcome::None => {}
operation::Outcome::Some(message) => {
self.queued_messages.push(message);
}
operation::Outcome::Chain(next) => {
current_operation = Some(next);
}
};
}
}
self.caches = Some(
user_interfaces
.drain(..)
.map(UserInterface::into_cache)
.collect(),
);
}
}
fn build_user_interfaces<'a, P: Program>(
program: &'a P,
mut caches: Vec<user_interface::Cache>,
renderer: &mut P::Renderer,
size: Size,
) -> Vec<UserInterface<'a, P::Message, P::Theme, P::Renderer>> {
caches
.drain(..)
.map(|cache| build_user_interface(program, cache, renderer, size))
.collect()
}
fn build_user_interface<'a, P: Program>(
program: &'a P,
cache: user_interface::Cache,
renderer: &mut P::Renderer,
size: Size,
) -> UserInterface<'a, P::Message, P::Theme, P::Renderer> {
let view_timer = debug::view_time();
let view = program.view();
drop(view_timer);
let layout_timer = debug::layout_time();
let user_interface = UserInterface::build(view, size, cache, renderer);
drop(layout_timer);
user_interface
}

84
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,
{
@ -158,48 +158,47 @@ where
}
/// Processes a runtime [`Event`].
pub fn on_event(
pub fn update(
&mut self,
event: Event,
event: &Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) -> event::Status {
) {
fn recurse<Message, Theme, Renderer>(
element: &mut overlay::Element<'_, Message, Theme, Renderer>,
layout: Layout<'_>,
event: Event,
event: &Event,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) -> (event::Status, bool)
) -> bool
where
Renderer: renderer::Renderer,
{
let mut layouts = layout.children();
if let Some(layout) = layouts.next() {
let (nested_status, nested_is_over) =
if let Some((mut nested, nested_layout)) =
element.overlay(layout, renderer).zip(layouts.next())
{
recurse(
&mut nested,
nested_layout,
event.clone(),
cursor,
renderer,
clipboard,
shell,
)
} else {
(event::Status::Ignored, false)
};
let nested_is_over = if let Some((mut nested, nested_layout)) =
element.overlay(layout, renderer).zip(layouts.next())
{
recurse(
&mut nested,
nested_layout,
event,
cursor,
renderer,
clipboard,
shell,
)
} else {
false
};
if matches!(nested_status, event::Status::Ignored) {
if shell.event_status() == event::Status::Ignored {
let is_over = nested_is_over
|| cursor
.position()
@ -212,30 +211,29 @@ where
})
.unwrap_or_default();
(
element.on_event(
event,
layout,
if nested_is_over {
mouse::Cursor::Unavailable
} else {
cursor
},
renderer,
clipboard,
shell,
),
is_over,
)
element.update(
event,
layout,
if nested_is_over {
mouse::Cursor::Unavailable
} else {
cursor
},
renderer,
clipboard,
shell,
);
is_over
} else {
(nested_status, nested_is_over)
nested_is_over
}
} else {
(event::Status::Ignored, false)
false
}
}
let (status, _) = recurse(
let _ = recurse(
&mut self.overlay,
layout,
event,
@ -244,8 +242,6 @@ where
clipboard,
shell,
);
status
}
/// Returns the current [`mouse::Interaction`] of the [`Nested`] overlay.

36
runtime/src/program.rs
View file

@ -1,36 +0,0 @@
//! Build interactive programs using The Elm Architecture.
use crate::Command;
use iced_core::text;
use iced_core::Element;
mod state;
pub use state::State;
/// The core of a user interface application following The Elm Architecture.
pub trait Program: Sized {
/// The graphics backend to use to draw the [`Program`].
type Renderer: text::Renderer;
/// The theme used to draw the [`Program`].
type Theme;
/// The type of __messages__ your [`Program`] will produce.
type Message: std::fmt::Debug + Send;
/// Handles a __message__ and updates the state of the [`Program`].
///
/// This is where you define your __update logic__. All the __messages__,
/// produced by either user interactions or commands, will be handled by
/// this method.
///
/// Any [`Command`] returned will be executed immediately in the
/// background by shells.
fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
/// Returns the widgets to display in the [`Program`].
///
/// These widgets can produce __messages__ based on user interaction.
fn view(&self) -> Element<'_, Self::Message, Self::Theme, Self::Renderer>;
}

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

@ -1,224 +0,0 @@
use crate::core::event::{self, Event};
use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget::operation::{self, Operation};
use crate::core::window;
use crate::core::{Clipboard, Size};
use crate::debug;
use crate::user_interface::{self, UserInterface};
use crate::{Command, Program};
/// The execution state of a [`Program`]. It leverages caching, event
/// processing, and rendering primitive storage.
#[allow(missing_debug_implementations)]
pub struct State<P>
where
P: Program + 'static,
{
program: P,
cache: Option<user_interface::Cache>,
queued_events: Vec<Event>,
queued_messages: Vec<P::Message>,
mouse_interaction: mouse::Interaction,
}
impl<P> State<P>
where
P: Program + 'static,
{
/// Creates a new [`State`] with the provided [`Program`], initializing its
/// primitive with the given logical bounds and renderer.
pub fn new(
mut program: P,
bounds: Size,
renderer: &mut P::Renderer,
) -> Self {
let user_interface = build_user_interface(
&mut program,
user_interface::Cache::default(),
renderer,
bounds,
);
let cache = Some(user_interface.into_cache());
State {
program,
cache,
queued_events: Vec::new(),
queued_messages: Vec::new(),
mouse_interaction: mouse::Interaction::None,
}
}
/// Returns a reference to the [`Program`] of the [`State`].
pub fn program(&self) -> &P {
&self.program
}
/// Queues an event in the [`State`] for processing during an [`update`].
///
/// [`update`]: Self::update
pub fn queue_event(&mut self, event: Event) {
self.queued_events.push(event);
}
/// Queues a message in the [`State`] for processing during an [`update`].
///
/// [`update`]: Self::update
pub fn queue_message(&mut self, message: P::Message) {
self.queued_messages.push(message);
}
/// Returns whether the event queue of the [`State`] is empty or not.
pub fn is_queue_empty(&self) -> bool {
self.queued_events.is_empty() && self.queued_messages.is_empty()
}
/// Returns the current [`mouse::Interaction`] of the [`State`].
pub fn mouse_interaction(&self) -> mouse::Interaction {
self.mouse_interaction
}
/// Processes all the queued events and messages, rebuilding and redrawing
/// the widgets of the linked [`Program`] if necessary.
///
/// Returns a list containing the instances of [`Event`] that were not
/// captured by any widget, and the [`Command`] obtained from [`Program`]
/// after updating it, only if an update was necessary.
pub fn update(
&mut self,
bounds: Size,
cursor: mouse::Cursor,
renderer: &mut P::Renderer,
theme: &P::Theme,
style: &renderer::Style,
clipboard: &mut dyn Clipboard,
) -> (Vec<Event>, Option<Command<P::Message>>) {
let mut user_interface = build_user_interface(
&mut self.program,
self.cache.take().unwrap(),
renderer,
bounds,
);
let interact_span = debug::interact(window::Id::MAIN);
let mut messages = Vec::new();
let (_, event_statuses) = user_interface.update(
&self.queued_events,
cursor,
renderer,
clipboard,
&mut messages,
);
let uncaptured_events = self
.queued_events
.iter()
.zip(event_statuses)
.filter_map(|(event, status)| {
matches!(status, event::Status::Ignored).then_some(event)
})
.cloned()
.collect();
self.queued_events.clear();
messages.append(&mut self.queued_messages);
interact_span.finish();
let command = if messages.is_empty() {
let draw_span = debug::draw(window::Id::MAIN);
self.mouse_interaction =
user_interface.draw(renderer, theme, style, cursor);
draw_span.finish();
self.cache = Some(user_interface.into_cache());
None
} else {
// When there are messages, we are forced to rebuild twice
// for now :^)
let temp_cache = user_interface.into_cache();
let commands =
Command::batch(messages.into_iter().map(|message| {
let update_span = debug::update(&message);
let command = self.program.update(message);
update_span.finish();
command
}));
let mut user_interface = build_user_interface(
&mut self.program,
temp_cache,
renderer,
bounds,
);
let draw_spawn = debug::draw(window::Id::MAIN);
self.mouse_interaction =
user_interface.draw(renderer, theme, style, cursor);
draw_spawn.finish();
self.cache = Some(user_interface.into_cache());
Some(commands)
};
(uncaptured_events, command)
}
/// Applies [`Operation`]s to the [`State`]
pub fn operate(
&mut self,
renderer: &mut P::Renderer,
operations: impl Iterator<Item = Box<dyn Operation<P::Message>>>,
bounds: Size,
) {
let mut user_interface = build_user_interface(
&mut self.program,
self.cache.take().unwrap(),
renderer,
bounds,
);
for operation in operations {
let mut current_operation = Some(operation);
while let Some(mut operation) = current_operation.take() {
user_interface.operate(renderer, operation.as_mut());
match operation.finish() {
operation::Outcome::None => {}
operation::Outcome::Some(message) => {
self.queued_messages.push(message);
}
operation::Outcome::Chain(next) => {
current_operation = Some(next);
}
};
}
}
self.cache = Some(user_interface.into_cache());
}
}
fn build_user_interface<'a, P: Program>(
program: &'a mut P,
cache: user_interface::Cache,
renderer: &mut P::Renderer,
size: Size,
) -> UserInterface<'a, P::Message, P::Theme, P::Renderer> {
let view_span = debug::view(window::Id::MAIN);
let view = program.view();
view_span.finish();
let layout_span = debug::layout(window::Id::MAIN);
let user_interface = UserInterface::build(view, size, cache, renderer);
layout_span.finish();
user_interface
}

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 information 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,
}

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

@ -0,0 +1,405 @@
//! Create runtime tasks.
use crate::Action;
use crate::core::widget;
use crate::futures::futures::channel::mpsc;
use crate::futures::futures::channel::oneshot;
use crate::futures::futures::future::{self, FutureExt};
use crate::futures::futures::stream::{self, Stream, StreamExt};
use crate::futures::{BoxStream, MaybeSend, boxed_stream};
use std::sync::Arc;
#[doc(no_inline)]
pub use sipper::{Never, Sender, Sipper, Straw, sipper, stream};
/// 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)]
#[must_use = "`Task` must be returned to the runtime to take effect; normally in your `update` or `new` functions."]
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 [`Task`] that runs the given [`Future`] to completion and maps its
/// output with the given closure.
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 and maps each
/// item with the given closure.
pub fn run<A>(
stream: impl Stream<Item = A> + MaybeSend + 'static,
f: impl Fn(A) -> T + MaybeSend + 'static,
) -> Self
where
T: 'static,
{
Self::stream(stream.map(f))
}
/// Creates a [`Task`] that runs the given [`Sipper`] to completion, mapping
/// progress with the first closure and the output with the second one.
pub fn sip<S>(
sipper: S,
on_progress: impl FnMut(S::Progress) -> T + MaybeSend + 'static,
on_output: impl FnOnce(<S as Future>::Output) -> T + MaybeSend + 'static,
) -> Self
where
S: sipper::Core + MaybeSend + 'static,
T: MaybeSend + 'static,
{
Self::stream(stream(sipper::sipper(move |sender| async move {
on_output(sipper.with(on_progress).run(sender).await)
})))
}
/// 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),
))))
}
/// 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(Some(first)),
Some(second) => Task(Some(boxed_stream(first.chain(second)))),
},
}
}
/// Creates a new [`Task`] that collects all the output of the current one into a [`Vec`].
pub fn collect(self) -> Task<Vec<T>>
where
T: MaybeSend + 'static,
{
match self.0 {
None => Task::done(Vec::new()),
Some(stream) => Task(Some(boxed_stream(
stream::unfold(
(stream, Some(Vec::new())),
move |(mut stream, outputs)| async move {
let mut outputs = outputs?;
let Some(action) = stream.next().await else {
return Some((
Some(Action::Output(outputs)),
(stream, None),
));
};
match action.output() {
Ok(output) => {
outputs.push(output);
Some((None, (stream, Some(outputs))))
}
Err(action) => {
Some((Some(action), (stream, Some(outputs))))
}
}
},
)
.filter_map(future::ready),
))),
}
}
/// Creates a new [`Task`] that discards the result of the current one.
///
/// Useful if you only care about the side effects of a [`Task`].
pub fn discard<O>(self) -> Task<O>
where
T: MaybeSend + 'static,
O: MaybeSend + 'static,
{
self.then(|_| Task::none())
}
/// Creates a new [`Task`] that can be aborted with the returned [`Handle`].
pub fn abortable(self) -> (Self, Handle)
where
T: 'static,
{
match self.0 {
Some(stream) => {
let (stream, handle) = stream::abortable(stream);
(
Self(Some(boxed_stream(stream))),
Handle {
internal: InternalHandle::Manual(handle),
},
)
}
None => (
Self(None),
Handle {
internal: InternalHandle::Manual(
stream::AbortHandle::new_pair().0,
),
},
),
}
}
/// 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))))
}
}
/// A handle to a [`Task`] that can be used for aborting it.
#[derive(Debug, Clone)]
pub struct Handle {
internal: InternalHandle,
}
#[derive(Debug, Clone)]
enum InternalHandle {
Manual(stream::AbortHandle),
AbortOnDrop(Arc<stream::AbortHandle>),
}
impl InternalHandle {
pub fn as_ref(&self) -> &stream::AbortHandle {
match self {
InternalHandle::Manual(handle) => handle,
InternalHandle::AbortOnDrop(handle) => handle.as_ref(),
}
}
}
impl Handle {
/// Aborts the [`Task`] of this [`Handle`].
pub fn abort(&self) {
self.internal.as_ref().abort();
}
/// Returns a new [`Handle`] that will call [`Handle::abort`] whenever
/// all of its instances are dropped.
///
/// If a [`Handle`] is cloned, [`Handle::abort`] will only be called
/// once all of the clones are dropped.
///
/// This can be really useful if you do not want to worry about calling
/// [`Handle::abort`] yourself.
pub fn abort_on_drop(self) -> Self {
match &self.internal {
InternalHandle::Manual(handle) => Self {
internal: InternalHandle::AbortOnDrop(Arc::new(handle.clone())),
},
InternalHandle::AbortOnDrop(_) => self,
}
}
/// Returns `true` if the [`Task`] of this [`Handle`] has been aborted.
pub fn is_aborted(&self) -> bool {
self.internal.as_ref().is_aborted()
}
}
impl Drop for Handle {
fn drop(&mut self) {
if let InternalHandle::AbortOnDrop(handle) = &mut self.internal {
let handle = std::mem::replace(
handle,
Arc::new(stream::AbortHandle::new_pair().0),
);
if let Some(handle) = Arc::into_inner(handle) {
handle.abort();
}
}
}
}
impl<T> Task<Option<T>> {
/// Executes a new [`Task`] after this one, only when it produces `Some` value.
///
/// The value is provided to the closure to create the subsequent [`Task`].
pub fn and_then<A>(
self,
f: impl Fn(T) -> Task<A> + MaybeSend + 'static,
) -> Task<A>
where
T: MaybeSend + 'static,
A: MaybeSend + 'static,
{
self.then(move |option| option.map_or_else(Task::none, &f))
}
}
impl<T, E> Task<Result<T, E>> {
/// Executes a new [`Task`] after this one, only when it succeeds with an `Ok` value.
///
/// The success value is provided to the closure to create the subsequent [`Task`].
pub fn and_then<A>(
self,
f: impl Fn(T) -> Task<A> + MaybeSend + 'static,
) -> Task<A>
where
T: MaybeSend + 'static,
E: MaybeSend + 'static,
A: MaybeSend + 'static,
{
self.then(move |option| option.map_or_else(|_| Task::none(), &f))
}
}
impl<T> From<()> for Task<T> {
fn from(_value: ()) -> Self {
Self::none()
}
}
/// Creates a new [`Task`] that runs the given [`widget::Operation`] and produces
/// its output.
pub fn widget<T>(operation: impl widget::Operation<T> + 'static) -> Task<T>
where
T: Send + 'static,
{
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<T>(f: impl FnOnce(oneshot::Sender<T>) -> Action<T>) -> Task<T>
where
T: MaybeSend + 'static,
{
let (sender, receiver) = oneshot::channel();
let action = f(sender);
Task(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<T>(f: impl FnOnce(mpsc::Sender<T>) -> Action<T>) -> Task<T>
where
T: MaybeSend + 'static,
{
let (sender, receiver) = mpsc::channel(1);
let action = f(sender);
Task(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<T>(action: impl Into<Action<Never>>) -> Task<T> {
let action = action.into();
Task(Some(boxed_stream(stream::once(async move {
action.output().expect_err("no output")
}))))
}
/// Returns the underlying [`Stream`] of the [`Task`].
pub fn into_stream<T>(task: Task<T>) -> Option<BoxStream<Action<T>>> {
task.0
}

60
runtime/src/user_interface.rs
View file

@ -5,7 +5,9 @@ use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget;
use crate::core::window;
use crate::core::{Clipboard, Element, Layout, Rectangle, Shell, Size, Vector};
use crate::core::{
Clipboard, Element, InputMethod, Layout, Rectangle, Shell, Size, Vector,
};
use crate::overlay;
/// A set of interactive graphical elements with a specific [`Layout`].
@ -19,7 +21,7 @@ use crate::overlay;
/// The [`integration`] example uses a [`UserInterface`] to integrate Iced in an
/// existing graphical application.
///
/// [`integration`]: https://github.com/iced-rs/iced/tree/0.12/examples/integration
/// [`integration`]: https://github.com/iced-rs/iced/tree/0.13/examples/integration
#[allow(missing_debug_implementations)]
pub struct UserInterface<'a, Message, Theme, Renderer> {
root: Element<'a, Message, Theme, Renderer>,
@ -186,7 +188,8 @@ where
use std::mem::ManuallyDrop;
let mut outdated = false;
let mut redraw_request = None;
let mut redraw_request = window::RedrawRequest::Wait;
let mut input_method = InputMethod::Disabled;
let mut manual_overlay = ManuallyDrop::new(
self.root
@ -207,10 +210,10 @@ where
let mut layout = overlay.layout(renderer, bounds);
let mut event_statuses = Vec::new();
for event in events.iter().cloned() {
for event in events {
let mut shell = Shell::new(messages);
let event_status = overlay.on_event(
overlay.update(
event,
Layout::new(&layout),
cursor,
@ -219,17 +222,9 @@ where
&mut shell,
);
event_statuses.push(event_status);
match (redraw_request, shell.redraw_request()) {
(None, Some(at)) => {
redraw_request = Some(at);
}
(Some(current), Some(new)) if new < current => {
redraw_request = Some(new);
}
_ => {}
}
event_statuses.push(shell.event_status());
redraw_request = redraw_request.min(shell.redraw_request());
input_method.merge(shell.input_method());
if shell.is_layout_invalid() {
let _ = ManuallyDrop::into_inner(manual_overlay);
@ -299,7 +294,6 @@ where
let event_statuses = events
.iter()
.cloned()
.zip(overlay_statuses)
.map(|(event, overlay_status)| {
if matches!(overlay_status, event::Status::Captured) {
@ -308,7 +302,7 @@ where
let mut shell = Shell::new(messages);
let event_status = self.root.as_widget_mut().on_event(
self.root.as_widget_mut().update(
&mut self.state,
event,
Layout::new(&self.base),
@ -319,19 +313,12 @@ where
&viewport,
);
if matches!(event_status, event::Status::Captured) {
if shell.event_status() == event::Status::Captured {
self.overlay = None;
}
match (redraw_request, shell.redraw_request()) {
(None, Some(at)) => {
redraw_request = Some(at);
}
(Some(current), Some(new)) if new < current => {
redraw_request = Some(new);
}
_ => {}
}
redraw_request = redraw_request.min(shell.redraw_request());
input_method.merge(shell.input_method());
shell.revalidate_layout(|| {
self.base = self.root.as_widget().layout(
@ -347,7 +334,7 @@ where
outdated = true;
}
event_status.merge(overlay_status)
shell.event_status().merge(overlay_status)
})
.collect();
@ -355,7 +342,10 @@ where
if outdated {
State::Outdated
} else {
State::Updated { redraw_request }
State::Updated {
redraw_request,
input_method,
}
},
event_statuses,
)
@ -566,7 +556,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,
@ -636,7 +626,7 @@ impl Default for Cache {
}
/// The resulting state after updating a [`UserInterface`].
#[derive(Debug, Clone, Copy)]
#[derive(Debug, Clone)]
pub enum State {
/// The [`UserInterface`] is outdated and needs to be rebuilt.
Outdated,
@ -644,7 +634,9 @@ pub enum State {
/// The [`UserInterface`] is up-to-date and can be reused without
/// rebuilding.
Updated {
/// The [`window::RedrawRequest`] when a redraw should be performed.
redraw_request: Option<window::RedrawRequest>,
/// The [`window::RedrawRequest`] describing when a redraw should be performed.
redraw_request: window::RedrawRequest,
/// The current [`InputMethod`] strategy of the user interface.
input_method: InputMethod,
},
}

480
runtime/src/window.rs
View file

@ -1,24 +1,182 @@
//! 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,
Direction, Event, Icon, Id, Level, Mode, Screenshot, Settings,
UserAttention,
};
use crate::core::{Point, Size};
use crate::futures::event;
use crate::futures::Subscription;
use crate::futures::event;
use crate::futures::futures::channel::oneshot;
use crate::task::{self, 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, oneshot::Sender<Id>),
/// Close the window and exits the application.
Close(Id),
/// Gets the [`Id`] of the oldest window.
GetOldest(oneshot::Sender<Option<Id>>),
/// Gets the [`Id`] of the latest window.
GetLatest(oneshot::Sender<Option<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 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.
DragResize(Id, Direction),
/// Resize the window to the given logical dimensions.
Resize(Id, Size),
/// Get the current logical dimensions of the window.
GetSize(Id, oneshot::Sender<Size>),
/// Get if the current window is maximized or not.
GetMaximized(Id, oneshot::Sender<bool>),
/// Set the window to maximized or back
Maximize(Id, bool),
/// Get if the current window is minimized or not.
///
/// ## Platform-specific
/// - **Wayland:** Always `None`.
GetMinimized(Id, oneshot::Sender<Option<bool>>),
/// Set the window to minimized or back
Minimize(Id, bool),
/// Get the current logical coordinates of the window.
GetPosition(Id, oneshot::Sender<Option<Point>>),
/// Get the current scale factor (DPI) of the window.
GetScaleFactor(Id, oneshot::Sender<f32>),
/// Move the window to the given logical coordinates.
///
/// Unsupported on Wayland.
Move(Id, Point),
/// Change the [`Mode`] of the window.
SetMode(Id, Mode),
/// Get the current [`Mode`] of the window.
GetMode(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`].
SetLevel(Id, Level),
/// Show the system menu at cursor position.
///
/// ## Platform-specific
/// Android / iOS / macOS / Orbital / Web / X11: Unsupported.
ShowSystemMenu(Id),
/// Get the raw identifier unique to the window.
GetRawId(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.
SetIcon(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>),
/// Enables mouse passthrough for the given window.
///
/// This disables mouse events for the window and passes mouse events
/// through to whatever window is underneath.
EnableMousePassthrough(Id),
/// Disable mouse passthrough for the given window.
///
/// This enables mouse events for the window and stops mouse events
/// from being passed to whatever is underneath.
DisableMousePassthrough(Id),
/// Set the minimum inner window size.
SetMinSize(Id, Option<Size>),
/// Set the maximum inner window size.
SetMaxSize(Id, Option<Size>),
/// Set the window to be resizable or not.
SetResizable(Id, bool),
/// Set the window size increment.
SetResizeIncrements(Id, Option<Size>),
}
/// Subscribes to the frames of the window of the running application.
///
/// The resulting [`Subscription`] will produce items at a rate equal to the
@ -28,116 +186,204 @@ use raw_window_handle::WindowHandle;
/// In any case, this [`Subscription`] is useful to smoothly draw application-driven
/// animations without missing any frames.
pub fn frames() -> Subscription<Instant> {
event::listen_raw(|event, _status| match event {
crate::core::Event::Window(_, Event::RedrawRequested(at)) => Some(at),
event::listen_raw(|event, _status, _window| match event {
crate::core::Event::Window(Event::RedrawRequested(at)) => Some(at),
_ => None,
})
}
/// 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>) {
/// Subscribes to all window events of the running application.
pub fn events() -> Subscription<(Id, Event)> {
event::listen_with(|event, _status, id| {
if let crate::core::Event::Window(event) = event {
Some((id, event))
} else {
None
}
})
}
/// Subscribes to all [`Event::Opened`] occurrences in the running application.
pub fn open_events() -> Subscription<Id> {
event::listen_with(|event, _status, id| {
if let crate::core::Event::Window(Event::Opened { .. }) = event {
Some(id)
} else {
None
}
})
}
/// Subscribes to all [`Event::Closed`] occurrences in the running application.
pub fn close_events() -> Subscription<Id> {
event::listen_with(|event, _status, id| {
if let crate::core::Event::Window(Event::Closed) = event {
Some(id)
} else {
None
}
})
}
/// Subscribes to all [`Event::Resized`] occurrences in the running application.
pub fn resize_events() -> Subscription<(Id, Size)> {
event::listen_with(|event, _status, id| {
if let crate::core::Event::Window(Event::Resized(size)) = event {
Some((id, size))
} else {
None
}
})
}
/// Subscribes to all [`Event::CloseRequested`] occurrences in the running application.
pub fn close_requests() -> Subscription<Id> {
event::listen_with(|event, _status, id| {
if let crate::core::Event::Window(Event::CloseRequested) = event {
Some(id)
} else {
None
}
})
}
/// Opens a new window with the given [`Settings`]; producing the [`Id`]
/// of the new window on completion.
pub fn open(settings: Settings) -> (Id, Task<Id>) {
let id = Id::unique();
(
id,
Command::single(command::Action::Window(Action::Spawn(id, settings))),
task::oneshot(|channel| {
crate::Action::Window(Action::Open(id, settings, channel))
}),
)
}
/// 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)))
}
/// Gets the window [`Id`] of the oldest window.
pub fn get_oldest() -> Task<Option<Id>> {
task::oneshot(|channel| crate::Action::Window(Action::GetOldest(channel)))
}
/// Gets the window [`Id`] of the latest window.
pub fn get_latest() -> Task<Option<Id>> {
task::oneshot(|channel| crate::Action::Window(Action::GetLatest(channel)))
}
/// 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)))
}
/// Begins resizing the window while the left mouse button is held.
pub fn drag_resize<T>(id: Id, direction: Direction) -> Task<T> {
task::effect(crate::Action::Window(Action::DragResize(id, direction)))
}
/// 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))))
/// Set the window to be resizable or not.
pub fn set_resizable<T>(id: Id, resizable: bool) -> Task<T> {
task::effect(crate::Action::Window(Action::SetResizable(id, resizable)))
}
/// 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),
/// Set the inner maximum size of the window.
pub fn set_max_size<T>(id: Id, size: Option<Size>) -> Task<T> {
task::effect(crate::Action::Window(Action::SetMaxSize(id, size)))
}
/// Set the inner minimum size of the window.
pub fn set_min_size<T>(id: Id, size: Option<Size>) -> Task<T> {
task::effect(crate::Action::Window(Action::SetMinSize(id, size)))
}
/// Set the window size increment.
///
/// This is usually used by apps such as terminal emulators that need "blocky" resizing.
pub fn set_resize_increments<T>(id: Id, increments: Option<Size>) -> Task<T> {
task::effect(crate::Action::Window(Action::SetResizeIncrements(
id, increments,
)))
}
/// Get the window's size in logical dimensions.
pub fn get_size(id: Id) -> Task<Size> {
task::oneshot(move |channel| {
crate::Action::Window(Action::GetSize(id, channel))
})
}
/// Gets the maximized state of the window with the given [`Id`].
pub fn get_maximized(id: Id) -> Task<bool> {
task::oneshot(move |channel| {
crate::Action::Window(Action::GetMaximized(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),
)))
/// Gets the minimized state of the window with the given [`Id`].
pub fn get_minimized(id: Id) -> Task<Option<bool>> {
task::oneshot(move |channel| {
crate::Action::Window(Action::GetMinimized(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),
)))
/// Gets the position in logical coordinates of the window with the given [`Id`].
pub fn get_position(id: Id) -> Task<Option<Point>> {
task::oneshot(move |channel| {
crate::Action::Window(Action::GetPosition(id, channel))
})
}
/// Gets the scale factor of the window with the given [`Id`].
pub fn get_scale_factor(id: Id) -> Task<f32> {
task::oneshot(move |channel| {
crate::Action::Window(Action::GetScaleFactor(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)))
}
/// Gets the current [`Mode`] of the window.
pub fn get_mode(id: Id) -> Task<Mode> {
task::oneshot(move |channel| {
crate::Action::Window(Action::GetMode(id, channel))
})
}
/// 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)))
}
/// 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 set_mode<T>(id: Id, mode: Mode) -> Task<T> {
task::effect(crate::Action::Window(Action::SetMode(id, mode)))
}
/// 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 +392,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 +405,77 @@ 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 set_level<T>(id: Id, level: Level) -> Task<T> {
task::effect(crate::Action::Window(Action::SetLevel(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
/// Gets 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 get_raw_id<Message>(id: Id) -> Task<u64> {
task::oneshot(|channel| {
crate::Action::Window(Action::GetRawId(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 set_icon<T>(id: Id, icon: Icon) -> Task<T> {
task::effect(crate::Action::Window(Action::SetIcon(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 + Send + 'static,
) -> Task<T>
where
T: Send + '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))
})
}
/// Enables mouse passthrough for the given window.
///
/// This disables mouse events for the window and passes mouse events
/// through to whatever window is underneath.
pub fn enable_mouse_passthrough<Message>(id: Id) -> Task<Message> {
task::effect(crate::Action::Window(Action::EnableMousePassthrough(id)))
}
/// Disable mouse passthrough for the given window.
///
/// This enables mouse events for the window and stops mouse events
/// from being passed to whatever is underneath.
pub fn disable_mouse_passthrough<Message>(id: Id) -> Task<Message> {
task::effect(crate::Action::Window(Action::DisableMousePassthrough(id)))
}

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:?})"),
}
}
}

98
runtime/src/window/screenshot.rs
View file

@ -1,98 +0,0 @@
//! Take screenshots of a window.
use crate::core::{Rectangle, Size};
use bytes::Bytes;
use std::fmt::{Debug, Formatter};
/// Data of a screenshot, captured with `window::screenshot()`.
///
/// The `bytes` of this screenshot will always be ordered as `RGBA` in the `sRGB` color space.
#[derive(Clone)]
pub struct Screenshot {
/// The bytes of the [`Screenshot`].
pub bytes: Bytes,
/// The size of the [`Screenshot`].
pub size: Size<u32>,
}
impl Debug for Screenshot {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(
f,
"Screenshot: {{ \n bytes: {}\n size: {:?} }}",
self.bytes.len(),
self.size
)
}
}
impl Screenshot {
/// Creates a new [`Screenshot`].
pub fn new(bytes: impl Into<Bytes>, size: Size<u32>) -> Self {
Self {
bytes: bytes.into(),
size,
}
}
/// Crops a [`Screenshot`] to the provided `region`. This will always be relative to the
/// top-left corner of the [`Screenshot`].
pub fn crop(&self, region: Rectangle<u32>) -> Result<Self, CropError> {
if region.width == 0 || region.height == 0 {
return Err(CropError::Zero);
}
if region.x + region.width > self.size.width
|| region.y + region.height > self.size.height
{
return Err(CropError::OutOfBounds);
}
// Image is always RGBA8 = 4 bytes per pixel
const PIXEL_SIZE: usize = 4;
let bytes_per_row = self.size.width as usize * PIXEL_SIZE;
let row_range = region.y as usize..(region.y + region.height) as usize;
let column_range = region.x as usize * PIXEL_SIZE
..(region.x + region.width) as usize * PIXEL_SIZE;
let chopped = self.bytes.chunks(bytes_per_row).enumerate().fold(
vec![],
|mut acc, (row, bytes)| {
if row_range.contains(&row) {
acc.extend(&bytes[column_range.clone()]);
}
acc
},
);
Ok(Self {
bytes: Bytes::from(chopped),
size: Size::new(region.width, region.height),
})
}
}
impl AsRef<[u8]> for Screenshot {
fn as_ref(&self) -> &[u8] {
&self.bytes
}
}
impl From<Screenshot> for Bytes {
fn from(screenshot: Screenshot) -> Self {
screenshot.bytes
}
}
#[derive(Debug, thiserror::Error)]
/// Errors that can occur when cropping a [`Screenshot`].
pub enum CropError {
#[error("The cropped region is out of bounds.")]
/// The cropped region's size is out of bounds.
OutOfBounds,
#[error("The cropped region is not visible.")]
/// The cropped region's size is zero.
Zero,
}