Bless Component Trait

core/src/renderer.rs

@@ -55,7 +55,7 @@ pub trait Renderer {
 
     /// Creates an [`image::Allocation`] for the given [`image::Handle`] and calls the given callback with it.
     fn allocate_image(
-        &mut self,
+        &self,
         handle: &image::Handle,
         callback: impl FnOnce(Result<image::Allocation, image::Error>) + Send + 'static,
     );

core/src/renderer/null.rs

@@ -17,7 +17,7 @@ impl Renderer for () {
     fn fill_quad(&mut self, _quad: renderer::Quad, _background: impl Into<Background>) {}
 
     fn allocate_image(
-        &mut self,
+        &self,
         handle: &image::Handle,
         callback: impl FnOnce(Result<image::Allocation, image::Error>) + Send + 'static,
     ) {

core/src/shell.rs

@@ -83,6 +83,12 @@ impl<'a, Message> Shell<'a, Message> {
         self.bus.push(message)
     }
 
+    /// Forwards the given `Message` and fulfills the given [`Receipt`]
+    /// once processed.
+    pub fn forward(&mut self, message: Message, receipt: Receipt) {
+        self.bus.forward(message, receipt);
+    }
+
     /// Marks the current event as captured. Prevents "event bubbling".
     ///
     /// A widget should capture an event when no ancestor should
@@ -280,7 +286,7 @@ pub enum Diff {
 /// A channel of messages published by a [`Shell`].
 #[derive(Debug)]
 pub struct Bus<T> {
-    messages: Vec<(T, Rc<()>)>,
+    messages: Vec<(T, Receipt)>,
 }
 
 impl<T> Bus<T> {
@@ -306,17 +312,22 @@ impl<T> Bus<T> {
     /// The returned [`Tracking`] can be used to determine if the message
     /// was processed.
     pub fn push(&mut self, message: T) -> Tracking {
-        let receipt = Rc::new(());
-        let tracking = Tracking(Rc::downgrade(&receipt));
+        let receipt = Receipt::new();
+        let tracking = receipt.tracking();
 
         self.messages.push((message, receipt));
 
         tracking
     }
 
+    /// Forward a new message to the [`Bus`] with the given [`Receipt`].
+    pub fn forward(&mut self, message: T, receipt: Receipt) {
+        self.messages.push((message, receipt));
+    }
+
     /// Drains the [`Bus`].
-    pub fn drain(&mut self) -> impl Iterator<Item = T> {
-        self.messages.drain(..).map(|(message, _receipt)| message)
+    pub fn drain(&mut self) -> impl Iterator<Item = (T, Receipt)> {
+        self.messages.drain(..)
     }
 }
 
@@ -339,7 +350,7 @@ impl<T> IntoIterator for Bus<T> {
 
 /// An iterator returned by the implementation of [`IntoIterator`] for [`Bus`].
 pub struct IntoIter<T> {
-    iter: vec::IntoIter<(T, Rc<()>)>,
+    iter: vec::IntoIter<(T, Receipt)>,
 }
 
 impl<T> Iterator for IntoIter<T> {
@@ -350,6 +361,20 @@ impl<T> Iterator for IntoIter<T> {
     }
 }
 
+/// Proof that a message has been received.
+#[derive(Debug)]
+pub struct Receipt(Rc<()>);
+
+impl Receipt {
+    fn new() -> Self {
+        Self(Rc::new(()))
+    }
+
+    fn tracking(&self) -> Tracking {
+        Tracking(Rc::downgrade(&self.0))
+    }
+}
+
 /// A message tracking returned by [`Shell::publish`].
 #[derive(Debug, Clone)]
 pub struct Tracking(rc::Weak<()>);

examples/component/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "component"
+version = "0.1.0"
+authors = ["Héctor Ramón Jiménez <hector@hecrj.dev>"]
+edition = "2024"
+publish = false
+
+[dependencies]
+iced.workspace = true
+iced.features = ["debug"]

examples/component/src/main.rs

@@ -0,0 +1,130 @@
+use iced::Element;
+use iced::widget::center;
+
+use numeric_input::numeric_input;
+
+pub fn main() -> iced::Result {
+    iced::run(Example::update, Example::view)
+}
+
+#[derive(Default)]
+struct Example {
+    value: Option<i32>,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum Message {
+    NumericInputChanged(Option<i32>),
+}
+
+impl Example {
+    fn update(&mut self, message: Message) {
+        match message {
+            Message::NumericInputChanged(value) => {
+                self.value = value;
+            }
+        }
+    }
+
+    fn view(&self) -> Element<'_, Message> {
+        center(numeric_input(self.value, Message::NumericInputChanged))
+            .padding(20)
+            .into()
+    }
+}
+
+mod numeric_input {
+    use iced::widget::{Component, button, component, row, text, text_input};
+    use iced::{Center, Element, Fill, Renderer};
+
+    pub struct NumericInput<Message> {
+        value: Option<i32>,
+        on_change: Box<dyn Fn(Option<i32>) -> Message>,
+    }
+
+    pub fn numeric_input<Message>(
+        value: Option<i32>,
+        on_change: impl Fn(Option<i32>) -> Message + 'static,
+    ) -> NumericInput<Message> {
+        NumericInput::new(value, on_change)
+    }
+
+    #[derive(Debug, Clone)]
+    pub enum Event {
+        InputChanged(String),
+        IncrementPressed,
+        DecrementPressed,
+    }
+
+    impl<Message> NumericInput<Message> {
+        pub fn new(
+            value: Option<i32>,
+            on_change: impl Fn(Option<i32>) -> Message + 'static,
+        ) -> Self {
+            Self {
+                value,
+                on_change: Box::new(on_change),
+            }
+        }
+    }
+
+    impl<'a, Message> Component<'a, Message> for NumericInput<Message> {
+        type State = ();
+        type Event = Event;
+
+        fn update(
+            &mut self,
+            _state: &mut Self::State,
+            event: Event,
+            _renderer: &Renderer,
+        ) -> Option<Message> {
+            match event {
+                Event::IncrementPressed => Some((self.on_change)(Some(
+                    self.value.unwrap_or_default().saturating_add(1),
+                ))),
+                Event::DecrementPressed => Some((self.on_change)(Some(
+                    self.value.unwrap_or_default().saturating_sub(1),
+                ))),
+                Event::InputChanged(value) => {
+                    if value.is_empty() {
+                        Some((self.on_change)(None))
+                    } else {
+                        value.parse().ok().map(Some).map(self.on_change.as_ref())
+                    }
+                }
+            }
+        }
+
+        fn view(&self, _state: &Self::State) -> Element<'a, Event> {
+            let button = |label, on_press| {
+                button(text(label).width(Fill).height(Fill).center())
+                    .width(40)
+                    .height(40)
+                    .on_press(on_press)
+            };
+
+            row![
+                button("-", Event::DecrementPressed),
+                text_input(
+                    "Type a number",
+                    self.value.as_ref().map(i32::to_string).unwrap_or_default(),
+                )
+                .on_input(Event::InputChanged)
+                .padding(10),
+                button("+", Event::IncrementPressed),
+            ]
+            .align_y(Center)
+            .spacing(10)
+            .into()
+        }
+    }
+
+    impl<'a, Message> From<NumericInput<Message>> for Element<'a, Message>
+    where
+        Message: 'a,
+    {
+        fn from(numeric_input: NumericInput<Message>) -> Self {
+            component(numeric_input)
+        }
+    }
+}

renderer/src/fallback.rs

@@ -63,7 +63,7 @@ where
     }
 
     fn allocate_image(
-        &mut self,
+        &self,
         handle: &image::Handle,
         callback: impl FnOnce(Result<image::Allocation, image::Error>) + Send + 'static,
     ) {

runtime/src/user_interface.rs

@@ -184,7 +184,7 @@ where
     ///     cache = user_interface.into_cache();
     ///
     ///     // Process the produced messages
-    ///     for message in messages.drain() {
+    ///     for (message, _receipt) in messages.drain() {
     ///         counter.update(message);
     ///     }
     /// }
@@ -487,7 +487,7 @@ where
     ///
     ///     cache = user_interface.into_cache();
     ///
-    ///     for message in messages.drain() {
+    ///     for (message, _receipt) in messages.drain() {
     ///         counter.update(message);
     ///     }
     ///

tiny_skia/src/lib.rs

@@ -209,7 +209,7 @@ impl core::Renderer for Renderer {
     }
 
     fn allocate_image(
-        &mut self,
+        &self,
         _handle: &core::image::Handle,
         callback: impl FnOnce(Result<core::image::Allocation, core::image::Error>) + Send + 'static,
     ) {

wgpu/src/lib.rs

@@ -685,13 +685,13 @@ impl core::Renderer for Renderer {
     }
 
     fn allocate_image(
-        &mut self,
+        &self,
         _handle: &core::image::Handle,
         _callback: impl FnOnce(Result<core::image::Allocation, core::image::Error>) + Send + 'static,
     ) {
         #[cfg(feature = "image")]
         self.image_cache
-            .get_mut()
+            .borrow_mut()
             .allocate_image(_handle, _callback);
     }
 

widget/src/action.rs

@@ -11,7 +11,8 @@ pub struct Action<Message> {
 }
 
 impl<Message> Action<Message> {
-    fn new() -> Self {
+    /// Creates an [`Action`] that does nothing.
+    pub fn none() -> Self {
         Self {
             message_to_publish: None,
             redraw_request: window::RedrawRequest::Wait,
@@ -27,7 +28,7 @@ impl<Message> Action<Message> {
     pub fn capture() -> Self {
         Self {
             event_status: event::Status::Captured,
-            ..Self::new()
+            ..Self::none()
         }
     }
 
@@ -38,7 +39,7 @@ impl<Message> Action<Message> {
     pub fn publish(message: Message) -> Self {
         Self {
             message_to_publish: Some(message),
-            ..Self::new()
+            ..Self::none()
         }
     }
 
@@ -47,7 +48,7 @@ impl<Message> Action<Message> {
     pub fn request_redraw() -> Self {
         Self {
             redraw_request: window::RedrawRequest::NextFrame,
-            ..Self::new()
+            ..Self::none()
         }
     }
 
@@ -59,7 +60,7 @@ impl<Message> Action<Message> {
     pub fn request_redraw_at(at: Instant) -> Self {
         Self {
             redraw_request: window::RedrawRequest::At(at),
-            ..Self::new()
+            ..Self::none()
         }
     }
 
@@ -69,6 +70,12 @@ impl<Message> Action<Message> {
         self
     }
 
+    /// Requests a redraw at the given [`Instant`]. See [`Self::request_redraw_at`].
+    pub fn and_request_redraw_at(mut self, at: Instant) -> Self {
+        self.redraw_request = window::RedrawRequest::At(at);
+        self
+    }
+
     /// Converts the [`Action`] into its internal parts.
     ///
     /// This method is meant to be used by runtimes, libraries, or internal