feat: rectangle tracker container

src/widget/rectangle_tracker/mod.rs

@@ -0,0 +1,244 @@
+mod subscription;
+
+use iced::futures::channel::mpsc::UnboundedSender;
+use iced::widget::Container;
+pub use subscription::*;
+
+use iced_native::alignment;
+use iced_native::event::{self, Event};
+use iced_native::layout;
+use iced_native::mouse;
+use iced_native::overlay;
+use iced_native::renderer;
+use iced_native::widget::{Operation, Tree};
+use iced_native::{Clipboard, Element, Layout, Length, Padding, Point, Rectangle, Shell, Widget};
+use std::{fmt::Debug, hash::Hash};
+
+pub use iced_style::container::{Appearance, StyleSheet};
+
+#[derive(Clone, Debug)]
+pub struct RectangleTracker<I> {
+    tx: UnboundedSender<(I, Rectangle)>,
+}
+
+impl<I> RectangleTracker<I>
+where
+    I: Hash + Copy + Send + Sync + Debug,
+{
+    pub fn container<'a, Message: 'static, T>(
+        &self,
+        id: I,
+        content: T,
+    ) -> RectangleTrackingContainer<'a, Message, crate::Renderer, I>
+    where
+        I: 'a,
+        T: Into<Element<'a, Message, crate::Renderer>>,
+    {
+        RectangleTrackingContainer::new(content, id, self.tx.clone())
+    }
+}
+
+/// An element decorating some content.
+///
+/// It is normally used for alignment purposes.
+#[allow(missing_debug_implementations)]
+pub struct RectangleTrackingContainer<'a, Message, Renderer, I>
+where
+    Renderer: iced_native::Renderer,
+    Renderer::Theme: StyleSheet,
+{
+    tx: UnboundedSender<(I, Rectangle)>,
+    id: I,
+    container: Container<'a, Message, Renderer>,
+}
+
+impl<'a, Message, Renderer, I> RectangleTrackingContainer<'a, Message, Renderer, I>
+where
+    Renderer: iced_native::Renderer,
+    Renderer::Theme: StyleSheet,
+    I: 'a + Hash + Copy + Send + Sync + Debug,
+{
+    /// Creates an empty [`Container`].
+    pub(crate) fn new<T>(content: T, id: I, tx: UnboundedSender<(I, Rectangle)>) -> Self
+    where
+        T: Into<Element<'a, Message, Renderer>>,
+    {
+        RectangleTrackingContainer {
+            id,
+            tx,
+            container: Container::new(content),
+        }
+    }
+
+    /// Sets the [`Padding`] of the [`Container`].
+    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
+        self.container = self.container.padding(padding);
+        self
+    }
+
+    /// Sets the width of the [`self.`].
+    pub fn width(mut self, width: Length) -> Self {
+        self.container = self.container.width(width);
+        self
+    }
+
+    /// Sets the height of the [`Container`].
+    pub fn height(mut self, height: Length) -> Self {
+        self.container = self.container.height(height);
+        self
+    }
+
+    /// Sets the maximum width of the [`Container`].
+    pub fn max_width(mut self, max_width: u32) -> Self {
+        self.container = self.container.max_width(max_width);
+        self
+    }
+
+    /// Sets the maximum height of the [`Container`] in pixels.
+    pub fn max_height(mut self, max_height: u32) -> Self {
+        self.container = self.container.max_height(max_height);
+        self
+    }
+
+    /// Sets the content alignment for the horizontal axis of the [`Container`].
+    pub fn align_x(mut self, alignment: alignment::Horizontal) -> Self {
+        self.container = self.container.align_x(alignment);
+        self
+    }
+
+    /// Sets the content alignment for the vertical axis of the [`Container`].
+    pub fn align_y(mut self, alignment: alignment::Vertical) -> Self {
+        self.container = self.container.align_y(alignment);
+        self
+    }
+
+    /// Centers the contents in the horizontal axis of the [`Container`].
+    pub fn center_x(mut self) -> Self {
+        self.container = self.container.center_x();
+        self
+    }
+
+    /// Centers the contents in the vertical axis of the [`Container`].
+    pub fn center_y(mut self) -> Self {
+        self.container = self.container.center_y();
+        self
+    }
+
+    /// Sets the style of the [`Container`].
+    pub fn style(mut self, style: impl Into<<Renderer::Theme as StyleSheet>::Style>) -> Self {
+        self.container = self.container.style(style);
+        self
+    }
+}
+
+impl<'a, Message, Renderer, I> Widget<Message, Renderer>
+    for RectangleTrackingContainer<'a, Message, Renderer, I>
+where
+    Renderer: iced_native::Renderer,
+    Renderer::Theme: StyleSheet,
+    I: 'a + Hash + Copy + Send + Sync + Debug,
+{
+    fn children(&self) -> Vec<Tree> {
+        self.container.children()
+    }
+
+    fn diff(&self, tree: &mut Tree) {
+        self.container.diff(tree);
+    }
+
+    fn width(&self) -> Length {
+        Widget::width(&self.container)
+    }
+
+    fn height(&self) -> Length {
+        Widget::height(&self.container)
+    }
+
+    fn layout(&self, renderer: &Renderer, limits: &layout::Limits) -> layout::Node {
+        self.container.layout(renderer, limits)
+    }
+
+    fn operate(&self, tree: &mut Tree, layout: Layout<'_>, operation: &mut dyn Operation<Message>) {
+        self.container.operate(tree, layout, operation)
+    }
+
+    fn on_event(
+        &mut self,
+        tree: &mut Tree,
+        event: Event,
+        layout: Layout<'_>,
+        cursor_position: Point,
+        renderer: &Renderer,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+    ) -> event::Status {
+        self.container.on_event(
+            tree,
+            event,
+            layout,
+            cursor_position,
+            renderer,
+            clipboard,
+            shell,
+        )
+    }
+
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor_position: Point,
+        viewport: &Rectangle,
+        renderer: &Renderer,
+    ) -> mouse::Interaction {
+        self.container
+            .mouse_interaction(tree, layout, cursor_position, viewport, renderer)
+    }
+
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut Renderer,
+        theme: &Renderer::Theme,
+        renderer_style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor_position: Point,
+        viewport: &Rectangle,
+    ) {
+        let _ = self.tx.unbounded_send((self.id, layout.bounds()));
+
+        self.container.draw(
+            tree,
+            renderer,
+            theme,
+            renderer_style,
+            layout,
+            cursor_position,
+            viewport,
+        )
+    }
+
+    fn overlay<'b>(
+        &'b self,
+        tree: &'b mut Tree,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+    ) -> Option<overlay::Element<'b, Message, Renderer>> {
+        self.container.overlay(tree, layout, renderer)
+    }
+}
+
+impl<'a, Message, Renderer, I> From<RectangleTrackingContainer<'a, Message, Renderer, I>>
+    for Element<'a, Message, Renderer>
+where
+    Message: 'a,
+    Renderer: 'a + iced_native::Renderer,
+    Renderer::Theme: StyleSheet,
+    I: 'a + Hash + Copy + Send + Sync + Debug,
+{
+    fn from(
+        column: RectangleTrackingContainer<'a, Message, Renderer, I>,
+    ) -> Element<'a, Message, Renderer> {
+        Element::new(column)
+    }
+}

