monolith

public

Star0

Fork 0

Watch0

300 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `4e490b7685b8`

tarball

atagen <boss@atagen.co>2026-10-19 10:50 UTC

4 files changed+342-317

windows: move size negotiation and ghost capture into their own modules

windows.rs mixed mapping, natural-size negotiation, rule placement and frame capture in 700 lines. The moved code is unchanged apart from two visibility widenings.

Added file: crates/monolith/src/ghosts.rs+119 additions@@ -0,0 +1,119 @@
+//! The last frames windows leave behind when they close or hide to a tray, so
+//! their animations have something to show.
+
+use crate::anim::Ghost;
+use crate::state::{State, now_ns};
+use crate::wm::{LastFrame, root};
+use monolith_layout::{OutputId, Rect, WindowId};
+use monolith_render_vk::VulkanTexture;
+use smithay::backend::renderer::Renderer;
+use smithay::backend::renderer::utils::{import_surface_tree, with_renderer_surface_state};
+use smithay::desktop::Window;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::wayland::compositor::{BufferAssignment, SurfaceAttributes, with_states};
+
+impl State {
+    /// Called before a commit applies. A null-buffer commit makes smithay
+    /// drop the surface's textures before `on_buffer` runs, so the frame a
+    /// hiding window leaves behind has to be taken here.
+    pub fn keep_frame_for_hide(&mut self, surface: &WlSurface) {
+        let Some(id) = self.window_id(surface) else {
+            return;
+        };
+        let removes = with_states(surface, |s| {
+            let mut attrs = s.cached_state.get::<SurfaceAttributes>();
+            matches!(attrs.pending().buffer, Some(BufferAssignment::Removed))
+        });
+        let Some(s) = self.wm.get(id).filter(|s| removes && s.drawn) else {
+            return;
+        };
+        let window = s.window.clone();
+        let frame = self.last_frame(&window);
+        if let Some(s) = self.wm.get_mut(id) {
+            s.hide_frame = frame;
+        }
+    }
+
+    /// Keeps a visible tiled window's last frame shrinking to its seed while
+    /// its neighbours close over it.
+    pub(crate) fn leave_ghost(
+        &mut self,
+        id: WindowId,
+        window: &Window,
+        saved: Option<LastFrame>,
+        opacity: f32,
+    ) {
+        let Some(o) = self.wm.layout.window(id).and_then(|w| w.output) else {
+            return;
+        };
+        let tiled = self
+            .wm
+            .layout
+            .output(o)
+            .is_some_and(|out| out.tree.contains(id));
+        if !tiled || !self.wm.layout.visible(id) {
+            return;
+        }
+        let Some(seed) = self
+            .wm
+            .layout
+            .arrange_hiding(o, &[id])
+            .tiled
+            .into_iter()
+            .find(|p| p.window == id)
+        else {
+            return;
+        };
+        if let Some(frame) = saved.or_else(|| self.last_frame(window)) {
+            self.wm.last_frames.insert(id, frame);
+            self.wm.anim.add_ghost(Ghost {
+                id,
+                output: o,
+                seed: seed.rect,
+                born: now_ns(),
+                fixed: None,
+                opacity,
+            });
+        }
+    }
+
+    /// Fades a window that just left the screen where it was, like a
+    /// dismissed scratchpad.
+    pub fn fade_out(&mut self, id: WindowId, rect: Rect, output: OutputId) {
+        let Some(window) = self.wm.window(id).cloned() else {
+            return;
+        };
+        let opacity = self.wm.get(id).and_then(|s| s.rule.opacity).unwrap_or(1.0);
+        if let Some(frame) = self.last_frame(&window) {
+            self.wm.last_frames.insert(id, frame);
+            self.wm.anim.add_ghost(Ghost {
+                id,
+                output,
+                seed: rect,
+                born: now_ns(),
+                fixed: Some(rect),
+                opacity,
+            });
+        }
+    }
+
+    fn last_frame(&mut self, window: &Window) -> Option<LastFrame> {
+        let surface = root(window)?;
+        let _ = import_surface_tree(&mut self.renderer, &surface);
+        let context = self.renderer.context_id();
+        // The geometry lookup locks the surface's state, which the closure
+        // below already holds.
+        let geometry = window.geometry();
+        with_renderer_surface_state(&surface, |s| {
+            let texture = s.texture::<VulkanTexture>(context.clone())?.clone();
+            Some(LastFrame {
+                texture,
+                scale: s.buffer_scale(),
+                transform: s.buffer_transform(),
+                geometry,
+                view: s.view()?,
+            })
+        })
+        .flatten()
+    }
+}

