`2bbd7d5`

initial gardisplay structure with basic monitor view

Authored by

espadonne 3 months ago

SHA: 2bbd7d51c8dc7e6761d0353c0552e353ba753708
Tree: 2f651a3

12 changed files

Status	File	+
A	`.gitignore`	6
A	`Cargo.toml`	9
A	`README.md`	28
A	`gardisplay-ipc/Cargo.toml`	8
A	`gardisplay-ipc/src/lib.rs`	71
A	`gardisplay/Cargo.toml`	26
A	`gardisplay/src/app.rs`	209
A	`gardisplay/src/config/mod.rs`	49
A	`gardisplay/src/config/types.rs`	163
A	`gardisplay/src/main.rs`	35
A	`gardisplay/src/ui/mod.rs`	16
A	`gardisplay/src/ui/monitor_view.rs`	249

.gitignoreadded

 +docs/
 +.vscode/
 +.fackr/
 +CLAUDE.md
 +target/
 +Cargo.lock

Cargo.tomladded

 +[workspace]
 +resolver = "2"
 +members = ["gardisplay", "gardisplay-ipc"]
++
 +[workspace.package]
 +version = "0.1.0"
 +edition = "2024"
 +license = "MIT"
 +repository = "https://github.com/gardesk/gardisplay"

README.mdadded

 +# gardisplay
++
 +Display/monitor manager for the gardesk desktop suite.
++
 +Manages monitor layouts, resolutions, refresh rates, scaling, rotation, and display effects (gamma, night mode, color profiles) with a draggable UI built on gartk.
++
 +## Components
++
 +- **gardisplay** - GUI application with visual monitor layout editor
 +- **gardisplayd** - Daemon for config persistence and effect scheduling
 +- **gardisplayctl** - CLI for scripting and automation
 +- **gardisplay-ipc** - Shared IPC message types
++
 +## Building
++
 +```bash
 +cargo build --release
 +```
++
 +## Configuration
++
 +```
 +~/.config/gardisplay/config.toml
 +```
++
 +## License
++
 +MIT

gardisplay-ipc/Cargo.tomladded

 +[package]
 +name = "gardisplay-ipc"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
++
 +[dependencies]
 +serde = { version = "1.0", features = ["derive"] }

gardisplay-ipc/src/lib.rsadded

 +//! IPC types for gardisplay daemon communication.
++
 +use serde::{Deserialize, Serialize};
++
 +/// Request from client to daemon.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum Request {
 +    /// Re-detect connected monitors.
 +    Detect,
 +    /// Apply a profile (uses default if None).
 +    Apply { profile: Option<String> },
 +    /// List available profile names.
 +    ListProfiles,
 +    /// Get current profile name.
 +    GetProfile,
 +    /// Switch to a named profile.
 +    SetProfile { name: String },
 +    /// Set brightness (0.0 - 1.0).
 +    SetBrightness { value: f64 },
 +    /// Set gamma (0.5 - 2.0).
 +    SetGamma { value: f64 },
 +    /// Control night mode.
 +    NightMode { action: NightModeAction },
 +    /// Get full current state.
 +    GetState,
 +}
++
 +/// Night mode control action.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum NightModeAction {
 +    On,
 +    Off,
 +    Toggle,
 +}
++
 +/// Response from daemon to client.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum Response {
 +    Ok,
 +    Error { message: String },
 +    Profile { name: String },
 +    Profiles { names: Vec<String> },
 +    State(DisplayState),
 +}
++
 +/// Current display state.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct DisplayState {
 +    pub current_profile: String,
 +    pub monitors: Vec<MonitorInfo>,
 +    pub brightness: f64,
 +    pub gamma: f64,
 +    pub night_mode_active: bool,
 +}
++
 +/// Monitor information for IPC.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct MonitorInfo {
 +    pub name: String,
 +    pub x: i32,
 +    pub y: i32,
 +    pub width: u32,
 +    pub height: u32,
 +    pub primary: bool,
 +}