src/widget/rectangle_tracker/subscription.rs

@@ -0,0 +1,75 @@
+use iced::{
+    futures::{
+        channel::mpsc::{unbounded, UnboundedReceiver},
+        StreamExt,
+    },
+    subscription, Rectangle,
+};
+use std::{fmt::Debug, hash::Hash, collections::HashMap};
+
+use super::RectangleTracker;
+
+pub fn rectangle_tracker_subscription<
+    I: 'static + Hash + Copy + Send + Sync + Debug,
+    R: 'static + Hash + Copy + Send + Sync + Debug + Eq,
+>(
+    id: I,
+) -> iced::Subscription<(I, RectangleUpdate<R>)> {
+    subscription::unfold(id, State::Ready, move |state| start_listening(id, state))
+}
+
+pub enum State<I> {
+    Ready,
+    Waiting(UnboundedReceiver<(I, Rectangle)>, HashMap<I, Rectangle>),
+    Finished,
+}
+
+async fn start_listening<I: Copy, R: 'static + Hash + Copy + Send + Sync + Debug + Eq>(
+    id: I,
+    state: State<R>,
+) -> (Option<(I, RectangleUpdate<R>)>, State<R>) {
+    match state {
+        State::Ready => {
+            let (tx, rx) = unbounded();
+
+            return (
+                Some((id, RectangleUpdate::Init(RectangleTracker { tx }))),
+                State::Waiting(rx, HashMap::new()),
+            );
+        }
+        State::Waiting(mut rx, mut map) => match rx.next().await {
+            Some(u) => 
+            {
+                if let Some(prev) = map.get(&u.0) {
+                    let new = u.1;
+                    if prev.width != new.width || prev.height != new.height || prev.x != new.x || prev.y != new.y {
+                        map.insert(u.0, new);
+                        return (
+                            Some((id, RectangleUpdate::Rectangle(u))),
+                            State::Waiting(rx, map),
+                        );
+                    }
+                } else {
+                    map.insert(u.0, u.1);
+                    return (
+                        Some((id, RectangleUpdate::Rectangle(u))),
+                        State::Waiting(rx, map),
+                    );
+                }
+                return (None, State::Waiting(rx, map))
+                
+        },
+            None => (None, State::Finished),
+        },
+        State::Finished => iced::futures::future::pending().await,
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum RectangleUpdate<I>
+where
+    I: 'static + Hash + Copy + Send + Sync + Debug,
+{
+    Rectangle((I, Rectangle)),
+    Init(RectangleTracker<I>),
+}