Modified file: crates/monolith/src/main.rs+2 additions@@ -11,6 +11,7 @@ mod drm;
 mod fifo;
 mod focus;
 mod frame;
+mod ghosts;
 mod globals;
 mod idle;
 mod import;
@@ -30,6 +31,7 @@ mod scale;
 mod scene;
 mod seat;
 mod signals;
+mod sizing;
 mod state;
 mod stats;
 mod timing;

Added file: crates/monolith/src/sizing.rs+217 additions@@ -0,0 +1,217 @@
+//! Sizing floating windows. Clients are asked what size they want, and rules
+//! can pick the size and spot.
+
+use crate::state::{State, now_ns};
+use crate::wm::Kind;
+use monolith_config::At;
+use monolith_layout::{Rect, WindowId, clamp_float};
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
+use smithay::utils::Serial;
+use std::time::Duration;
+
+impl State {
+    /// Gives floats that landed on the layout's default rect their own size,
+    /// as when a tiled window is toggled. The client is told to pick one, and
+    /// its next commit after acking says which.
+    pub fn size_new_floats(&mut self) {
+        let stale: Vec<WindowId> = self
+            .wm
+            .iter()
+            .filter(|(id, s)| {
+                s.natural_size && !self.wm.layout.window(*id).is_some_and(|w| w.floating)
+            })
+            .map(|(id, _)| id)
+            .collect();
+        for id in stale {
+            if let Some(s) = self.wm.get_mut(id) {
+                s.natural_size = false;
+                s.natural_after = None;
+            }
+        }
+        let defaults: Vec<WindowId> = self
+            .wm
+            .layout
+            .windows()
+            .filter(|(_, w)| w.floating && w.float_default && w.scratchpad.is_none() && !w.hidden)
+            .map(|(id, _)| id)
+            .collect();
+        for id in defaults {
+            self.ask_natural_size(id);
+        }
+    }
+
+    fn ask_natural_size(&mut self, id: WindowId) {
+        let Some(window) = self
+            .wm
+            .get(id)
+            .filter(|s| !s.natural_size)
+            .map(|s| s.window.clone())
+        else {
+            return;
+        };
+        let geometry = window.geometry().size;
+        let current = (geometry.w > 0 && geometry.h > 0).then_some(geometry);
+        let fixed = window.toplevel().and_then(crate::xdg::fixed_size);
+        let size = match (window.x11_surface(), window.toplevel()) {
+            (Some(x), _) => crate::xwayland::fixed_size(x),
+            (_, Some(_)) if fixed.is_some() => fixed,
+            (_, Some(t)) => {
+                let held = self.visual_rect(id);
+                let serial = crate::wm::configure_free(t);
+                if let Some(w) = self.wm.get_mut(id)
+                    && let Some(serial) = serial
+                {
+                    w.natural_size = true;
+                    w.natural_after = Some(serial);
+                    if let Some(rect) = held {
+                        self.wm.layout.hold_float_rect(id, rect);
+                    }
+                    self.await_natural_size(id, serial);
+                    return;
+                }
+                current
+            }
+            _ => None,
+        };
+        match size {
+            Some(size) => self.float_at_natural_size(id, f64::from(size.w), f64::from(size.h)),
+            None => {
+                let rect = self.wm.layout.window(id).and_then(|w| w.float_rect);
+                if let Some(rect) = rect {
+                    self.wm.layout.set_float_rect(id, rect);
+                }
+            }
+        }
+    }
+
+    /// Where a placed window is drawn right now.
+    fn visual_rect(&self, id: WindowId) -> Option<Rect> {
+        let now = now_ns();
+        let (kind, rect, o) = self.wm.get(id)?.placed?;
+        self.wm
+            .anim
+            .gliding(id, now)
+            .or_else(|| {
+                (kind == Kind::Tiled)
+                    .then(|| self.wm.anim.tiled(o, id, now))
+                    .flatten()
+            })
+            .or(Some(rect))
+    }
+
+    /// A client that never answers a request for its size takes whatever
+    /// size it has.
+    fn await_natural_size(&mut self, id: WindowId, serial: Serial) {
+        let timeout = Timer::from_duration(Duration::from_millis(300));
+        let _ = self.core.handle.insert_source(timeout, move |_, _, state| {
+            state.give_up_natural_size(id, serial);
+            TimeoutAction::Drop
+        });
+    }
+
+    fn give_up_natural_size(&mut self, id: WindowId, serial: Serial) {
+        let Some(w) = self.wm.get_mut(id) else {
+            return;
+        };
+        if !w.natural_size || w.natural_after != Some(serial) {
+            return;
+        }
+        w.natural_size = false;
+        w.natural_after = None;
+        let size = w.window.geometry().size;
+        if size.w > 0 && size.h > 0 {
+            self.float_at_natural_size(id, f64::from(size.w), f64::from(size.h));
+        } else if let Some(rect) = self.wm.layout.window(id).and_then(|w| w.float_rect) {
+            self.wm.layout.set_float_rect(id, rect);
+        }
+        self.apply_layout();
+    }
+
+    /// Gives a floating window the size and spot its rules ask for, keeping
+    /// whichever of the two they leave out. One still waiting for its client
+    /// to pick a size gets its spot when the size arrives, unless the rule
+    /// has a size to give it right away.
+    pub(crate) fn float_by_rule(&mut self, id: WindowId) {
+        let Some(win) = self.wm.layout.window(id).filter(|win| win.floating) else {
+            return;
+        };
+        let (held, fullscreen) = (win.float_rect.map(|r| (r.w, r.h)), win.fullscreen);
+        let Some(s) = self.wm.get_mut(id) else {
+            return;
+        };
+        let rule = &s.rule;
+        let size = rule.size.map(|(w, h)| (f64::from(w), f64::from(h)));
+        let shaped = rule.at.is_some() || rule.min_size.is_some() || rule.max_size.is_some();
+        if size.is_some() {
+            s.natural_size = false;
+            s.natural_after = None;
+        } else if !shaped || s.natural_size || fullscreen {
+            return;
+        }
+        let Some((w, h)) = size.or(held) else {
+            return;
+        };
+        if let Some(rect) = self.float_rect_for(id, w, h) {
+            self.wm.layout.set_float_rect(id, rect);
+        }
+    }
+
+    /// Where a floating window of this size goes. A rule can pick the spot,
+    /// otherwise it is centred over its parent, or else its output, and kept
+    /// clear of the bars.
+    fn float_rect_for(&self, id: WindowId, w: f64, h: f64) -> Option<Rect> {
+        let rule = self.wm.get(id).map(|s| &s.rule);
+        let (w, h) = rule.map_or((w, h), |r| r.clamp_size(w, h));
+        let parent = self
+            .wm
+            .layout
+            .window(id)
+            .and_then(|win| win.parent)
+            .and_then(|p| self.wm.get(p)?.placed)
+            .map(|(_, r, _)| r);
+        let output = self
+            .wm
+            .layout
+            .window(id)
+            .and_then(|win| win.output)
+            .and_then(|o| self.wm.layout.output(o))?;
+        let usable = output.usable();
+        let at = rule.and_then(|r| r.at);
+        let around = if at.is_some() {
+            usable
+        } else {
+            parent.unwrap_or(usable)
+        };
+        let (x, y) = match at {
+            Some(At::Position(x, y)) => {
+                return Some(Rect::new(
+                    output.area.x + f64::from(x),
+                    output.area.y + f64::from(y),
+                    w,
+                    h,
+                ));
+            }
+            _ => (
+                around.x + (around.w - w) / 2.0,
+                around.y + (around.h - h) / 2.0,
+            ),
+        };
+        Some(clamp_float(Rect::new(x, y, w, h), usable))
+    }
+
+    /// Sizes a window to what its client picked. One already floating glides
+    /// there from where it is drawn.
+    pub(crate) fn float_at_natural_size(&mut self, id: WindowId, w: f64, h: f64) {
+        if let Some(rect) = self.float_rect_for(id, w, h) {
+            self.wm.layout.set_float_rect(id, rect);
+            if let Some((Kind::Floating, from, o)) = self.wm.get(id).and_then(|s| s.placed) {
+                let now = now_ns();
+                let from = self.wm.anim.gliding(id, now).unwrap_or(from);
+                self.wm.anim.glide(id, from, rect, now);
+                if let Some(s) = self.wm.get_mut(id) {
+                    s.placed = Some((Kind::Floating, rect, o));
+                }
+            }
+        }
+    }
+}

