feat: display transformations

PandorasFox · PandorasFox · commit d22a0b407834 · 2025-09-29T12:42:37.000-07:00
refactors image loading/mode-setting to smoothly fall back to static mode, which is generally necessary when rotating a display.
diff --git a/src/daemon.rs b/src/daemon.rs
@@ -15,8 +15,7 @@ pub trait Daemon {
 
     fn handle_cmd(self: Arc<Self>, cmd: &CommandType);
 
-    fn load_image(self: Arc<Self>, path: &str) -> Result<(), DaemonError>;
-    fn get_image_dimensions(self: Arc<Self>, img: &str) -> Result<(u32, u32), DaemonError>;
+    fn load_image(self: Arc<Self>, path: &str) -> Result<(u32, u32), DaemonError>;
     fn read_img_to_file(
         self: Arc<Self>,
         img: &str,
diff --git a/src/pandora.rs b/src/pandora.rs
@@ -81,7 +81,7 @@ impl Daemon for Pandora {
             Anchor::Top | Anchor::Left | Anchor::Bottom | Anchor::Right,
         );
         layer_surface.set_exclusive_zone(conn, -1);
-        
+
         wl_surface.commit(conn);
         conn.blocking_roundtrip().unwrap();
     }
@@ -94,22 +94,23 @@ impl Daemon for Pandora {
         };
     }
 
