monolith

public

Star0

Fork 0

Watch0

121 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `618afeb78754`

tarball

atagen <boss@atagen.co>2026-10-17 13:45 UTC

5 files changed+131-52

monolith: fade scratchpads and focus on hover only when entering a window

Summoning plays the spawn fade and dismissing leaves a still ghost of the last frame fading where the window was. Focus used to follow whatever window was under the pointer on every motion, so a new window lost focus the moment the mouse twitched over an old one.

Modified file: crates/monolith/src/anim.rs+10 additions−4 deletions@@ -26,6 +26,9 @@ pub struct Ghost {
     pub output: OutputId,
     pub seed: Rect,
     pub born: u64,
+    /// Fades where it is for one phase instead of shrinking in the plan,
+    /// like a dismissed scratchpad.
+    pub fixed: Option<Rect>,
 }
 
 struct Track {
@@ -84,7 +87,7 @@ impl Animator {
         let ghosts = self
             .ghosts
             .iter()
-            .filter(|g| g.output == o)
+            .filter(|g| g.output == o && g.fixed.is_none())
             .map(|g| (g.id, g.seed));
         let targets: Vec<(WindowId, Rect)> = ghosts.chain(targets.iter().copied()).collect();
         let ids: Vec<WindowId> = targets.iter().map(|(id, _)| *id).collect();
@@ -199,6 +202,7 @@ impl Animator {
     }
 
     pub fn spawned(&mut self, id: WindowId, now: u64) {
+        self.ghosts.retain(|g| g.id != id);
         if self.phase_ns() > 0 {
             self.spawns.insert(id, now);
         }
@@ -229,6 +233,7 @@ impl Animator {
         self.tracks.values().any(|t| t.timeline.end_ns() > now)
             || self.glides.values().any(|g| g.timeline.end_ns() > now)
             || !self.spawns.is_empty()
+            || self.ghosts.iter().any(|g| g.fixed.is_some())
     }
 
     pub fn forget(&mut self, id: WindowId) {
@@ -242,10 +247,11 @@ impl Animator {
         self.spawns
             .retain(|_, start| now.saturating_sub(*start) < phase);
         let tracks = &self.tracks;
-        self.ghosts.retain(|g| {
-            tracks
+        self.ghosts.retain(|g| match g.fixed {
+            Some(_) => now.saturating_sub(g.born) < phase,
+            None => tracks
                 .get(&g.output)
-                .is_some_and(|t| t.timeline.end_ns() > now)
+                .is_some_and(|t| t.timeline.end_ns() > now),
         });
     }
 }

Modified file: crates/monolith/src/input.rs+12 additions−3 deletions@@ -20,7 +20,7 @@ impl State {
         let Some(pointer) = self.input.seat.get_pointer() else {
             return;
         };
-        focus_on_hover(self, pos);
+        focus_on_hover(self, pos, self.input.warping);
         let under = self.surface_under(pos);
         pointer.motion(
             self,
@@ -166,7 +166,10 @@ fn window_at(state: &State, pos: Point<f64, Logical>) -> Option<WindowId> {
 }
 
 /// Layers above windows, like a bar, keep the focus where it was.
-fn focus_on_hover(state: &mut State, pos: Point<f64, Logical>) {
+/// Focus changes only when the pointer enters another window. Moving
+/// inside one, or being warped, leaves focus alone, so a new window keeps
+/// it until the pointer actually goes somewhere else.
+fn focus_on_hover(state: &mut State, pos: Point<f64, Logical>, warped: bool) {
     if !state.settings.config.general.focus_follows_mouse
         || state.services.lock.active()
         || state
@@ -175,7 +178,11 @@ fn focus_on_hover(state: &mut State, pos: Point<f64, Logical>) {
     {
         return;
     }
-    let Some(id) = window_at(state, pos) else {
+    let under = window_at(state, pos);
+    if std::mem::replace(&mut state.input.hovered, under) == under || warped {
+        return;
+    }
+    let Some(id) = under else {
         return;
     };
     if state.wm.layout.focused() == Some(id) {
@@ -202,10 +209,12 @@ impl State {
         let Some((_, r, _)) = focused.and_then(|id| self.wm.get(id)?.placed) else {
             return;
         };
+        self.input.warping = true;
         self.pointer_to(
             Point::from((r.x + r.w / 2.0, r.y + r.h / 2.0)),
             InputTime::now(),
         );
+        self.input.warping = false;
         self.pointer_frame();
         self.dirty.cursor = true;
     }

Modified file: crates/monolith/src/scene.rs+37 additions−23 deletions@@ -1,7 +1,7 @@
 //! What a frame draws. The space holds final geometry for input, while the
 //! scene draws windows where the animator says they are right now.
 
-use crate::wm::Wm;
+use crate::wm::{LastFrame, Wm};
 use monolith_config::Decoration;
 use monolith_layout::{OutputId, Rect};
 use monolith_render_vk::{Clip, Effect, VulkanFrame, VulkanRenderer, VulkanTexture};
@@ -59,9 +59,18 @@ pub fn build(
     let mut ghosts = Vec::new();
     let mut tiled = Vec::new();
     let mut above = Vec::new();
+    let mut fading = Vec::new();
     for g in anim.ghosts().iter().filter(|g| g.output == o) {
-        if let (Some(r), Some(frame)) = (anim.tiled(o, g.id, now), last_frames.get(&g.id)) {
-            ghosts.push((g, frame, local(r)));
+        let Some(frame) = last_frames.get(&g.id) else {
+            continue;
+        };
+        match g.fixed {
+            Some(r) => fading.push((g, frame, local(r))),
+            None => {
+                if let Some(r) = anim.tiled(o, g.id, now) {
+                    ghosts.push((g, frame, local(r)));
+                }
+            }
         }
     }
     let arr = layout.arrange(o);
@@ -108,6 +117,9 @@ pub fn build(
             crate::layers::elements(&mut out, renderer, output, Layer::Top);
         }
     }
+    for (g, frame, r) in fading.into_iter().rev() {
+        out.extend(ghost_element(frame, r, anim.ghost_effect(g, now), deco));
+    }
     for (id, r, framed, gliding) in tiled.into_iter().chain(above).rev() {
         let Some(state) = windows.get_mut(id) else {
             continue;
@@ -135,26 +147,7 @@ pub fn build(
         }
     }
     for (g, frame, r) in ghosts.into_iter().rev() {
-        let Some((at, size)) = pixels(r) else {
-            continue;
-        };
-        let src = Rectangle::new(
-            frame.geometry.loc.to_f64(),
-            (f64::from(size.0), f64::from(size.1)).into(),
-        );
-        let ghost = Draw::Effect(EffectElement::new(
-            &frame.texture,
-            frame.scale,
-            frame.transform,
-            src,
-            at,
-            size,
-            anim.ghost_effect(g, now),
-        ));
-        out.push(match corner_clip(r, deco) {
-            Some(clip) => Draw::Clipped(ClipElement::new(ghost, clip)),
-            None => ghost,
-        });
+        out.extend(ghost_element(frame, r, anim.ghost_effect(g, now), deco));
     }
     if let Some(output) = output {
         crate::layers::elements(&mut out, renderer, output, Layer::Bottom);
@@ -437,6 +430,27 @@ impl RenderElement<VulkanRenderer> for EffectElement {
     }
 }
 
+fn ghost_element(frame: &LastFrame, r: Rect, effect: Effect, deco: &Decoration) -> Option<Draw> {
+    let (at, size) = pixels(r)?;
+    let src = Rectangle::new(
+        frame.geometry.loc.to_f64(),
+        (f64::from(size.0), f64::from(size.1)).into(),
+    );
+    let ghost = Draw::Effect(EffectElement::new(
+        &frame.texture,
+        frame.scale,
+        frame.transform,
+        src,
+        at,
+        size,
+        effect,
+    ));
+    Some(match corner_clip(r, deco) {
+        Some(clip) => Draw::Clipped(ClipElement::new(ghost, clip)),
+        None => ghost,
+    })
+}
+
 /// The rounded outline of a framed window at `r`, if it has one.
 fn corner_clip(r: Rect, deco: &Decoration) -> Option<Clip> {
     let radii = deco.radius.0;

Modified file: crates/monolith/src/state.rs+30 additions@@ -52,6 +52,9 @@ pub struct Input {
     /// The focus mouse-follows-focus last saw, so pointer-made focus
     /// changes can mark themselves as already followed.
     pub followed: Option<WindowId>,
+    /// The window under the pointer when it last moved.
+    pub hovered: Option<WindowId>,
+    pub warping: bool,
     pub cursor: crate::cursor::Cursor,
     pub cursor_status: CursorImageStatus,
 }
@@ -176,6 +179,8 @@ impl State {
                 drag: None,
                 move_inverted: false,
                 followed: None,
+                hovered: None,
+                warping: false,
                 cursor: crate::cursor::Cursor::load(),
                 cursor_status: CursorImageStatus::default_named(),
             },
@@ -317,6 +322,31 @@ impl State {
         for (id, from, to) in glides {
             self.wm.anim.glide(id, from, to, now);
         }
+        let scratch = |wm: &Wm, id| wm.layout.window(id).is_some_and(|w| w.scratchpad.is_some());
+        let summoned: Vec<WindowId> = shown
+            .iter()
+            .filter(|&&(id, _, kind, _)| {
+                kind == Kind::Floating
+                    && scratch(&self.wm, id)
+                    && self
+                        .wm
+                        .get(id)
+                        .is_some_and(|s| s.placed.is_none() && !s.awaiting_buffer)
+            })
+            .map(|s| s.0)
+            .collect();
+        let dismissed: Vec<(WindowId, Rect, OutputId)> = self
+            .wm
+            .iter()
+            .filter(|&(id, _)| scratch(&self.wm, id) && !shown.iter().any(|s| s.0 == id))
+            .filter_map(|(id, s)| s.placed.map(|(_, r, o)| (id, r, o)))
+            .collect();
+        for id in summoned {
+            self.wm.anim.spawned(id, now);
+        }
+        for (id, r, o) in dismissed {
+            self.fade_out(id, r, o);
+        }
         for (_, s) in self.wm.iter_mut() {
             s.placed = None;
         }

Modified file: crates/monolith/src/windows.rs+42 additions−22 deletions@@ -1,7 +1,7 @@
 use crate::anim::Ghost;
 use crate::state::{State, now_ns};
 use crate::wm::{LastFrame, identity, root};
-use monolith_layout::{Rect, WindowId};
+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};
@@ -146,36 +146,56 @@ impl State {
         else {
             return;
         };
-        let Some(surface) = root(window) else {
-            return;
-        };
-        let _ = import_surface_tree(&mut self.renderer, &surface);
-        let context = self.renderer.context_id();
-        let snapshot = with_renderer_surface_state(&surface, |s| {
-            s.texture::<VulkanTexture>(context.clone())
-                .cloned()
-                .map(|t| (t, s.buffer_scale(), s.buffer_transform()))
-        })
-        .flatten();
-        if let Some((texture, scale, transform)) = snapshot {
-            self.wm.last_frames.insert(
-                id,
-                LastFrame {
-                    texture,
-                    scale,
-                    transform,
-                    geometry: window.geometry(),
-                },
-            );
+        if let Some(frame) = 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,
+            });
+        }
+    }
+
+    /// 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;
+        };
+        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),
             });
         }
     }
 
+    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| {
+            s.texture::<VulkanTexture>(context.clone())
+                .cloned()
+                .map(|texture| LastFrame {
+                    texture,
+                    scale: s.buffer_scale(),
+                    transform: s.buffer_transform(),
+                    geometry,
+                })
+        })
+        .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 618afeb78754

Commit `618afeb78754`