++
 +/// Event sent to gar window manager.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub enum Event {
 +    LayoutChanged { monitors: Vec<MonitorInfo> },
 +}

gardisplay/Cargo.tomladded

 +[package]
 +name = "gardisplay"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
++
 +[[bin]]
 +name = "gardisplay"
 +path = "src/main.rs"
++
 +[dependencies]
 +gardisplay-ipc = { path = "../gardisplay-ipc" }
 +gartk-core = { path = "../../gartk/gartk-core" }
 +gartk-x11 = { path = "../../gartk/gartk-x11" }
 +gartk-render = { path = "../../gartk/gartk-render" }
++
 +x11rb = { version = "0.13", features = ["randr"] }
 +serde = { version = "1.0", features = ["derive"] }
 +serde_json = "1.0"
 +toml = "0.8"
 +thiserror = "2.0"
 +anyhow = "1.0"
 +tracing = "0.1"
 +tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 +clap = { version = "4.5", features = ["derive"] }
 +dirs = "6.0"

gardisplay/src/app.rsadded

 +//! Main application state and event loop.
++
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Key, Rect, Size, Theme};
 +use gartk_render::{copy_surface_to_window, Renderer};
 +use gartk_x11::{
 +    detect_monitors, primary_monitor, Connection, EventLoop, EventLoopConfig, Window, WindowConfig,
 +};
 +use x11rb::protocol::xproto::ConnectionExt;
++
 +use crate::config::Config;
 +use crate::ui::{EventResult, MonitorView};
++
 +/// Window dimensions.
 +const WINDOW_WIDTH: u32 = 800;
 +const WINDOW_HEIGHT: u32 = 600;
++
 +/// Main application.
 +pub struct App {
 +    conn: Connection,
 +    window: Window,
 +    renderer: Renderer,
 +    theme: Theme,
 +    gc: u32,
 +    config: Config,
 +    monitor_view: MonitorView,
 +}
