Remove lateral scrolling scaffolding.

PandorasFox · claude · PandorasFox · commit 209945193b97 · 2025-09-28T23:45:43.000-07:00
I wasn't sure if the niri windows IPC update was going to be sufficient
for my purposes here - tl;dr it isn't (no events emitted when a column
is centered -&gt; not enough information to deduce when to scroll). So, I'm
removing all that jazz.

Because I had already implemented the relevant bits on the render side
(and had previously stubbed out the Niri side to just default-value 50%
for the scroll every time on the x-axis), I used claude to munge all the
window IPC bits for me to evaluate if it would be a sufficiently
pleasing experience. It wasn't, so I cleaned up all the resulting work.

Co-Authored-By: Claude &lt;noreply@anthropic.com&gt;
diff --git a/src/pithos/commands.rs b/src/pithos/commands.rs
@@ -6,10 +6,8 @@ pub enum RenderMode {
     // single image
     Static, // will scale up/down to fill
     ScrollVertical,
-    ScrollLateral,
-    // scrolling both directions will be trickier to implement. later problem.
-    // hello from later me: honestly it's probably easier than I thought:
-    // the agent can enforce positional state well, & correcting-on-the-fly looks better than expected
+    // ScrollLateral, // not using this in niri agent presently; not enough IPC to cleanly animate on
+    // most of the logic remains in comments; could be useful for other compositors with portrait monitors (?).
 }
 
 // ===== COMMAND STRUCTS =====
diff --git a/src/pithos/misc.rs b/src/pithos/misc.rs
@@ -137,15 +137,10 @@ pub fn get_viewport_dimensions(
             let viewport_height = (width_ratio * output_height as f64).round() as i32;
             (viewport_width, viewport_height)
         }
-        RenderMode::ScrollLateral => {
-            let viewport_width = (height_ratio * output_width as f64).round() as i32;
-            let viewport_height = image_height;
-            (viewport_width, viewport_height)
-        }
     }
 }
 
-// i used claude pro to generate these tests, with some nudging about what the expectations were.
+// i used Claude to generate these tests, with some nudging about what the expectations were.
 // it worked reasonably well and didn't actually take that long, and (after fixing the one test
 // that got horizontal and vertical confused), the tests did show my function worked. yippee :)
 #[cfg(test)]
@@ -211,22 +206,6 @@ mod tests {
         assert!((viewport_ratio - output_ratio).abs() < 0.01);
     }
 
