add multi-monitor support via RandR

Status	File	+	-
M	`garchomp-ipc/src/lib.rs`	13	0
M	`garchomp/src/compositor/mod.rs`	13	3
M	`garchomp/src/main.rs`	13	0
M	`garchomp/src/x11/connection.rs`	117	0
M	`garchomp/src/x11/mod.rs`	1	1

garchomp-ipc/src/lib.rsmodified

      pub current_workspace: usize,
      pub effects_enabled: EffectsStatus,
      pub connected_to_gar: bool,
++    #[serde(default)]
++    pub monitors: Vec<MonitorStatus>,
++}
++
++/// Information about a monitor.
++#[derive(Debug, Clone, Serialize, Deserialize)]
++pub struct MonitorStatus {
++    pub name: String,
++    pub x: i16,
++    pub y: i16,
++    pub width: u16,
++    pub height: u16,
++    pub primary: bool,
+ }
  /// Status of compositor effects.

garchomp/src/compositor/mod.rsmodified

  use crate::config::LuaConfig;
  use crate::ipc::GarConnection;
  use crate::render::{GpuError, HdrConfig, Renderer, WindowRenderInfo};
--use crate::x11::{CompositeExt, Connection};
++use crate::x11::{CompositeExt, Connection, MonitorInfo};
  use garchomp_ipc::GarEvent;
  use std::collections::HashMap;
  use thiserror::Error;
      lua_config: Option<LuaConfig>,
      /// Root window background pixmap (wallpaper).
      root_pixmap: Option<u32>,
++    /// Monitor configuration from RandR.
++    pub monitors: Vec<MonitorInfo>,
  }
  impl Compositor {
          let width = screen.width_in_pixels as u32;
          let height = screen.height_in_pixels as u32;
--        // Initialize GPU renderer
++        // Initialize GPU renderer (vsync will be configured after loading Lua config)
          tracing::info!("Initializing GPU renderer for {}x{} surface", width, height);
--        let renderer = Renderer::new(overlay, width, height).await?;
++        let renderer = Renderer::new(overlay, width, height, crate::render::VSync::default()).await?;
          tracing::info!("GPU renderer initialized");
          // Subscribe to events on root window
              tracing::info!("Found root pixmap: {:#x}", pix);
          }
++        // Query monitor configuration
++        let monitors = conn.get_monitors().unwrap_or_default();
++
          let mut compositor = Self {
              conn,
              overlay,
              gar,
              lua_config,
              root_pixmap,
++            monitors,
          };
          // Get initial active window
          compositor.active_window = compositor.conn.get_active_window();
++        // Apply VSync setting from config
++        compositor.renderer.set_vsync(compositor.effects.vsync);
++        tracing::info!("VSync mode: {:?}", compositor.effects.vsync);
++
          // Apply HDR config if enabled
          if let Some(ref lua) = compositor.lua_config {
              let hdr_config = lua.get_hdr_config();

garchomp/src/main.rsmodified

+             }
+         }
          Request::Status => {
++            let monitors: Vec<garchomp_ipc::MonitorStatus> = compositor.monitors
++                .iter()
++                .map(|m| garchomp_ipc::MonitorStatus {
++                    name: m.name.clone(),
++                    x: m.x,
++                    y: m.y,
++                    width: m.width,
++                    height: m.height,
++                    primary: m.primary,
++                })
++                .collect();
++
              Response::Status(garchomp_ipc::CompositorStatus {
                  version: garchomp_ipc::PROTOCOL_VERSION,
                  window_count: compositor.windows.len(),
                      blur_strength: compositor.effects.blur_strength,
                  },
                  connected_to_gar: compositor.is_connected_to_gar(),
++                monitors,
              })
+         }
      };

garchomp/src/x11/connection.rsmodified

  use x11rb::connection::{Connection as X11Connection, RequestConnection};
  use x11rb::protocol::composite::ConnectionExt as CompositeConnectionExt;
  use x11rb::protocol::damage::ConnectionExt as DamageConnectionExt;
++use x11rb::protocol::randr::ConnectionExt as RandrConnectionExt;
  use x11rb::protocol::xfixes::ConnectionExt as XfixesConnectionExt;
  use x11rb::protocol::xproto::{ConnectionExt as XprotoConnectionExt, Screen, Window};
  use x11rb::rust_connection::RustConnection;