++
 +impl App {
 +    /// Create a new application instance.
 +    pub fn new(config: Config) -> Result<Self> {
 +        // Connect to X11
 +        let conn = Connection::connect(None)?;
 +        tracing::info!("connected to X11 display");
++
 +        // Get monitor for positioning
 +        let monitor = primary_monitor(&conn).unwrap_or_else(|_| {
 +            tracing::warn!("could not get primary monitor, using defaults");
 +            gartk_x11::Monitor {
 +                name: "default".to_string(),
 +                rect: Rect::new(0, 0, 1920, 1080),
 +                primary: true,
 +                width_mm: 0,
 +                height_mm: 0,
 +            }
 +        });
++
 +        // Center window on monitor
 +        let x = monitor.rect.x + (monitor.rect.width as i32 - WINDOW_WIDTH as i32) / 2;
 +        let y = monitor.rect.y + (monitor.rect.height as i32 - WINDOW_HEIGHT as i32) / 2;
++
 +        // Create window
 +        let window = Window::create(
 +            conn.clone(),
 +            WindowConfig::new()
 +                .title("gardisplay")
 +                .class("gardisplay")
 +                .position(x, y)
 +                .size(WINDOW_WIDTH, WINDOW_HEIGHT),
 +        )?;
 +        window.map()?;
 +        tracing::info!(
 +            "created window {}x{} at ({}, {})",
 +            WINDOW_WIDTH,
 +            WINDOW_HEIGHT,
 +            x,
 +            y
 +        );
++
 +        // Create graphics context for blitting
 +        let gc = conn.generate_id()?;
 +        conn.inner()
 +            .create_gc(gc, window.id(), &Default::default())?;
++
 +        // Create renderer with theme
 +        let theme = Theme::dark();
 +        let renderer = Renderer::with_theme(WINDOW_WIDTH, WINDOW_HEIGHT, theme.clone())?;
++
 +        // Create monitor view
 +        let view_rect = Rect::new(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT - 100); // Leave room for controls
 +        let mut monitor_view = MonitorView::new(view_rect);
++
 +        // Detect monitors
 +        let monitors = detect_monitors(&conn)?;
 +        tracing::info!("detected {} monitors", monitors.len());
 +        for m in &monitors {
 +            tracing::debug!(
 +                "  {} {}x{} at ({}, {}) {}",
 +                m.name,
 +                m.rect.width,
 +                m.rect.height,
 +                m.rect.x,
 +                m.rect.y,
 +                if m.primary { "(primary)" } else { "" }
 +            );
 +        }
 +        monitor_view.set_monitors(monitors);
++
 +        Ok(Self {
 +            conn,
 +            window,
 +            renderer,
 +            theme,
 +            gc,
 +            config,
 +            monitor_view,
 +        })
 +    }
++
 +    /// Run the application event loop.
 +    pub fn run(&mut self) -> Result<()> {
 +        // Initial render
 +        self.render()?;
++
 +        let mut event_loop = EventLoop::new(&self.window, EventLoopConfig::default())?;
++
 +        event_loop.run(|loop_state, event| {
 +            match self.handle_event(&event) {
 +                EventResult::Quit => return Ok(false),
 +                EventResult::Redraw => {
 +                    loop_state.request_redraw();
 +                }
 +                EventResult::None => {}
 +            }
++
 +            // Render on idle if needed
 +            if matches!(event, InputEvent::Idle) && loop_state.needs_redraw() {
 +                if let Err(e) = self.render() {
 +                    tracing::error!("render error: {}", e);
 +                }
 +                loop_state.redraw_done();
 +            }
++
 +            Ok(true)
 +        })?;
++
 +        tracing::info!("exiting");
 +        Ok(())
 +    }
++
 +    /// Handle an input event.
 +    fn handle_event(&mut self, event: &InputEvent) -> EventResult {
 +        match event {
 +            InputEvent::CloseRequested => EventResult::Quit,
 +            InputEvent::Key(e) if e.pressed && e.key == Key::Escape => EventResult::Quit,
 +            InputEvent::Key(e) if e.pressed && e.key == Key::Char('q') => EventResult::Quit,
 +            InputEvent::Resize { width, height } => {
 +                self.handle_resize(Size::new(*width, *height));
 +                EventResult::Redraw
 +            }
 +            InputEvent::Expose => EventResult::Redraw,
 +            _ => self.monitor_view.handle_event(event),
 +        }
 +    }
++
 +    /// Handle window resize.
 +    fn handle_resize(&mut self, size: Size) {
 +        tracing::debug!("resize to {}x{}", size.width, size.height);
++
 +        // Resize renderer
 +        if let Err(e) = self.renderer.resize(size.width, size.height) {
 +            tracing::error!("failed to resize renderer: {}", e);
 +            return;
 +        }
++
 +        // Update monitor view rect
 +        let view_rect = Rect::new(0, 0, size.width, size.height.saturating_sub(100));
 +        self.monitor_view.set_view_rect(view_rect);
 +    }
++
 +    /// Render the application.
 +    fn render(&mut self) -> Result<()> {
 +        // Clear background
 +        self.renderer.clear()?;
++
 +        // Render monitor view
 +        self.monitor_view.render(&mut self.renderer, &self.theme)?;
++
 +        // Render bottom controls area
 +        let size = self.renderer.size();
 +        let controls_y = size.height.saturating_sub(100) as i32;
 +        let controls_rect = Rect::new(0, controls_y, size.width, 100);
 +        self.renderer
 +            .fill_rect(controls_rect, self.theme.background)?;
++
 +        // Separator line
 +        self.renderer.line(
 +            0.0,
 +            controls_y as f64,
 +            size.width as f64,
 +            controls_y as f64,
 +            self.theme.border,
 +            1.0,
 +        )?;
++
 +        // Title in controls area
 +        self.renderer.text_default(
 +            "gardisplay - Drag monitors to arrange",
 +            10.0,
 +            (controls_y + 20) as f64,
 +            self.theme.foreground,
 +        )?;
++
 +        // Blit to window
 +        copy_surface_to_window(self.renderer.surface_mut(), &self.window, self.gc, 0, 0)?;
++
 +        Ok(())
 +    }
 +}

