use crate::clipboard;
use crate::core::widget;
use crate::font;
use crate::system;
use crate::window;
use dnd::DndAction;
use iced_futures::MaybeSend;
use std::borrow::Cow;
use std::fmt;
pub enum Action<T> {
Future(iced_futures::BoxFuture<T>),
Stream(iced_futures::BoxStream<T>),
Clipboard(clipboard::Action<T>),
Window(window::Action<T>),
System(system::Action<T>),
Widget(Box<dyn widget::Operation<T>>),
Dnd(crate::dnd::DndAction<T>),
LoadFont {
bytes: Cow<'static, [u8]>,
tagger: Box<dyn Fn(Result<(), font::Error>) -> T>,
},
PlatformSpecific(crate::command::platform_specific::Action<T>),
}
impl<T> Action<T> {
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::PlatformSpecific(action) => {
Action::PlatformSpecific(action.map(f))
}
Self::Dnd(a) => Action::Dnd(a.map(f)),
Action::LoadFont { bytes, tagger } => todo!(),
Action::PlatformSpecific(_) => todo!(),
}
}
}
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::PlatformSpecific(action) => {
write!(f, "Action::PlatformSpecific({:?})", action)
}
Self::Dnd(action) => write!(f, "Action::Dnd"),
}
}
}