++/// Information about a monitor/output.
++#[derive(Debug, Clone)]
++pub struct MonitorInfo {
++    /// Monitor name (e.g., "DP-1", "HDMI-0").
++    pub name: String,
++    /// X position in pixels.
++    pub x: i16,
++    /// Y position in pixels.
++    pub y: i16,
++    /// Width in pixels.
++    pub width: u16,
++    /// Height in pixels.
++    pub height: u16,
++    /// Whether this is the primary monitor.
++    pub primary: bool,
++}
++
  #[derive(Error, Debug)]
  pub enum ConnectionError {
      #[error("failed to connect to X11 display")]
          reply.value32().and_then(|mut v| v.next()).filter(|&p| p != 0)
+     }
++
++    /// Query all monitors using RandR.
++    /// Returns a list of active monitors with their geometry.
++    pub fn get_monitors(&self) -> Result<Vec<MonitorInfo>> {
++        // Query RandR version first
++        let randr_version = self.conn.randr_query_version(1, 5)?.reply()?;
++        tracing::debug!(
++            "RandR version: {}.{}",
++            randr_version.major_version,
++            randr_version.minor_version
++        );
++
++        // Get screen resources
++        let resources = self.conn.randr_get_screen_resources(self.root())?.reply()?;
++
++        // Get primary output
++        let primary = self.conn.randr_get_output_primary(self.root())?.reply()?;
++        let primary_output = primary.output;
++
++        let mut monitors = Vec::new();
++
++        // Iterate through all CRTCs to find active outputs
++        for crtc in &resources.crtcs {
++            let crtc_info = match self.conn.randr_get_crtc_info(*crtc, 0)?.reply() {
++                Ok(info) => info,
++                Err(_) => continue,
++            };
++
++            // Skip disabled CRTCs
++            if crtc_info.width == 0 || crtc_info.height == 0 {
++                continue;
++            }
++
++            // Get output name from first connected output
++            for output in &crtc_info.outputs {
++                let output_info = match self.conn.randr_get_output_info(*output, 0)?.reply() {
++                    Ok(info) => info,
++                    Err(_) => continue,
++                };
++
++                // Convert name bytes to string
++                let name = String::from_utf8_lossy(&output_info.name).to_string();
++
++                monitors.push(MonitorInfo {
++                    name,
++                    x: crtc_info.x,
++                    y: crtc_info.y,
++                    width: crtc_info.width,
++                    height: crtc_info.height,
++                    primary: *output == primary_output,
++                });
++
++                // Only take first output per CRTC
++                break;
++            }
++        }
++
++        // Sort by position (left to right, top to bottom)
++        monitors.sort_by(|a, b| {
++            if a.y != b.y {
++                a.y.cmp(&b.y)
++            } else {
++                a.x.cmp(&b.x)
++            }
++        });
++
++        tracing::info!("Found {} monitors", monitors.len());
++        for (i, m) in monitors.iter().enumerate() {
++            tracing::info!(
++                "  Monitor {}: {} {}x{}+{}+{} {}",
++                i, m.name, m.width, m.height, m.x, m.y,
++                if m.primary { "(primary)" } else { "" }
++            );
++        }
++
++        Ok(monitors)
++    }
++
++    /// Find which monitor a point is on.
++    pub fn point_to_monitor(&self, x: i32, y: i32, monitors: &[MonitorInfo]) -> Option<usize> {
++        for (i, m) in monitors.iter().enumerate() {
++            let mx = m.x as i32;
++            let my = m.y as i32;
++            let mw = m.width as i32;
++            let mh = m.height as i32;
++
++            if x >= mx && x < mx + mw && y >= my && y < my + mh {
++                return Some(i);
++            }
++        }
++        None
++    }
++
++    /// Find which monitor a window is primarily on (by center point).
++    pub fn window_to_monitor(&self, x: i16, y: i16, width: u16, height: u16, monitors: &[MonitorInfo]) -> Option<usize> {
++        let center_x = x as i32 + (width as i32 / 2);
++        let center_y = y as i32 + (height as i32 / 2);
++        self.point_to_monitor(center_x, center_y, monitors)
++    }
+ }

garchomp/src/x11/mod.rsmodified


 
 pub use atoms::Atoms;
 pub use composite::CompositeExt;
+pub use connection::{Connection, ConnectionError, MonitorInfo};
 pub use visual::{VisualConfig, create_colormap, find_best_visual, get_visual_depth, has_deepcolor_support};

gardesk/garchomp / `b05b49f`

5 changed files

`@@ -7,5 +7,5 @@` mod visual;
7		7
8	pub use atoms::Atoms;	8	pub use atoms::Atoms;
9	pub use composite::CompositeExt;	9	pub use composite::CompositeExt;
10	-pub use connection::{Connection, ConnectionError};	10	+pub use connection::{Connection, ConnectionError, MonitorInfo};
11	pub use visual::{VisualConfig, create_colormap, find_best_visual, get_visual_depth, has_deepcolor_support};	11	pub use visual::{VisualConfig, create_colormap, find_best_visual, get_visual_depth, has_deepcolor_support};