gardisplay/src/config/mod.rsadded

 +//! Configuration loading and types.
++
 +mod types;
++
 +pub use types::*;
++
 +use std::path::PathBuf;
++
 +/// Load configuration from file or default location.
 +pub fn load_config(path: Option<&str>) -> anyhow::Result<Config> {
 +    let path = match path {
 +        Some(p) => PathBuf::from(p),
 +        None => config_path()?,
 +    };
++
 +    if path.exists() {
 +        tracing::info!("loading config from {}", path.display());
 +        let content = std::fs::read_to_string(&path)?;
 +        let config: Config = toml::from_str(&content)?;
 +        Ok(config)
 +    } else {
 +        tracing::info!("no config file found, using defaults");
 +        Ok(Config::default())
 +    }
 +}
++
 +/// Get default config file path.
 +pub fn config_path() -> anyhow::Result<PathBuf> {
 +    let config_dir = dirs::config_dir()
 +        .ok_or_else(|| anyhow::anyhow!("could not determine config directory"))?;
 +    Ok(config_dir.join("gardisplay").join("config.toml"))
 +}
++
 +impl Config {
 +    /// Save configuration to file.
 +    pub fn save(&self) -> anyhow::Result<()> {
 +        let path = config_path()?;
++
 +        if let Some(parent) = path.parent() {
 +            std::fs::create_dir_all(parent)?;
 +        }
++
 +        let content = toml::to_string_pretty(self)?;
 +        std::fs::write(&path, content)?;
++
 +        tracing::info!("saved config to {}", path.display());
 +        Ok(())
 +    }
 +}

gardisplay/src/config/types.rsadded

 +//! Configuration types.
++
 +use serde::{Deserialize, Serialize};
 +use std::collections::HashMap;
++
 +/// Main configuration.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Config {
 +    #[serde(default)]
 +    pub general: GeneralConfig,
 +    #[serde(default)]
 +    pub profiles: HashMap<String, Profile>,
 +    #[serde(default)]
 +    pub effects: EffectsConfig,
 +    #[serde(default)]
 +    pub night_mode: NightModeConfig,
 +}
++
 +impl Default for Config {
 +    fn default() -> Self {
 +        Self {
 +            general: GeneralConfig::default(),
 +            profiles: HashMap::new(),
 +            effects: EffectsConfig::default(),
 +            night_mode: NightModeConfig::default(),
 +        }
 +    }
 +}
++
 +/// General settings.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct GeneralConfig {
 +    #[serde(default = "default_profile_name")]
 +    pub default_profile: String,
 +}
++
 +fn default_profile_name() -> String {
 +    "default".to_string()
 +}
++
 +impl Default for GeneralConfig {
 +    fn default() -> Self {
 +        Self {
 +            default_profile: default_profile_name(),
 +        }
 +    }
 +}
++
 +/// A named monitor profile.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Profile {
 +    pub primary: Option<String>,
 +    #[serde(default)]
 +    pub monitors: Vec<MonitorConfig>,
 +}
++
 +/// Per-monitor configuration.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct MonitorConfig {
 +    pub name: String,
 +    #[serde(default = "default_true")]
 +    pub enabled: bool,
 +    #[serde(default)]
 +    pub x: i32,
 +    #[serde(default)]
 +    pub y: i32,
 +    pub width: u32,
 +    pub height: u32,
 +    #[serde(default = "default_refresh")]
 +    pub refresh: f64,
 +    #[serde(default = "default_scale")]
 +    pub scale: f64,
 +    #[serde(default)]
 +    pub rotation: u32,
 +}
++
 +fn default_true() -> bool {
 +    true
 +}
++
 +fn default_refresh() -> f64 {
 +    60.0
 +}
++
 +fn default_scale() -> f64 {
 +    1.0
 +}