-    #[test]
-    fn test_scroll_lateral_mode() {
-        // In lateral scroll mode, viewport height = image height
-        // viewport width scaled to maintain output aspect ratio
-        let (vw, vh) = get_viewport_dimensions(4000, 1500, 1920, 1080, RenderMode::ScrollLateral);
-        assert_eq!(vh, 1500); // Full image height
-        let expected_width = 2667;
-        assert_eq!(vw, expected_width);
-        assert!(vw <= 4000); // Viewport width <= image width
-        assert!(vh <= 1500); // Viewport height <= image height
-
-        let output_ratio = 1920.0 / 1080.0;
-        let viewport_ratio = vw as f64 / vh as f64;
-        assert!((viewport_ratio - output_ratio).abs() < 0.01);
-    }
-
     #[test]
     fn test_laptop_resolutions_with_web_images() {
         // 1366x768 laptop with typical web image 1920x1080
@@ -292,15 +271,6 @@ mod tests {
         let viewport_ratio = vw as f64 / vh as f64;
         assert!((viewport_ratio - output_ratio).abs() < 0.01);
 
-        // Lateral scroll: ultrawide with wide panorama
-        let (vw, vh) = get_viewport_dimensions(12000, 2000, 3440, 1440, RenderMode::ScrollLateral);
-        assert_eq!(vh, 2000);
-        assert!(vw <= 12000);
-        assert!(vh <= 2000);
-        let output_ratio = 3440.0 / 1440.0;
-        let viewport_ratio = vw as f64 / vh as f64;
-        assert!((viewport_ratio - output_ratio).abs() < 0.01);
-
         // Vertical scroll: 4K monitor with very tall image
         let (vw, vh) = get_viewport_dimensions(3000, 15000, 3840, 2160, RenderMode::ScrollVertical);
         assert_eq!(vw, 3000);
diff --git a/src/threads/lockscreen.rs b/src/threads/lockscreen.rs
@@ -41,54 +41,7 @@ impl Cerberus {
         //self.raise_lockscreen();
         //self.listen_for_unlock()
     }
-    /*
-    get wayland globals:
-        connection, compositor, shm, outputs, viewport. create globals struct, no optionals, just arcs.
-        bind ext_session_lock_manager_v1 => acquire session lock - lives in-thread
-        spawn render threads per output; their state lives in the vec<(output_state, wloutput)> hamburger. they only get connection<state> and path (evaluate cloning this ? it's mut ? fuck)
-        primary lock thread continues on to input parsing, sending to.... oh god, the channels.
 
-    what if we do this all in one thread? what if we just process input, then dispatch events for frame callbacks?
-    => nothing can block ever
-
-    so. we need to *also* put the receivers in the output state, and arc them, on output::done during the initial callback hell.
-
-    we also need to make sure that we *cleanly* handle the callbacks for mode changes. We'll want to send that
-    into its own callback, which can evaluate the proper actions to take - i believe we will want to destroy the active surface,
-    and create a new lock_surface
-
-    ... so we need a way to ask the input threa-.
-    ..... so we need a main thread that holds the input thread, the ext_session_lock, and the output render threads.
-    ... sounds familiar.
-    ..... (clutches my head)
-    .... so. the main thread will grab everything that's needed. it will hold the connection, the globals, etc.
-    ...  it will acquire the lock, _and then_ spawn the thread that handles input, and the lockscreen thread.
-    ... the lockscreen thread will be responsible for managing the surfaces attached to a given WlOutput.
-    .... it will manage the state (attached image, buffer, which lockscreen(s) gets the indicators) with its config blob
-    => how do we get the current lockscreen viewport state for ourselves?
-    ==> we should be able to fetch the offsets from the agent at lock time
-    ===> niri agent needs a refactor to have a .getState {output: (image, mode, offset)} (and an updateState.... yeah....)
-    ...  it will dispatch events for frame draws
-    ...  it will read its event queue from the input thread
-    ...  LastAction Instance::now whenever an event from event queue => reset state
-    ...  it will use subsurfaces to separate wallpaper bottom layer from (cairo?) canvas upper layer
-    ...  it will have appropriate handling of when the callback necessitates surface recreation (and wloutput object remapping in the vec as well i presume, oh god)
-    ...  overall actually sounds quite pleasant
-    ... the main thread will wait for the AUTH_FINISH response from lock thread
-    ... IMMEDIATELY unlock and destroy() the lock. "OBJECTS CREATED ARE STILL VALID"
-    ... upon which it passes that on to the lockscreen thread (exits gracefully) => up the surfaces and releases them all => we rejoice
-    ... because the underlying compositor block should be gone, we can maybe opacity lighten? hmmm? eyewiggles?
-    ... OPACITY LIGHTEN AND ZOOM IN MAYBE?? :eyes:
-
-    okay yeah that's enough thinking on that
-
-    methods accessible on the 'handler' (cerberus) should be defined by trait so pandora (hecate ? ) can reuse
-
-
-    and im gonna write it all by hand because this is a security sensitive application and i wish to take it slowly and carefully!
-    (so i can reuse the well written independent functions for the normal render threads/architecture)
-    hggggh
-    */
     fn _log(&self, msg: String) {
         self._do_log(LogLevel::DEFAULT, format!("[lockscreen] {msg}"));
     }
diff --git a/src/threads/niri.rs b/src/threads/niri.rs
@@ -119,6 +119,7 @@ struct OutputState {
     current_image: String,
     mode: Option<RenderMode>,
     max_workspace_idx: u8,
+    active_workspace_idx: Option<u8>,
 }
 
 #[derive(Default)]
@@ -128,13 +129,6 @@ struct NiriProcessor {
     workspaces: Vec<Workspace>,
 }
 
-/*
-    TODO: refactor/implement lateral scrolling position within workspaces
-    handle window change events to (re)calculate scrolling positions of workspaces
-    plumb scroll command generation to use desired workspace scrolling position
-    
-*/
-
 impl NiriProcessor {
     fn update_config(
         &mut self,
@@ -144,33 +138,54 @@ impl NiriProcessor {
         for new_output_conf in &new_config.outputs {
             let p = pandora.clone();
             let new_mode = new_output_conf.mode.unwrap_or(RenderMode::Static);
-            let (output_name, state) = match self
-                .outputs
-                .iter_mut()
-                .find(|o| o.0 == new_output_conf.name)
-            {
-                Some(v) => v,
-                None => continue,
+
+            // First, find the output and check if we need to update
+            let needs_update = if let Some((_, state)) = self.outputs.iter().find(|o| o.0 == new_output_conf.name) {
+                state.current_image != new_output_conf.image || state.mode.unwrap_or(RenderMode::Static) != new_mode
+            } else {
+                continue; // Output not found
             };
-            if state.current_image != new_output_conf.image
-                || state.mode.unwrap_or(RenderMode::Static) != new_mode
-            {
+
+            if needs_update {
+                let position = self.get_current_position_for_output(&new_output_conf.name, new_mode);
                 let cmd = RenderCommand {
-                    output: output_name.clone(),
+                    output: new_output_conf.name.clone(),
                     image: new_output_conf.image.clone(),
                     mode: new_mode,
-                    position: (0.0, 0.0), // todo: should compute scroll position + plumb this on the other end
+                    position,
                 };
                 p.handle_cmd(&CommandType::Tc(RenderThreadCommand::Render(cmd)));
 
                 // Update state to reflect the change
-                state.current_image = new_output_conf.image.clone();
-                state.mode = Some(new_mode);
+                if let Some((_, state)) = self.outputs.iter_mut().find(|o| o.0 == new_output_conf.name) {
+                    state.current_image = new_output_conf.image.clone();
+                    state.mode = Some(new_mode);
+                }
             }
         }
         self.config = new_config;
     }
 
+    fn get_current_position_for_output(&self, output_name: &str, mode: RenderMode) -> (f64, f64) {
+        match mode {
+            RenderMode::Static => (0.0, 0.0),
+            RenderMode::ScrollVertical => {
+                // Use existing vertical scroll logic
+                let output = match self.outputs.iter().find(|o| o.0 == output_name) {
+                    Some((_, state)) => state,
+                    None => return (0.0, 0.0),
+                };
+
+                let active_workspace_idx = output.active_workspace_idx.unwrap_or(1);
+                let mut scroll_percent = 100.0 * (active_workspace_idx - 1) as f64 / (output.max_workspace_idx - 1) as f64;
+                if scroll_percent.is_nan() {
+                    scroll_percent = 50.0;
+                }
+                (50.0, scroll_percent)
+            }
+        }
+    }
+
     fn update_workspaces(&mut self, workspaces: &Vec<Workspace>) {
         for workspace in workspaces {
             if workspace.output.is_some() {
@@ -181,8 +196,14 @@ impl NiriProcessor {
                 };
                 let cur_max_idx = output_state.1.max_workspace_idx;
                 output_state.1.max_workspace_idx = u8::max(workspace.idx, cur_max_idx);
+
+                // Update active workspace index
+                if workspace.is_active {
+                    output_state.1.active_workspace_idx = Some(workspace.idx);
+                }
             }
         }
+
         self.workspaces = workspaces.clone();
     }
 
@@ -205,15 +226,17 @@ impl NiriProcessor {
                     current_image: img_path,
                     mode: output_config.mode,
                     max_workspace_idx: 0,
+                    active_workspace_idx: None,
                 };
                 self.outputs.push((output_name.clone(), output_state));
             }
         }
         self.update_workspaces(&workspaces);
+
     }
 
-    fn reseat_scroll_positions(&self, pandora: Arc<dyn Daemon + Send + Sync>) {
-        for workspace in &self.workspaces {
+    fn reseat_scroll_positions(&mut self, pandora: Arc<dyn Daemon + Send + Sync>) {
+        for workspace in &self.workspaces.clone() {
             if workspace.is_active {
                 self.gen_scroll_cmd_for_workspace_id(pandora.clone(), workspace.id);
             }
@@ -228,21 +251,16 @@ impl NiriProcessor {
                     output.1.max_workspace_idx = 0;
                 }
                 self.update_workspaces(&workspaces);
+
                 self.reseat_scroll_positions(pandora.clone());
             }
             Event::WorkspaceActivated { id, .. } => {
                 self.gen_scroll_cmd_for_workspace_id(pandora.clone(), id)
             }
-            Event::WindowFocusChanged { id: _ } => {
-                self.poke(pandora.clone());
-                // TODO - niri includes tile layouts in WindowLayout structs now
-                // we should keep track of the full pixel width of each workspace,
-                // as well as the position of the focused window within that mosaic
-                // and compute a scroll percentage based on that
-                // we'll want to then start using that whenever we gen_scroll_cmd,
-                // and just trust the render thread to discard or use as needed.
-            }
-            Event::WindowLayoutsChanged { changes } => {
+            //Event::WindowFocusChanged { id: _id } => {
+            //    self.poke(pandora.clone());
+            //}
+            Event::WindowLayoutsChanged { changes: _changes } => {
                 self.poke(pandora.clone());
             }
             _ => (), // idc about other events rn
@@ -287,10 +305,6 @@ impl NiriProcessor {
                 });
                 Some(CommandType::Tc(cmd))
             }
-            Some(RenderMode::ScrollLateral) => {
-                // TODO: implement horizontal scrolling for window changes
-                todo!()
-            }
             Some(RenderMode::Static) => None,
         } {
             pandora.verbose("niri-agent", format!("emitting command {cmd:?}"));
diff --git a/src/wayland/render_base.rs b/src/wayland/render_base.rs
@@ -439,7 +439,7 @@ impl WallpaperRenderState {
     pub fn scroll(
         &mut self,
         conn: &mut Connection<RenderThreadState>,
-        scroll_x: f64,
+        _scroll_x: f64,
         scroll_y: f64,
     ) {
         // scroll (x|y) track the % (0.0 => 100.0) of the center of the viewport along each dimension
@@ -450,7 +450,6 @@ impl WallpaperRenderState {
         match self.mode {
             RenderMode::Static => return,
             RenderMode::ScrollVertical => self.height.scroll(scroll_y, self.slowdown),
-            RenderMode::ScrollLateral => self.width.scroll(scroll_x, self.slowdown),
         };
 
         if !is_already_scrolling {
@@ -757,19 +756,16 @@ fn image_to_file(
     width: u32,
     height: u32,
 ) -> (i32, i32) {
+    // note: should wrap this and fall back to static if vert won't work, or infer it ourselves
     let scale_to = match mode {
         RenderMode::Static => (Some(width), Some(height)),
         RenderMode::ScrollVertical => (Some(width), None),
-        RenderMode::ScrollLateral => (None, Some(height)),
     };
 
     pandora.clone().load_image(path).unwrap();
     let (img_width, img_height) = pandora.clone().read_img_to_file(path, f, scale_to).unwrap();
 
     if img_width < width || img_height < height {
-        // TODO: better handling of this case
-        // idealy coerce to static at runtime and just log
-        // im lazy for now tho
         panic!(
             "INVALID CONFIG COMBINATION: image scaled to {img_width} x {img_height}, but output is {width} by {height}.\nSwitch to STATIC mode for this image or try scrolling in the other direction."
         )
