diff --git a/src/platform_impl/linux/wayland/event_loop.rs b/src/platform_impl/linux/wayland/event_loop.rs
index 146dcb37..4135e368 100644
--- a/src/platform_impl/linux/wayland/event_loop.rs
+++ b/src/platform_impl/linux/wayland/event_loop.rs
@@ -664,60 +664,53 @@ impl<T> EventLoop<T> {
             }
         }
         // process pending resize/refresh
-        window_target.store.lock().unwrap().for_each(
-            |newsize,
-             size,
-             new_dpi,
-             refresh,
-             frame_refresh,
-             closed,
-             grab_cursor,
-             surface,
-             wid,
-             frame| {
-                if let Some(frame) = frame {
-                    if let Some(newsize) = newsize {
-                        // Drop resize events equaled to the current size
-                        if newsize != *size {
-                            let (w, h) = newsize;
-                            frame.resize(w, h);
-                            frame.refresh();
-                            let logical_size = crate::dpi::LogicalSize::new(w as f64, h as f64);
-                            sink.send_window_event(
-                                crate::event::WindowEvent::Resized(logical_size),
-                                wid,
-                            );
-                            *size = (w, h);
-                        } else {
-                            // Refresh csd, etc, otherwise
-                            frame.refresh();
-                        }
-                    } else if frame_refresh {
+        window_target.store.lock().unwrap().for_each(|window| {
+            if let Some(frame) = window.frame {
+                if let Some(newsize) = window.newsize {
+                    // Drop resize events equaled to the current size
+                    if newsize != *window.size {
+                        let (w, h) = newsize;
+                        frame.resize(w, h);
                         frame.refresh();
-                        if !refresh {
-                            frame.surface().commit()
-                        }
+                        let logical_size = crate::dpi::LogicalSize::new(w as f64, h as f64);
+                        sink.send_window_event(
+                            crate::event::WindowEvent::Resized(logical_size),
+                            window.wid,
+                        );
+                        *window.size = (w, h);
+                    } else {
+                        // Refresh csd, etc, otherwise
+                        frame.refresh();
+                    }
+                } else if window.frame_refresh {
+                    frame.refresh();
+                    if !window.refresh {
+                        frame.surface().commit()
                     }
                 }
-                if let Some(dpi) = new_dpi {
-                    sink.send_window_event(
-                        crate::event::WindowEvent::HiDpiFactorChanged(dpi as f64),
-                        wid,
-                    );
-                }
-                if refresh {
-                    sink.send_window_event(crate::event::WindowEvent::RedrawRequested, wid);
-                }
-                if closed {
-                    sink.send_window_event(crate::event::WindowEvent::CloseRequested, wid);
-                }
+            }
+            if let Some(dpi) = window.new_dpi {
+                sink.send_window_event(
+                    crate::event::WindowEvent::HiDpiFactorChanged(dpi as f64),
+                    window.wid,
+                );
+            }
+            if window.refresh {
+                sink.send_window_event(crate::event::WindowEvent::RedrawRequested, window.wid);
+            }
+            if window.closed {
+                sink.send_window_event(crate::event::WindowEvent::CloseRequested, window.wid);
+            }
 
-                if let Some(grab_cursor) = grab_cursor {
-                    let surface = if grab_cursor { Some(surface) } else { None };
-                    self.cursor_manager.lock().unwrap().grab_pointer(surface);
-                }
-            },
-        )
+            if let Some(grab_cursor) = window.grab_cursor {
+                let surface = if grab_cursor {
+                    Some(window.surface)
+                } else {
+                    None
+                };
+                self.cursor_manager.lock().unwrap().grab_pointer(surface);
+            }
+        })
     }
 }
 
diff --git a/src/platform_impl/linux/wayland/window.rs b/src/platform_impl/linux/wayland/window.rs
index 49849ba6..609430a4 100644
--- a/src/platform_impl/linux/wayland/window.rs
+++ b/src/platform_impl/linux/wayland/window.rs
@@ -385,6 +385,19 @@ pub struct WindowStore {
     windows: Vec<InternalWindow>,
 }
 
+pub struct WindowStoreForEach<'a> {
+    pub newsize: Option<(u32, u32)>,
+    pub size: &'a mut (u32, u32),
+    pub new_dpi: Option<i32>,
+    pub refresh: bool,
+    pub frame_refresh: bool,
+    pub closed: bool,
+    pub grab_cursor: Option<bool>,
+    pub surface: &'a wl_surface::WlSurface,
+    pub wid: WindowId,
+    pub frame: Option<&'a mut SWindow<ConceptFrame>>,
+}
+
 impl WindowStore {
     pub fn new() -> WindowStore {
         WindowStore {
@@ -434,34 +447,23 @@ impl WindowStore {
 
     pub fn for_each<F>(&mut self, mut f: F)
     where
-        F: FnMut(
-            Option<(u32, u32)>,
-            &mut (u32, u32),
-            Option<i32>,
-            bool,
-            bool,
-            bool,
-            Option<bool>,
-            &wl_surface::WlSurface,
-            WindowId,
-            Option<&mut SWindow<ConceptFrame>>,
-        ),
+        F: FnMut(WindowStoreForEach<'_>),
     {
         for window in &mut self.windows {
             let opt_arc = window.frame.upgrade();
             let mut opt_mutex_lock = opt_arc.as_ref().map(|m| m.lock().unwrap());
-            f(
-                window.newsize.take(),
-                &mut *(window.size.lock().unwrap()),
-                window.new_dpi,
-                replace(&mut *window.need_refresh.lock().unwrap(), false),
-                replace(&mut *window.need_frame_refresh.lock().unwrap(), false),
-                window.closed,
-                window.cursor_grab_changed.lock().unwrap().take(),
-                &window.surface,
-                make_wid(&window.surface),
-                opt_mutex_lock.as_mut().map(|m| &mut **m),
-            );
+            f(WindowStoreForEach {
+                newsize: window.newsize.take(),
+                size: &mut *(window.size.lock().unwrap()),
+                new_dpi: window.new_dpi,
+                refresh: replace(&mut *window.need_refresh.lock().unwrap(), false),
+                frame_refresh: replace(&mut *window.need_frame_refresh.lock().unwrap(), false),
+                closed: window.closed,
+                grab_cursor: window.cursor_grab_changed.lock().unwrap().take(),
+                surface: &window.surface,
+                wid: make_wid(&window.surface),
+                frame: opt_mutex_lock.as_mut().map(|m| &mut **m),
+            });
             if let Some(dpi) = window.new_dpi.take() {
                 window.current_dpi = dpi;
             }