++
 +/// Display effects settings.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct EffectsConfig {
 +    #[serde(default = "default_brightness")]
 +    pub brightness: f64,
 +    #[serde(default = "default_gamma")]
 +    pub gamma: f64,
 +}
++
 +fn default_brightness() -> f64 {
 +    1.0
 +}
++
 +fn default_gamma() -> f64 {
 +    1.0
 +}
++
 +impl Default for EffectsConfig {
 +    fn default() -> Self {
 +        Self {
 +            brightness: default_brightness(),
 +            gamma: default_gamma(),
 +        }
 +    }
 +}
++
 +/// Night mode settings.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct NightModeConfig {
 +    #[serde(default)]
 +    pub enabled: bool,
 +    #[serde(default = "default_schedule")]
 +    pub schedule: String,
 +    #[serde(default = "default_start_time")]
 +    pub start_time: String,
 +    #[serde(default = "default_end_time")]
 +    pub end_time: String,
 +    #[serde(default = "default_temperature")]
 +    pub temperature: u32,
 +    #[serde(default = "default_transition")]
 +    pub transition_minutes: u32,
 +}
++
 +fn default_schedule() -> String {
 +    "sunset".to_string()
 +}
++
 +fn default_start_time() -> String {
 +    "20:00".to_string()
 +}
++
 +fn default_end_time() -> String {
 +    "06:00".to_string()
 +}
++
 +fn default_temperature() -> u32 {
 +    4500
 +}
++
 +fn default_transition() -> u32 {
 +    30
 +}
++
 +impl Default for NightModeConfig {
 +    fn default() -> Self {
 +        Self {
 +            enabled: false,
 +            schedule: default_schedule(),
 +            start_time: default_start_time(),
 +            end_time: default_end_time(),
 +            temperature: default_temperature(),
 +            transition_minutes: default_transition(),
 +        }
 +    }
 +}

gardisplay/src/main.rsadded

 +//! gardisplay - Display/monitor manager for gardesk.
++
 +mod app;
 +mod config;
 +mod ui;
++
 +use clap::Parser;
 +use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
++
 +#[derive(Parser)]
 +#[command(name = "gardisplay")]
 +#[command(about = "Display/monitor manager for gardesk")]
 +struct Args {
 +    /// Configuration file path
 +    #[arg(short, long)]
 +    config: Option<String>,
 +}
++
 +fn main() -> anyhow::Result<()> {
 +    let args = Args::parse();
++
 +    tracing_subscriber::registry()
 +        .with(
 +            EnvFilter::try_from_default_env()
 +                .unwrap_or_else(|_| EnvFilter::new("info,gardisplay=debug")),
 +        )
 +        .with(tracing_subscriber::fmt::layer())
 +        .init();
++
 +    tracing::info!("starting gardisplay");
++
 +    let config = config::load_config(args.config.as_deref())?;
 +    let mut app = app::App::new(config)?;
 +    app.run()
 +}

gardisplay/src/ui/mod.rsadded

 +//! UI components for gardisplay.
++
 +mod monitor_view;
++
 +pub use monitor_view::MonitorView;
++
 +/// Result of handling an event.
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum EventResult {
 +    /// No action needed.
 +    None,
 +    /// Redraw the UI.
 +    Redraw,
 +    /// Quit the application.
 +    Quit,
 +}

gardisplay/src/ui/monitor_view.rsadded

 +//! Monitor layout view - displays monitors as draggable rectangles.
++
 +use gartk_core::{Color, InputEvent, Point, Rect, Theme};
 +use gartk_render::Renderer;
 +use gartk_x11::Monitor;
++
 +use super::EventResult;
++
 +/// Visual representation of a monitor in the layout.
 +#[derive(Debug, Clone)]
 +pub struct MonitorState {
 +    /// Monitor info from X11.
 +    pub info: Monitor,
 +    /// Scaled rectangle for display.
 +    pub scaled_rect: Rect,
 +}
