From f433b3dc20d1ccc112c43fd1b9336f0bd287374a Mon Sep 17 00:00:00 2001
From: Ashley Wulber <ashley@system76.com>
Date: Mon, 15 May 2023 14:22:07 -0400
Subject: [PATCH] fix: make rectangle_tracker subscription only return update
 if there is some

---
 src/widget/rectangle_tracker/subscription.rs | 75 +++++++++++---------
 1 file changed, 41 insertions(+), 34 deletions(-)

diff --git a/src/widget/rectangle_tracker/subscription.rs b/src/widget/rectangle_tracker/subscription.rs
index 0c61808b..224f8d6c 100644
--- a/src/widget/rectangle_tracker/subscription.rs
+++ b/src/widget/rectangle_tracker/subscription.rs
@@ -14,7 +14,7 @@ pub fn rectangle_tracker_subscription<
     R: 'static + Hash + Copy + Send + Sync + Debug + Eq,
 >(
     id: I,
-) -> iced::Subscription<Option<(I, RectangleUpdate<R>)>> {
+) -> iced::Subscription<(I, RectangleUpdate<R>)> {
     subscription::unfold(id, State::Ready, move |state| start_listening(id, state))
 }
 
@@ -26,44 +26,51 @@ pub enum State<I> {
 
 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();
+    mut state: State<R>,
+) -> ((I, RectangleUpdate<R>), State<R>) {
+    loop {
+        let (update, new_state) = match state {
+            State::Ready => {
+                let (tx, rx) = unbounded();
 
-            (
-                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).abs() > 0.1
-                        || (prev.height - new.height).abs() > 0.1
-                        || (prev.x - new.x).abs() > 0.1
-                        || (prev.y - new.y).abs() > 0.1
-                    {
-                        map.insert(u.0, new);
-                        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).abs() > 0.1
+                            || (prev.height - new.height).abs() > 0.1
+                            || (prev.x - new.x).abs() > 0.1
+                            || (prev.y - new.y).abs() > 0.1
+                        {
+                            map.insert(u.0, new);
+                            (
+                                Some((id, RectangleUpdate::Rectangle(u))),
+                                State::Waiting(rx, map),
+                            )
+                        } else {
+                            (None, State::Waiting(rx, map))
+                        }
+                    } else {
+                        map.insert(u.0, u.1);
+                        (
                             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),
-                    );
                 }
-                (None, State::Waiting(rx, map))
-            }
-            None => (None, State::Finished),
-        },
-        State::Finished => iced::futures::future::pending().await,
+                None => (None, State::Finished),
+            },
+            State::Finished => iced::futures::future::pending().await,
+        };
+        state = new_state;
+        if let Some(u) = update {
+            return (u, state);
+        }
     }
 }