`6b29169`

Default to per-monitor wallpapers, add --span flag

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 6b291697fcea577f413c6d527377f342a1aa76ed
Parents: aff0b13
Tree: 51d5d37

3 changed files

Status	File	+	-
M	`garbg/src/daemon/state.rs`	48	20
M	`garbg/src/ipc/protocol.rs`	3	0
M	`garbg/src/main.rs`	42	13

garbg/src/daemon/state.rsmodified

      /// Handle an IPC command
      fn handle_command(&mut self, cmd: Command) -> Response {
          match cmd {
 -            Command::Set { source, mode, monitor: _, interval_secs, shuffle, animate, max_fps } => {
 +            Command::Set { source, mode, monitor: _, interval_secs, shuffle, animate, max_fps, span } => {
                  let scale_mode = mode.unwrap_or(self.state.config.general.mode);
                  // Stop any existing animation first
+                 }
                  // Set up slideshow with the new source (static image)
 -                match self.set_wallpaper_with_options(&source, scale_mode, shuffle, interval_secs) {
 +                match self.set_wallpaper_with_options(&source, scale_mode, shuffle, interval_secs, span) {
                      Ok(_) => {
                          // Update slideshow interval
                          self.state.slideshow_interval = interval_secs.map(Duration::from_secs);
+             }
              Command::SetWorkspace { workspace, source, mode } => {
                  let scale_mode = mode.unwrap_or(self.state.config.general.mode);
 -                // Only set if we're on this workspace
 +                // Only set if we're on this workspace (default to per-monitor)
                  if self.state.current_workspace == workspace {
 -                    match self.set_wallpaper_from_source(&source, scale_mode, false) {
 +                    match self.set_wallpaper_from_source(&source, scale_mode, false, false) {
                          Ok(_) => Response::ok(),
                          Err(e) => Response::error(e.to_string()),
+                     }
              return Ok(());
+         }
 -        self.set_wallpaper_from_source(&source, mode, shuffle)
 +        // Default to per-monitor (span = false)
 +        self.set_wallpaper_from_source(&source, mode, shuffle, false)
+     }
      /// Start an animated image playback (GIF, WebP, APNG, or video)
          mode: ScaleMode,
          shuffle: bool,
          _interval_secs: Option<u64>,
 +        span: bool,
      ) -> Result<()> {
 -        self.set_wallpaper_from_source(source, mode, shuffle)
 +        self.set_wallpaper_from_source(source, mode, shuffle, span)
+     }
      /// Set wallpaper from a source (file, directory, or URL)
 -    fn set_wallpaper_from_source(&mut self, source: &str, mode: ScaleMode, shuffle: bool) -> Result<()> {
 +    fn set_wallpaper_from_source(&mut self, source: &str, mode: ScaleMode, shuffle: bool, span: bool) -> Result<()> {
          // Expand path
          let expanded = shellexpand::tilde(source);
          let path = std::path::Path::new(expanded.as_ref());
              playlist.save()?;
              self.state.playlist = Some(playlist);
 -            self.set_wallpaper(&first, mode)?;
 +            self.set_wallpaper_with_span(&first, mode, span)?;
              tracing::info!(
                  "Playlist loaded: {} images{}",
          } else if source.starts_with("http://") || source.starts_with("https://") {
              // Remote URL
              let image = self.fetch_image(source)?;
 -            let conn = self.conn_mut()?;
 -            let (width, height) = conn.screen_dimensions();
 -            let scaled = scale_image(&image, width as u32, height as u32, mode);
 -            conn.set_wallpaper(&scaled)?;
 -            tracing::info!("Wallpaper set: {} (mode: {})", source, mode);
 +            self.set_image_with_span(&image, source, mode, span)?;
          } else {
              // Single file
 -            self.set_wallpaper(source, mode)?;
 +            self.set_wallpaper_with_span(source, mode, span)?;
+         }
          Ok(())
      /// Set wallpaper from a local file
      pub fn set_wallpaper(&mut self, source: &str, mode: ScaleMode) -> Result<()> {
 +        self.set_wallpaper_with_span(source, mode, false)
 +    }
++
 +    /// Set wallpaper from a local file with span option
 +    pub fn set_wallpaper_with_span(&mut self, source: &str, mode: ScaleMode, span: bool) -> Result<()> {
          let expanded = shellexpand::tilde(source);
          let image = ImageLoader::load_file(expanded.as_ref())?;
 -        let conn = self.conn_mut()?;
 -        let (width, height) = conn.screen_dimensions();
 -        let scaled = scale_image(&image, width as u32, height as u32, mode);
 -        conn.set_wallpaper(&scaled)?;
 +        self.set_image_with_span(&image, source, mode, span)
 +    }
++
 +    /// Set wallpaper from an image with span option
 +    fn set_image_with_span(&mut self, image: &image::RgbaImage, source: &str, mode: ScaleMode, span: bool) -> Result<()> {
 +        let conn = self.conn()?;
 +        let monitors = Monitor::get_all(conn).unwrap_or_default();
 -        tracing::info!("Wallpaper set: {} (mode: {})", source, mode);
 +        if !span && monitors.len() > 1 {
 +            // Per-monitor mode: scale wallpaper to each monitor individually
 +            let compositor = Compositor::new(&monitors);
 +            let wallpapers = Compositor::create_wallpapers_uniform(&monitors, image, mode);
 +            let composited = compositor.composite(&wallpapers);
 +            self.conn_mut()?.set_wallpaper(&composited)?;
++
 +            tracing::info!(
 +                "Wallpaper set on {} monitors: {} (mode: {})",
 +                monitors.len(),
 +                source,
 +                mode
 +            );
 +        } else {
 +            // Span mode or single monitor: scale to full screen
 +            let conn = self.conn_mut()?;
 +            let (width, height) = conn.screen_dimensions();
 +            let scaled = scale_image(image, width as u32, height as u32, mode);
 +            conn.set_wallpaper(&scaled)?;
++
 +            tracing::info!("Wallpaper set: {} (mode: {})", source, mode);
 +        }
          Ok(())
+     }
          if let Some(config) = ws_config {
              let mode = config.mode.unwrap_or(self.state.config.general.mode);
 -            self.set_wallpaper_from_source(&config.source, mode, false)?;
 +            // Default to per-monitor (span = false)
 +            self.set_wallpaper_from_source(&config.source, mode, false, false)?;
+         }
          Ok(())

garbg/src/ipc/protocol.rsmodified

          /// Max FPS for animations (default: 60)
          #[serde(default = "default_max_fps")]
          max_fps: u32,
 +        /// Span wallpaper across all monitors (default: false, per-monitor)
 +        #[serde(default)]
 +        span: bool,
      },
      /// Set wallpaper for a specific workspace

garbg/src/main.rsmodified

          /// Max FPS for animations (default: 60)
          #[arg(long, default_value = "60")]
          max_fps: u32,
++
 +        /// Span wallpaper across all monitors (default: per-monitor)
 +        #[arg(long)]
 +        span: bool,
      },
      /// Advance to the next image in the playlist
          .init();
      match cli.command {
 -        Commands::Set { source, mode, monitor, random, interval, animate, max_fps } => {
 -            set_wallpaper(&source, &mode, monitor.as_deref(), random, interval, animate, max_fps)?;
 +        Commands::Set { source, mode, monitor, random, interval, animate, max_fps, span } => {
 +            set_wallpaper(&source, &mode, monitor.as_deref(), random, interval, animate, max_fps, span)?;
+         }
          Commands::Next => {
              cmd_next()?;
      interval: Option<Duration>,
      animate: bool,
      max_fps: u32,
 +    span: bool,
  ) -> Result<()> {
      use garbg::config::ScaleMode;
      use garbg::ipc::send_command_blocking;
          shuffle: random,
          animate,
          max_fps,
 +        span,
      };
      // Try to send to daemon (should be ready if systemd started it correctly)
+     }
      // Set the initial wallpaper (handles animated GIFs automatically)
 -    set_single_wallpaper(&resolved_source, scale_mode, animate, max_fps)?;
 +    set_single_wallpaper(&resolved_source, scale_mode, animate, max_fps, span)?;
      // If interval specified and daemon not running, enter foreground rotation loop
      // Note: --interval mode doesn't support animations (would require stopping animation to rotate)
                  playlist_state.save()?;
                  // Static mode for rotation (animation would conflict)
 -                set_single_wallpaper(&next_img, playlist_state.mode, false, 60)?;
 +                set_single_wallpaper(&next_img, playlist_state.mode, false, 60, span)?;
                  tracing::info!(
                      "Rotated to [{}/{}]: {}",
                      playlist_state.current_index + 1,
  ///
  /// If `animate` is true and the source is an animated GIF, this will block
  /// and play the animation until interrupted (Ctrl+C).
 +///
 +/// If `span` is true, the wallpaper is stretched across all monitors.
 +/// If `span` is false (default), the wallpaper is scaled to each monitor individually.
  fn set_single_wallpaper(
      source: &str,
      mode: garbg::config::ScaleMode,
      animate: bool,
      max_fps: u32,
 +    span: bool,
  ) -> Result<()> {
      use garbg::daemon::{AnimationConfig, AnimationLoop};
      use garbg::media::{AnimatedGif, ImageLoader};
 -    use garbg::x11::Connection;
 +    use garbg::x11::{Connection, Compositor, Monitor};
      tracing::info!("Setting wallpaper: {}", source);
          ImageLoader::load_file(source)?
      };
 -    let (width, height) = conn.screen_dimensions();
 -    let scaled = garbg::media::scale_image(&image, width as u32, height as u32, mode);
 -    conn.set_wallpaper(&scaled)?;
 +    // Check for multiple monitors
 +    let monitors = Monitor::get_all(&conn).unwrap_or_default();
++
 +    if !span && monitors.len() > 1 {
 +        // Per-monitor mode: scale wallpaper to each monitor individually
 +        let compositor = Compositor::new(&monitors);
 +        let wallpapers = Compositor::create_wallpapers_uniform(&monitors, &image, mode);
 +        let composited = compositor.composite(&wallpapers);
 +        conn.set_wallpaper(&composited)?;
++
 +        tracing::info!(
 +            "Wallpaper set on {} monitors: {} (mode: {:?})",
 +            monitors.len(),
 +            source,
 +            mode
 +        );
 +    } else {
 +        // Span mode or single monitor: scale to full screen
 +        let (width, height) = conn.screen_dimensions();
 +        let scaled = garbg::media::scale_image(&image, width as u32, height as u32, mode);
 +        conn.set_wallpaper(&scaled)?;
 -    tracing::info!("Wallpaper set: {} ({}x{}, mode: {:?})", source, width, height, mode);
 +        tracing::info!("Wallpaper set: {} ({}x{}, mode: {:?})", source, width, height, mode);
 +    }
      Ok(())
+ }
      let next_image = state.next().to_string();
      state.save()?;
 -    // No animation for quick navigation commands
 -    set_single_wallpaper(&next_image, state.mode, false, 60)?;
 +    // No animation for quick navigation commands, default to per-monitor
 +    set_single_wallpaper(&next_image, state.mode, false, 60, false)?;
      tracing::info!(
          "Next [{}/{}]: {}",
      let prev_image = state.prev().to_string();
      state.save()?;
 -    // No animation for quick navigation commands
 -    set_single_wallpaper(&prev_image, state.mode, false, 60)?;
 +    // No animation for quick navigation commands, default to per-monitor
 +    set_single_wallpaper(&prev_image, state.mode, false, 60, false)?;
      tracing::info!(
          "Prev [{}/{}]: {}",