++
 +/// View showing all monitors as rectangles.
 +pub struct MonitorView {
 +    monitors: Vec<MonitorState>,
 +    selected: Option<usize>,
 +    hovered: Option<usize>,
 +    primary_name: Option<String>,
 +    view_rect: Rect,
 +    scale: f64,
 +    offset: Point,
 +}
++
 +impl MonitorView {
 +    /// Create a new monitor view.
 +    pub fn new(view_rect: Rect) -> Self {
 +        Self {
 +            monitors: Vec::new(),
 +            selected: None,
 +            hovered: None,
 +            primary_name: None,
 +            view_rect,
 +            scale: 1.0,
 +            offset: Point::new(0, 0),
 +        }
 +    }
++
 +    /// Update with detected monitors.
 +    pub fn set_monitors(&mut self, monitors: Vec<Monitor>) {
 +        // Find primary
 +        self.primary_name = monitors.iter().find(|m| m.primary).map(|m| m.name.clone());
++
 +        // Calculate scale to fit all monitors in view
 +        self.calculate_layout(&monitors);
++
 +        // Create monitor states
 +        self.monitors = monitors
 +            .into_iter()
 +            .map(|info| {
 +                let scaled_rect = self.scale_rect(&info.rect);
 +                MonitorState { info, scaled_rect }
 +            })
 +            .collect();
++
 +        tracing::debug!(
 +            "set {} monitors, scale={:.3}, offset=({}, {})",
 +            self.monitors.len(),
 +            self.scale,
 +            self.offset.x,
 +            self.offset.y
 +        );
 +    }
++
 +    /// Calculate scale and offset to fit monitors in view.
 +    fn calculate_layout(&mut self, monitors: &[Monitor]) {
 +        if monitors.is_empty() {
 +            self.scale = 1.0;
 +            self.offset = Point::new(0, 0);
 +            return;
 +        }
++
 +        // Find bounding box of all monitors
 +        let mut min_x = i32::MAX;
 +        let mut min_y = i32::MAX;
 +        let mut max_x = i32::MIN;
 +        let mut max_y = i32::MIN;
++
 +        for m in monitors {
 +            min_x = min_x.min(m.rect.x);
 +            min_y = min_y.min(m.rect.y);
 +            max_x = max_x.max(m.rect.x + m.rect.width as i32);
 +            max_y = max_y.max(m.rect.y + m.rect.height as i32);
 +        }
++
 +        let total_width = (max_x - min_x) as f64;
 +        let total_height = (max_y - min_y) as f64;
++
 +        // Add padding
 +        let padding = 40.0;
 +        let available_width = self.view_rect.width as f64 - padding * 2.0;
 +        let available_height = self.view_rect.height as f64 - padding * 2.0;
++
 +        // Calculate scale to fit
 +        let scale_x = available_width / total_width;
 +        let scale_y = available_height / total_height;
 +        self.scale = scale_x.min(scale_y).min(0.15); // Cap at 15% to keep it reasonable
++
 +        // Calculate offset to center
 +        let scaled_width = total_width * self.scale;
 +        let scaled_height = total_height * self.scale;
++
 +        self.offset = Point::new(
 +            self.view_rect.x + ((self.view_rect.width as f64 - scaled_width) / 2.0) as i32
 +                - (min_x as f64 * self.scale) as i32,
 +            self.view_rect.y + ((self.view_rect.height as f64 - scaled_height) / 2.0) as i32
 +                - (min_y as f64 * self.scale) as i32,
 +        );
 +    }
++
 +    /// Scale a monitor rect to view coordinates.
 +    fn scale_rect(&self, rect: &Rect) -> Rect {
 +        Rect::new(
 +            self.offset.x + (rect.x as f64 * self.scale) as i32,
 +            self.offset.y + (rect.y as f64 * self.scale) as i32,
 +            (rect.width as f64 * self.scale) as u32,
 +            (rect.height as f64 * self.scale) as u32,
 +        )
 +    }
++
 +    /// Find monitor at a point.
 +    fn monitor_at_point(&self, point: Point) -> Option<usize> {
 +        for (i, state) in self.monitors.iter().enumerate().rev() {
 +            if state.scaled_rect.contains_point(point) {
 +                return Some(i);
 +            }
 +        }
 +        None
 +    }
++
 +    /// Handle an input event.
 +    pub fn handle_event(&mut self, event: &InputEvent) -> EventResult {
 +        match event {
 +            InputEvent::MouseMove(e) => {
 +                let new_hovered = self.monitor_at_point(e.position);
 +                if new_hovered != self.hovered {
 +                    self.hovered = new_hovered;
 +                    return EventResult::Redraw;
 +                }
 +            }
 +            InputEvent::MousePress(e) => {
 +                if let Some(index) = self.monitor_at_point(e.position) {
 +                    self.selected = Some(index);
 +                    return EventResult::Redraw;
 +                } else if self.selected.is_some() {
 +                    self.selected = None;
 +                    return EventResult::Redraw;
 +                }
 +            }
 +            _ => {}
 +        }
 +        EventResult::None
 +    }
++
 +    /// Render the monitor view.
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> anyhow::Result<()> {
 +        // Background
 +        renderer.fill_rect(self.view_rect, theme.background)?;
++
 +        // Render each monitor
 +        for (i, state) in self.monitors.iter().enumerate() {
 +            self.render_monitor(renderer, theme, i, state)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Render a single monitor.
 +    fn render_monitor(
 +        &self,
 +        renderer: &Renderer,
 +        theme: &Theme,
 +        index: usize,
 +        state: &MonitorState,
 +    ) -> anyhow::Result<()> {
 +        let rect = state.scaled_rect;
 +        let is_primary = self
 +            .primary_name
 +            .as_ref()
 +            .is_some_and(|name| name == &state.info.name);
++
 +        // Determine colors based on state
 +        let (bg_color, border_color, border_width) = if Some(index) == self.selected {
 +            (
 +                theme.item_selected_background,
 +                theme.selection_background,
 +                3.0,
 +            )
 +        } else if Some(index) == self.hovered {
 +            (theme.item_hover_background, theme.border, 2.0)
 +        } else {
 +            (theme.item_background, theme.border, 1.0)
 +        };
++
 +        // Background
 +        renderer.fill_rounded_rect(rect, 8.0, bg_color)?;
++
 +        // Border (thicker for primary)
 +        let actual_border_width = if is_primary {
 +            border_width + 1.0
 +        } else {
 +            border_width
 +        };
 +        let actual_border_color = if is_primary {
 +            Color::new(0.3, 0.6, 1.0, 1.0) // Blue accent for primary
 +        } else {
 +            border_color
 +        };
 +        renderer.stroke_rounded_rect(rect, 8.0, actual_border_color, actual_border_width)?;
++
 +        // Monitor name
 +        let text_x = (rect.x + 10) as f64;
 +        let text_y = (rect.y + 10) as f64;
 +        renderer.text_default(&state.info.name, text_x, text_y, theme.foreground)?;
++
 +        // Resolution
 +        let res_text = format!("{}x{}", state.info.rect.width, state.info.rect.height);
 +        renderer.text_default(&res_text, text_x, text_y + 20.0, theme.item_description)?;
++
 +        // Primary indicator
 +        if is_primary {
 +            renderer.text_default("(primary)", text_x, text_y + 40.0, theme.selection_background)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Get the selected monitor index.
 +    pub fn selected(&self) -> Option<usize> {
 +        self.selected
 +    }
++
 +    /// Get monitors.
 +    pub fn monitors(&self) -> &[MonitorState] {
 +        &self.monitors
 +    }
++
 +    /// Update view rect (e.g., on resize).
 +    pub fn set_view_rect(&mut self, rect: Rect) {
 +        self.view_rect = rect;
 +        // Recalculate layout
 +        let monitors: Vec<Monitor> = self.monitors.iter().map(|s| s.info.clone()).collect();
 +        self.set_monitors(monitors);
 +    }
 +}