Modified file: crates/monolith/src/windows.rs+4 additions−317 deletions@@ -1,18 +1,14 @@
-use crate::anim::Ghost;
 use crate::state::{State, now_ns};
-use crate::wm::{Kind, LastFrame, identity, root};
-use monolith_config::At;
-use monolith_layout::{OutputId, Rect, TagId, WindowId, clamp_float};
-use monolith_render_vk::VulkanTexture;
-use smithay::backend::renderer::Renderer;
-use smithay::backend::renderer::utils::{import_surface_tree, with_renderer_surface_state};
+use crate::wm::{identity, root};
+use monolith_layout::{OutputId, Rect, TagId, WindowId};
+use smithay::backend::renderer::utils::with_renderer_surface_state;
 use smithay::desktop::Window;
 use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::State as XdgState;
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::{Logical, Point, Rectangle, Serial};
-use smithay::wayland::compositor::{BufferAssignment, SurfaceAttributes, with_states};
+use smithay::wayland::compositor::with_states;
 use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;
 use std::time::Duration;
 
@@ -239,27 +235,6 @@ impl State {
         self.apply_layout();
     }
 
-    /// Called before a commit applies. A null-buffer commit makes smithay
-    /// drop the surface's textures before `on_buffer` runs, so the frame a
-    /// hiding window leaves behind has to be taken here.
-    pub fn keep_frame_for_hide(&mut self, surface: &WlSurface) {
-        let Some(id) = self.window_id(surface) else {
-            return;
-        };
-        let removes = with_states(surface, |s| {
-            let mut attrs = s.cached_state.get::<SurfaceAttributes>();
-            matches!(attrs.pending().buffer, Some(BufferAssignment::Removed))
-        });
-        let Some(s) = self.wm.get(id).filter(|s| removes && s.drawn) else {
-            return;
-        };
-        let window = s.window.clone();
-        let frame = self.last_frame(&window);
-        if let Some(s) = self.wm.get_mut(id) {
-            s.hide_frame = frame;
-        }
-    }
-
     fn first_buffer(&mut self, id: WindowId) {
         let Some(w) = self.wm.get_mut(id) else {
             return;
@@ -324,211 +299,6 @@ impl State {
         true
     }
 
-    /// Gives floats that landed on the layout's default rect their own size,
-    /// as when a tiled window is toggled. The client is told to pick one, and
-    /// its next commit after acking says which.
-    pub fn size_new_floats(&mut self) {
-        let stale: Vec<WindowId> = self
-            .wm
-            .iter()
-            .filter(|(id, s)| {
-                s.natural_size && !self.wm.layout.window(*id).is_some_and(|w| w.floating)
-            })
-            .map(|(id, _)| id)
-            .collect();
-        for id in stale {
-            if let Some(s) = self.wm.get_mut(id) {
-                s.natural_size = false;
-                s.natural_after = None;
-            }
-        }
-        let defaults: Vec<WindowId> = self
-            .wm
-            .layout
-            .windows()
-            .filter(|(_, w)| w.floating && w.float_default && w.scratchpad.is_none() && !w.hidden)
-            .map(|(id, _)| id)
-            .collect();
-        for id in defaults {
-            self.ask_natural_size(id);
-        }
-    }
-
-    fn ask_natural_size(&mut self, id: WindowId) {
-        let Some(window) = self
-            .wm
-            .get(id)
-            .filter(|s| !s.natural_size)
-            .map(|s| s.window.clone())
-        else {
-            return;
-        };
-        let geometry = window.geometry().size;
-        let current = (geometry.w > 0 && geometry.h > 0).then_some(geometry);
-        let fixed = window.toplevel().and_then(crate::xdg::fixed_size);
-        let size = match (window.x11_surface(), window.toplevel()) {
-            (Some(x), _) => crate::xwayland::fixed_size(x),
-            (_, Some(_)) if fixed.is_some() => fixed,
-            (_, Some(t)) => {
-                let held = self.visual_rect(id);
-                let serial = crate::wm::configure_free(t);
-                if let Some(w) = self.wm.get_mut(id)
-                    && let Some(serial) = serial
-                {
-                    w.natural_size = true;
-                    w.natural_after = Some(serial);
-                    if let Some(rect) = held {
-                        self.wm.layout.hold_float_rect(id, rect);
-                    }
-                    self.await_natural_size(id, serial);
-                    return;
-                }
-                current
-            }
-            _ => None,
-        };
-        match size {
-            Some(size) => self.float_at_natural_size(id, f64::from(size.w), f64::from(size.h)),
-            None => {
-                let rect = self.wm.layout.window(id).and_then(|w| w.float_rect);
-                if let Some(rect) = rect {
-                    self.wm.layout.set_float_rect(id, rect);
-                }
-            }
-        }
-    }
-
-    /// Where a placed window is drawn right now.
-    fn visual_rect(&self, id: WindowId) -> Option<Rect> {
-        let now = now_ns();
-        let (kind, rect, o) = self.wm.get(id)?.placed?;
-        self.wm
-            .anim
-            .gliding(id, now)
-            .or_else(|| {
-                (kind == Kind::Tiled)
-                    .then(|| self.wm.anim.tiled(o, id, now))
-                    .flatten()
-            })
-            .or(Some(rect))
-    }
-
-    /// A client that never answers a request for its size takes whatever
-    /// size it has.
-    fn await_natural_size(&mut self, id: WindowId, serial: Serial) {
-        let timeout = Timer::from_duration(Duration::from_millis(300));
-        let _ = self.core.handle.insert_source(timeout, move |_, _, state| {
-            state.give_up_natural_size(id, serial);
-            TimeoutAction::Drop
-        });
-    }
-
-    fn give_up_natural_size(&mut self, id: WindowId, serial: Serial) {
-        let Some(w) = self.wm.get_mut(id) else {
-            return;
-        };
-        if !w.natural_size || w.natural_after != Some(serial) {
-            return;
-        }
-        w.natural_size = false;
-        w.natural_after = None;
-        let size = w.window.geometry().size;
-        if size.w > 0 && size.h > 0 {
-            self.float_at_natural_size(id, f64::from(size.w), f64::from(size.h));
-        } else if let Some(rect) = self.wm.layout.window(id).and_then(|w| w.float_rect) {
-            self.wm.layout.set_float_rect(id, rect);
-        }
-        self.apply_layout();
-    }
-
-    /// Gives a floating window the size and spot its rules ask for, keeping
-    /// whichever of the two they leave out. One still waiting for its client
-    /// to pick a size gets its spot when the size arrives, unless the rule
-    /// has a size to give it right away.
-    pub(crate) fn float_by_rule(&mut self, id: WindowId) {
-        let Some(win) = self.wm.layout.window(id).filter(|win| win.floating) else {
-            return;
-        };
-        let (held, fullscreen) = (win.float_rect.map(|r| (r.w, r.h)), win.fullscreen);
-        let Some(s) = self.wm.get_mut(id) else {
-            return;
-        };
-        let rule = &s.rule;
-        let size = rule.size.map(|(w, h)| (f64::from(w), f64::from(h)));
-        let shaped = rule.at.is_some() || rule.min_size.is_some() || rule.max_size.is_some();
-        if size.is_some() {
-            s.natural_size = false;
-            s.natural_after = None;
-        } else if !shaped || s.natural_size || fullscreen {
-            return;
-        }
-        let Some((w, h)) = size.or(held) else {
-            return;
-        };
-        if let Some(rect) = self.float_rect_for(id, w, h) {
-            self.wm.layout.set_float_rect(id, rect);
-        }
-    }
-
-    /// Where a floating window of this size goes. A rule can pick the spot,
-    /// otherwise it is centred over its parent, or else its output, and kept
-    /// clear of the bars.
-    fn float_rect_for(&self, id: WindowId, w: f64, h: f64) -> Option<Rect> {
-        let rule = self.wm.get(id).map(|s| &s.rule);
-        let (w, h) = rule.map_or((w, h), |r| r.clamp_size(w, h));
-        let parent = self
-            .wm
-            .layout
-            .window(id)
-            .and_then(|win| win.parent)
-            .and_then(|p| self.wm.get(p)?.placed)
-            .map(|(_, r, _)| r);
-        let output = self
-            .wm
-            .layout
-            .window(id)
-            .and_then(|win| win.output)
-            .and_then(|o| self.wm.layout.output(o))?;
-        let usable = output.usable();
-        let at = rule.and_then(|r| r.at);
-        let around = if at.is_some() {
-            usable
-        } else {
-            parent.unwrap_or(usable)
-        };
-        let (x, y) = match at {
-            Some(At::Position(x, y)) => {
-                return Some(Rect::new(
-                    output.area.x + f64::from(x),
-                    output.area.y + f64::from(y),
-                    w,
-                    h,
-                ));
-            }
-            _ => (
-                around.x + (around.w - w) / 2.0,
-                around.y + (around.h - h) / 2.0,
-            ),
-        };
-        Some(clamp_float(Rect::new(x, y, w, h), usable))
-    }
-
-    /// Sizes a window to what its client picked. One already floating glides
-    /// there from where it is drawn.
-    fn float_at_natural_size(&mut self, id: WindowId, w: f64, h: f64) {
-        if let Some(rect) = self.float_rect_for(id, w, h) {
-            self.wm.layout.set_float_rect(id, rect);
-            if let Some((Kind::Floating, from, o)) = self.wm.get(id).and_then(|s| s.placed) {
-                let now = now_ns();
-                let from = self.wm.anim.gliding(id, now).unwrap_or(from);
-                self.wm.anim.glide(id, from, rect, now);
-                if let Some(s) = self.wm.get_mut(id) {
-                    s.placed = Some((Kind::Floating, rect, o));
-                }
-            }
-        }
-    }
-
     pub fn unmap_window(&mut self, surface: &WlSurface) {
         self.wm
             .unmapped
@@ -550,89 +320,6 @@ impl State {
         state.map(|s| s.window)
     }
 
-    /// Keeps a visible tiled window's last frame shrinking to its seed while
-    /// its neighbours close over it.
-    fn leave_ghost(
-        &mut self,
-        id: WindowId,
-        window: &Window,
-        saved: Option<LastFrame>,
-        opacity: f32,
-    ) {
-        let Some(o) = self.wm.layout.window(id).and_then(|w| w.output) else {
-            return;
-        };
-        let tiled = self
-            .wm
-            .layout
-            .output(o)
-            .is_some_and(|out| out.tree.contains(id));
-        if !tiled || !self.wm.layout.visible(id) {
-            return;
-        }
-        let Some(seed) = self
-            .wm
-            .layout
-            .arrange_hiding(o, &[id])
-            .tiled
-            .into_iter()
-            .find(|p| p.window == id)
-        else {
-            return;
-        };
-        if let Some(frame) = saved.or_else(|| self.last_frame(window)) {
-            self.wm.last_frames.insert(id, frame);
-            self.wm.anim.add_ghost(Ghost {
-                id,
-                output: o,
-                seed: seed.rect,
-                born: now_ns(),
-                fixed: None,
-                opacity,
-            });
-        }
-    }
-
-    /// Fades a window that just left the screen where it was, like a
-    /// dismissed scratchpad.
-    pub fn fade_out(&mut self, id: WindowId, rect: Rect, output: OutputId) {
-        let Some(window) = self.wm.window(id).cloned() else {
-            return;
-        };
-        let opacity = self.wm.get(id).and_then(|s| s.rule.opacity).unwrap_or(1.0);
-        if let Some(frame) = self.last_frame(&window) {
-            self.wm.last_frames.insert(id, frame);
-            self.wm.anim.add_ghost(Ghost {
-                id,
-                output,
-                seed: rect,
-                born: now_ns(),
-                fixed: Some(rect),
-                opacity,
-            });
-        }
-    }
-
-    fn last_frame(&mut self, window: &Window) -> Option<LastFrame> {
-        let surface = root(window)?;
-        let _ = import_surface_tree(&mut self.renderer, &surface);
-        let context = self.renderer.context_id();
-        // The geometry lookup locks the surface's state, which the closure
-        // below already holds.
-        let geometry = window.geometry();
-        with_renderer_surface_state(&surface, |s| {
-            let texture = s.texture::<VulkanTexture>(context.clone())?.clone();
-            Some(LastFrame {
-                texture,
-                scale: s.buffer_scale(),
-                transform: s.buffer_transform(),
-                geometry,
-                view: s.view()?,
-            })
-        })
-        .flatten()
-    }
-
     /// Picks up a changed title or app id, which clients send at any time.
     pub fn refresh_identity(&mut self, id: WindowId) {
         let Some(w) = self.wm.get_mut(id) else {

monolith

Commit 4e490b7685b8

Commit `4e490b7685b8`