-    fn load_image(self: Arc<Self>, path: &str) -> Result<(), DaemonError> {
+    fn load_image(self: Arc<Self>, path: &str) -> Result<(u32, u32), DaemonError> {
         let start = std::time::Instant::now();
         {
             // read lock
             match self.images.read() {
                 Ok(images_check) => {
-                    if images_check.contains_key(&path.to_string()) {
+                    if let Some(img) = images_check.get(&path.to_string()) {
                         self.debug("pandora", format!("file {} already loaded", path));
-                        return Ok(());
+                        return Ok((img.width(), img.height()));
                     }
                 }
                 Err(e) => panic!("{e:?}"),
             }
         }
         let img = ImageReader::open(path)?.decode()?;
         let img_loaded = std::time::Instant::now();
+        let dimensions = (img.width(), img.height());
         self.verbose(
             "pandora",
             format!("image loaded in {:?}", img_loaded - start),
@@ -118,7 +119,7 @@ impl Daemon for Pandora {
             //write lock
             match self.images.write() {
                 Ok(mut images_table) => {
-                    if images_table.contains_key(&path.to_string()) {
+                    if let Some(existing_img) = images_table.get(&path.to_string()) {
                         // written while we loaded the image! try to eliminate this case as much as we can.
                         self.verbose(
                             "pandora",
@@ -127,7 +128,7 @@ impl Daemon for Pandora {
                                 path
                             ),
                         );
-                        return Ok(());
+                        return Ok((existing_img.width(), existing_img.height()));
                     }
                     images_table.insert(path.to_string(), img /*.into_rgba8() */);
                     let img_inserted = std::time::Instant::now();
@@ -140,27 +141,13 @@ impl Daemon for Pandora {
                             img_inserted - start
                         ),
                     );
-                    Ok(())
+                    Ok(dimensions)
                 }
                 Err(e) => panic!("{e:?}"),
             }
         }
     }
 
-    fn get_image_dimensions(self: Arc<Self>, img: &str) -> Result<(u32, u32), DaemonError> {
-        match self.images.read() {
-            Ok(images_table) => {
-                if images_table.contains_key(&img.to_string()) {
-                    let image = images_table.get(&img.to_string()).unwrap();
-                    Ok((image.width(), image.height()))
-                } else {
-                    Err(CommandError::from_message("image not found in cache"))
-                }
-            }
-            Err(_) => Err(DaemonError::PoisonError),
-        }
-    }
-
     fn read_img_to_file(
         self: Arc<Self>,
         img: &str,
@@ -294,7 +281,9 @@ impl Pandora {
         if fs::exists(path.clone()).is_err() {
             return Err(format!("could not preload {path} during init"));
         }
-        thread::spawn(move || self.load_image(&path));
+        thread::spawn(move || {
+            let _ = self.load_image(&path);
+        });
         Ok(())
     }
 
diff --git a/src/pithos/misc.rs b/src/pithos/misc.rs
@@ -1,4 +1,7 @@
-use fast_image_resize::{images::Image, pixels::{U8x3, U8x4}};
+use fast_image_resize::{
+    images::Image,
+    pixels::{U8x3, U8x4},
+};
 use std::{
     fs::File,
     io::{BufWriter, Write},
@@ -16,15 +19,13 @@ pub fn img_into_buffer(img: &Image, buf: &mut BufWriter<&File>) {
             let (r, g, b, a) = (pixel.0[0], pixel.0[1], pixel.0[2], pixel.0[3]);
             buf.write_all(&[b, g, r, a]).unwrap();
         }
-    } else {
-        if let Some(typed) = img.typed_image::<U8x3>() {
-            for pixel in typed.pixels() {
-                let (r, g, b, a) = (pixel.0[0], pixel.0[1], pixel.0[2], u8::max_value());
-                buf.write_all(&[b, g, r, a]).unwrap();
-            }
-        } else {
-            panic!("image could not be coerced to U8x4");
+    } else if let Some(typed) = img.typed_image::<U8x3>() {
+        for pixel in typed.pixels() {
+            let (r, g, b, a) = (pixel.0[0], pixel.0[1], pixel.0[2], u8::MAX);
+            buf.write_all(&[b, g, r, a]).unwrap();
         }
+    } else {
+        panic!("image could not be coerced to U8x4");
     }
 
     let loop_end = std::time::Instant::now();
diff --git a/src/threads/niri.rs b/src/threads/niri.rs
@@ -87,7 +87,7 @@ fn run(
         let mut read_event = socket.read_events();
         loop {
             match read_event() {
-                Ok(event ) => {
+                Ok(event) => {
                     processor.process(pandora.clone(), event);
                     match cmd_queue.lock() {
                         Ok(channel) => {
@@ -102,10 +102,11 @@ fn run(
                             }
                         }
                         Err(e) => {
-                            pandora.log("niri-agent", format!("error acquiring channel lock: {e:?}"));
+                            pandora
+                                .log("niri-agent", format!("error acquiring channel lock: {e:?}"));
                         }
                     }
-                },
+                }
                 Err(e) => {
                     pandora.debug("niri-agent", format!("event read failed {e:?}"));
                 }
@@ -130,24 +131,24 @@ struct NiriProcessor {
 }
 
 impl NiriProcessor {
-    fn update_config(
-        &mut self,
-        new_config: DaemonConfig,
-        pandora: Arc<dyn Daemon + Send + Sync>,
-    ) {
+    fn update_config(&mut self, new_config: DaemonConfig, pandora: Arc<dyn Daemon + Send + Sync>) {
         for new_output_conf in &new_config.outputs {
             let p = pandora.clone();
             let new_mode = new_output_conf.mode.unwrap_or(RenderMode::Static);
 
             // 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
+            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 needs_update {
-                let position = self.get_current_position_for_output(&new_output_conf.name, new_mode);
+                let position =
+                    self.get_current_position_for_output(&new_output_conf.name, new_mode);
                 let cmd = RenderCommand {
                     output: new_output_conf.name.clone(),
                     image: new_output_conf.image.clone(),
@@ -157,7 +158,11 @@ impl NiriProcessor {
                 p.handle_cmd(&CommandType::Tc(RenderThreadCommand::Render(cmd)));
 
                 // Update state to reflect the change
-                if let Some((_, state)) = self.outputs.iter_mut().find(|o| o.0 == new_output_conf.name) {
+                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);
                 }
@@ -177,7 +182,8 @@ impl NiriProcessor {
                 };
 
                 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;
+                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;
                 }
@@ -232,7 +238,6 @@ impl NiriProcessor {
             }
         }
         self.update_workspaces(&workspaces);
-
     }
 
     fn reseat_scroll_positions(&mut self, pandora: Arc<dyn Daemon + Send + Sync>) {
diff --git a/src/threads/render.rs b/src/threads/render.rs
@@ -98,12 +98,25 @@ impl WallpaperThread {
             }
 
             // Handle outputs that need re-initialization after transform changes
-            for (_, output_state) in &mut state.outputs {
+            let mut output_indices_to_reinit = Vec::new();
+
+            // Collect outputs that need reinitialization
+            for (i, (_, output_state)) in state.outputs.iter().enumerate() {
                 if output_state.needs_reinit {
-                    output_state.reinit();
+                    output_indices_to_reinit.push(i);
                 }
             }
 
+            // Process each output by temporarily removing it from the state
+            for &output_idx in &output_indices_to_reinit {
+                let (mut output, mut output_state) = state.outputs.swap_remove(output_idx);
+
+                output_state.reinit(conn, &mut output, state);
+
+                // Put the output back
+                state.outputs.insert(output_idx, (output, output_state));
+            }
+
             self.handle_inbound_commands(conn, state);
 
             if received_events.is_err() {
@@ -223,11 +236,11 @@ impl WallpaperThread {
             done: output_state.done,
             transform: output_state.transform,
             render_state: crate::wayland::render_base::OutputRenderStateVariety::None,
+            needs_reinit: false,
         };
 
         // Update existing wallpaper state with new image
-        if let OutputRenderStateVariety::Wallpaper(wallpaper_state) =
-            &mut output_state.render_state
+        if let OutputRenderStateVariety::Wallpaper(wallpaper_state) = &mut output_state.render_state
         {
             wallpaper_state.update_image(
                 conn,
@@ -297,9 +310,7 @@ impl WallpaperThread {
             }
         };
 
-        if let OutputRenderStateVariety::Wallpaper(render_state) =
-            &mut output_state.render_state
-        {
+        if let OutputRenderStateVariety::Wallpaper(render_state) = &mut output_state.render_state {
             render_state.scroll(conn, cmd.position_x, cmd.position_y);
         } else {
             self.debug("received scroll command, but no wallpaper state found on attached outputs. reseat pending/workspace change from output disconnect?".to_string());
diff --git a/src/wayland/render_base.rs b/src/wayland/render_base.rs
