`a6b7cdc`

initial commit: configuration GUI for gar desktop

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

SHA: a6b7cdc6d147839da863f26f2df5dfb0a003f2a1
Tree: fc88a40

60 changed files

Status	File	+
A	`.gitignore`	15
A	`Cargo.toml`	39
A	`docs/.fackr/workspace.json`	29
A	`docs/gargears.md`	3
A	`gargears-ipc/Cargo.toml`	12
A	`gargears-ipc/src/lib.rs`	73
A	`gargears/Cargo.toml`	29
A	`gargears/src/app.rs`	933
A	`gargears/src/config/lua_writer.rs`	364
A	`gargears/src/config/mod.rs`	77
A	`gargears/src/config/toml_writer.rs`	276
A	`gargears/src/daemon.rs`	165
A	`gargears/src/ipc/adapter.rs`	50
A	`gargears/src/ipc/adapters/gar.rs`	288
A	`gargears/src/ipc/adapters/garbar.rs`	141
A	`gargears/src/ipc/adapters/garbg.rs`	211
A	`gargears/src/ipc/adapters/garclip.rs`	111
A	`gargears/src/ipc/adapters/garfield.rs`	103
A	`gargears/src/ipc/adapters/garlaunch.rs`	105
A	`gargears/src/ipc/adapters/garlock.rs`	95
A	`gargears/src/ipc/adapters/garnotify.rs`	121
A	`gargears/src/ipc/adapters/garshot.rs`	92
A	`gargears/src/ipc/adapters/garterm.rs`	155
A	`gargears/src/ipc/adapters/gartray.rs`	107
A	`gargears/src/ipc/adapters/mod.rs`	25
A	`gargears/src/ipc/client.rs`	230
A	`gargears/src/ipc/discovery.rs`	56
A	`gargears/src/ipc/manager.rs`	384
A	`gargears/src/ipc/mod.rs`	10
A	`gargears/src/main.rs`	91
A	`gargears/src/panels/gar.rs`	759
A	`gargears/src/panels/garbar.rs`	524
A	`gargears/src/panels/garbg.rs`	541
A	`gargears/src/panels/garclip.rs`	279
A	`gargears/src/panels/garfield.rs`	260
A	`gargears/src/panels/garlaunch.rs`	247
A	`gargears/src/panels/garlock.rs`	326
A	`gargears/src/panels/garnotify.rs`	342
A	`gargears/src/panels/garshot.rs`	256
A	`gargears/src/panels/garterm.rs`	294
A	`gargears/src/panels/gartray.rs`	351
A	`gargears/src/panels/mod.rs`	116
A	`gargears/src/panels/placeholder.rs`	123
A	`gargears/src/ui/layout.rs`	64
A	`gargears/src/ui/mod.rs`	10
A	`gargears/src/ui/panel.rs`	81
A	`gargears/src/ui/sidebar.rs`	135
A	`gargears/src/ui/widgets/button.rs`	112
A	`gargears/src/ui/widgets/color_picker.rs`	242
A	`gargears/src/ui/widgets/dropdown.rs`	346
A	`gargears/src/ui/widgets/label.rs`	104
A	`gargears/src/ui/widgets/list.rs`	150
A	`gargears/src/ui/widgets/mod.rs`	57
A	`gargears/src/ui/widgets/number_input.rs`	186
A	`gargears/src/ui/widgets/section.rs`	88
A	`gargears/src/ui/widgets/slider.rs`	259
A	`gargears/src/ui/widgets/text_input.rs`	209
A	`gargears/src/ui/widgets/toggle.rs`	112
A	`gargearsctl/Cargo.toml`	19
A	`gargearsctl/src/main.rs`	78

.gitignoreadded

 +# Build artifacts
 +/target/
 +**/*.rs.bk
 +Cargo.lock
++
 +# IDE
 +.idea/
 +.vscode/
 +*.swp
 +*.swo
 +*~
++
 +# Planning docs (local only)
 +/docs/roadmap.md
 +/docs/sprints/

Cargo.tomladded

 +[workspace]
 +resolver = "2"
 +members = ["gargears", "gargearsctl", "gargears-ipc"]
++
 +[workspace.package]
 +version = "0.1.0"
 +edition = "2024"
 +license = "MIT"
 +authors = ["mfwolffe"]
++
 +[workspace.dependencies]
 +# Internal crates
 +gargears-ipc = { path = "gargears-ipc" }
 +gartk-core = { path = "../gartk/gartk-core" }
 +gartk-x11 = { path = "../gartk/gartk-x11" }
 +gartk-render = { path = "../gartk/gartk-render" }
++
 +# CLI
 +clap = { version = "4.5", features = ["derive"] }
++
 +# Async
 +tokio = { version = "1.0", features = ["full"] }
++
 +# Serialization
 +serde = { version = "1.0", features = ["derive"] }
 +serde_json = "1.0"
 +toml = "0.8"
 +regex = "1.11"
++
 +# Error handling
 +thiserror = "2.0"
 +anyhow = "1.0"
++
 +# Logging
 +tracing = "0.1"
 +tracing-subscriber = { version = "0.3", features = ["env-filter"] }
++
 +# X11 for blitting
 +x11rb = { version = "0.13", features = ["allow-unsafe-code"] }

docs/.fackr/workspace.jsonadded

 +{
 +  "active_tab": 0,
 +  "tabs": [
 +    {
 +      "files": [
 +        {
 +          "path": "gargears.md",
 +          "is_orphan": false
 +        }
 +      ],
 +      "active_pane": 0,
 +      "panes": [
 +        {
 +          "buffer_idx": 0,
 +          "cursor_line": 2,
 +          "cursor_col": 68,
 +          "viewport_line": 0,
 +          "viewport_col": 0,
 +          "bounds": {
 +            "x_start": 0.0,
 +            "y_start": 0.0,
 +            "x_end": 1.0,
 +            "y_end": 1.0
 +          }
 +        }
 +      ]
 +    }
 +  ]
 +}

docs/gargears.mdadded

 +# gargears
++
 +a centralized gui for controlling modules of the gar desktop suite.

gargears-ipc/Cargo.tomladded

 +[package]
 +name = "gargears-ipc"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
 +authors.workspace = true
 +description = "IPC protocol types for gargears"
++
 +[dependencies]
 +serde.workspace = true
 +serde_json.workspace = true
 +thiserror.workspace = true

gargears-ipc/src/lib.rsadded

 +//! IPC protocol types for gargears
 +//!
 +//! This crate defines the IPC protocol used by gargears daemon and gargearsctl.
++
 +use serde::{Deserialize, Serialize};
++
 +/// Commands that can be sent to the gargears daemon
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +pub enum Command {
 +    /// Show the gargears window
 +    Show,
 +    /// Hide the gargears window
 +    Hide,
 +    /// Toggle window visibility
 +    Toggle,
 +    /// Get daemon status
 +    Status,
 +    /// Quit the daemon
 +    Quit,
 +}
++
 +/// Response from the gargears daemon
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Response {
 +    pub success: bool,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub data: Option<serde_json::Value>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub error: Option<String>,
 +}
++
 +impl Response {
 +    pub fn ok() -> Self {
 +        Self {
 +            success: true,
 +            data: None,
 +            error: None,
 +        }
 +    }
++
 +    pub fn ok_with_data(data: serde_json::Value) -> Self {
 +        Self {
 +            success: true,
 +            data: Some(data),
 +            error: None,
 +        }
 +    }
++
 +    pub fn error(msg: impl Into<String>) -> Self {
 +        Self {
 +            success: false,
 +            data: None,
 +            error: Some(msg.into()),
 +        }
 +    }
 +}
++
 +/// Status information returned by the daemon
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct DaemonStatus {
 +    pub visible: bool,
 +    pub running: bool,
 +}
++
 +/// Get the default socket path for gargears
 +pub fn socket_path() -> std::path::PathBuf {
 +    if let Ok(runtime_dir) = std::env::var("XDG_RUNTIME_DIR") {
 +        std::path::PathBuf::from(runtime_dir).join("gargears.sock")
 +    } else {
 +        std::path::PathBuf::from("/tmp/gargears.sock")
 +    }
 +}

gargears/Cargo.tomladded

 +[package]
 +name = "gargears"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
 +authors.workspace = true
 +description = "Centralized GUI for gardesk configuration"
++
 +[[bin]]
 +name = "gargears"
 +path = "src/main.rs"
++
 +[dependencies]
 +gargears-ipc.workspace = true
 +gartk-core.workspace = true
 +gartk-x11.workspace = true
 +gartk-render.workspace = true
++
 +clap.workspace = true
 +tokio.workspace = true
 +serde.workspace = true
 +serde_json.workspace = true
 +toml.workspace = true
 +regex.workspace = true
 +thiserror.workspace = true
 +anyhow.workspace = true
 +tracing.workspace = true
 +tracing-subscriber.workspace = true
 +x11rb.workspace = true

gargears/src/app.rsadded

 +//! Main application state and event loop
++
 +use crate::daemon::{check_command, DaemonCommand};
 +use crate::ipc::discovery::DaemonStatus;
 +use crate::ipc::{ConnectionManager, IpcEvent};
 +use crate::panels::{
 +    Component, GarPanel, GarbarPanel, GarbgPanel, GarclipPanel, GarfieldPanel, GarlaunchPanel,
 +    GarlockPanel, GarnotifyPanel, GarshotPanel, GartermPanel, GartrayPanel,
 +};
 +use crate::ui::{Layout, Sidebar};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Key, Point, Rect, Theme};
 +use gartk_render::Renderer;
 +use gartk_x11::{Connection, EventLoop, EventLoopConfig, Window, WindowConfig};
 +use std::collections::HashMap;
 +use std::sync::atomic::{AtomicBool, Ordering};
 +use std::sync::mpsc::Receiver;
 +use std::sync::Arc;
 +use std::time::{Duration, Instant};
 +use x11rb::protocol::xproto::{ConnectionExt, ImageFormat};
++
 +/// How often to refresh connections (in seconds)
 +const REFRESH_INTERVAL_SECS: u64 = 5;
++
 +/// How often to poll IPC events (in milliseconds)
 +const IPC_POLL_INTERVAL_MS: u64 = 100;
++
 +/// Main application state
 +pub struct App {
 +    window: Window,
 +    renderer: Renderer,
 +    theme: Theme,
 +    gc: u32,
 +    sidebar: Sidebar,
 +    layout: Layout,
 +    selected_component: Component,
 +    panels: HashMap<Component, Box<dyn Panel>>,
 +    connection_manager: ConnectionManager,
 +    daemon_status: Vec<DaemonStatus>,
 +    last_refresh: Instant,
 +    last_ipc_poll: Instant,
 +    status_message: Option<(String, Instant)>,
 +    should_quit: bool,
 +    visible: Arc<AtomicBool>,
 +    instant_apply: bool,
 +    /// Persistent back buffer for blitting (avoids per-frame allocation)
 +    blit_buffer: Option<gartk_render::Surface>,
 +}
++
 +/// Duration to show status messages before fading
 +const STATUS_MESSAGE_DURATION: Duration = Duration::from_secs(3);
++
 +impl App {
 +    /// Create a new application
 +    pub fn new(initial_panel: Option<&str>) -> Result<Self> {
 +        // Connect to X11
 +        let conn = Connection::connect(None)?;
++
 +        // Get monitor at pointer for centering
 +        let monitor = gartk_x11::monitor_at_pointer(&conn)?;
++
 +        // Window size
 +        let width = 900;
 +        let height = 600;
 +        let x = monitor.rect.x + (monitor.rect.width as i32 - width as i32) / 2;
 +        let y = monitor.rect.y + (monitor.rect.height as i32 - height as i32) / 2;
++
 +        // Create window
 +        let window = Window::create(
 +            conn.clone(),
 +            WindowConfig::new()
 +                .title("gargears")
 +                .class("gargears")
 +                .position(x, y)
 +                .size(width, height)
 +                .transparent(true),
 +        )?;
++
 +        window.focus()?;
++
 +        // Create renderer
 +        let theme = Theme::dark();
 +        let renderer = Renderer::with_theme(width, height, theme.clone())?;
++
 +        // Create GC for blitting
 +        let gc = conn.generate_id()?;
 +        conn.inner()
 +            .create_gc(gc, window.id(), &Default::default())?;
 +        conn.flush()?;
++
 +        // Initialize components
 +        let sidebar = Sidebar::new();
 +        let layout = Layout::new(width, height);
++
 +        // Parse initial panel
 +        let selected_component = initial_panel
 +            .and_then(|name| Component::from_name(name))
 +            .unwrap_or(Component::Gar);
++
 +        // Initialize connection manager and connect to running daemons
 +        let mut connection_manager = ConnectionManager::new();
 +        let daemon_status = connection_manager.connect_all();
++
 +        // Subscribe to events
 +        connection_manager.subscribe_to_events();
++
 +        // Create panels
 +        let mut panels: HashMap<Component, Box<dyn Panel>> = HashMap::new();
++
 +        // Create all panels
 +        panels.insert(
 +            Component::Gar,
 +            Box::new(GarPanel::new(connection_manager.take_gar_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garbar,
 +            Box::new(GarbarPanel::new(connection_manager.take_garbar_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garbg,
 +            Box::new(GarbgPanel::new(connection_manager.take_garbg_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garterm,
 +            Box::new(GartermPanel::new(connection_manager.take_garterm_adapter())),
 +        );
 +        panels.insert(
 +            Component::Gartray,
 +            Box::new(GartrayPanel::new(connection_manager.take_gartray_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garshot,
 +            Box::new(GarshotPanel::new(connection_manager.take_garshot_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garlock,
 +            Box::new(GarlockPanel::new(connection_manager.take_garlock_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garfield,
 +            Box::new(GarfieldPanel::new(connection_manager.take_garfield_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garclip,
 +            Box::new(GarclipPanel::new(connection_manager.take_garclip_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garlaunch,
 +            Box::new(GarlaunchPanel::new(connection_manager.take_garlaunch_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garnotify,
 +            Box::new(GarnotifyPanel::new(connection_manager.take_garnotify_adapter())),
 +        );
++
 +        Ok(Self {
 +            window,
 +            renderer,
 +            theme,
 +            gc,
 +            sidebar,
 +            layout,
 +            selected_component,
 +            panels,
 +            connection_manager,
 +            daemon_status,
 +            last_refresh: Instant::now(),
 +            last_ipc_poll: Instant::now(),
 +            status_message: None,
 +            should_quit: false,
 +            visible: Arc::new(AtomicBool::new(true)),
 +            instant_apply: true, // Enable instant-apply by default
 +            blit_buffer: None,
 +        })
 +    }
++
 +    /// Create a new application for daemon mode (starts hidden)
 +    pub fn new_daemon(initial_panel: Option<&str>) -> Result<Self> {
 +        // Connect to X11
 +        let conn = Connection::connect(None)?;
++
 +        // Get monitor at pointer for centering
 +        let monitor = gartk_x11::monitor_at_pointer(&conn)?;
++
 +        // Window size
 +        let width = 900;
 +        let height = 600;
 +        let x = monitor.rect.x + (monitor.rect.width as i32 - width as i32) / 2;
 +        let y = monitor.rect.y + (monitor.rect.height as i32 - height as i32) / 2;
++
 +        // Create window but don't map it yet
 +        let window = Window::create(
 +            conn.clone(),
 +            WindowConfig::new()
 +                .title("gargears")
 +                .class("gargears")
 +                .position(x, y)
 +                .size(width, height)
 +                .transparent(true)
 +                .map_on_create(false), // Don't show immediately
 +        )?;
++
 +        // Create renderer
 +        let theme = Theme::dark();
 +        let renderer = Renderer::with_theme(width, height, theme.clone())?;
++
 +        // Create GC for blitting
 +        let gc = conn.generate_id()?;
 +        conn.inner()
 +            .create_gc(gc, window.id(), &Default::default())?;
 +        conn.flush()?;
++
 +        // Initialize components
 +        let sidebar = Sidebar::new();
 +        let layout = Layout::new(width, height);
++
 +        // Parse initial panel
 +        let selected_component = initial_panel
 +            .and_then(|name| Component::from_name(name))
 +            .unwrap_or(Component::Gar);
++
 +        // Initialize connection manager
 +        let mut connection_manager = ConnectionManager::new();
 +        let daemon_status = connection_manager.connect_all();
 +        connection_manager.subscribe_to_events();
++
 +        // Create panels
 +        let mut panels: HashMap<Component, Box<dyn Panel>> = HashMap::new();
 +        panels.insert(
 +            Component::Gar,
 +            Box::new(GarPanel::new(connection_manager.take_gar_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garbar,
 +            Box::new(GarbarPanel::new(connection_manager.take_garbar_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garbg,
 +            Box::new(GarbgPanel::new(connection_manager.take_garbg_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garterm,
 +            Box::new(GartermPanel::new(connection_manager.take_garterm_adapter())),
 +        );
 +        panels.insert(
 +            Component::Gartray,
 +            Box::new(GartrayPanel::new(connection_manager.take_gartray_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garshot,
 +            Box::new(GarshotPanel::new(connection_manager.take_garshot_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garlock,
 +            Box::new(GarlockPanel::new(connection_manager.take_garlock_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garfield,
 +            Box::new(GarfieldPanel::new(connection_manager.take_garfield_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garclip,
 +            Box::new(GarclipPanel::new(connection_manager.take_garclip_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garlaunch,
 +            Box::new(GarlaunchPanel::new(connection_manager.take_garlaunch_adapter())),
 +        );
 +        panels.insert(
 +            Component::Garnotify,
 +            Box::new(GarnotifyPanel::new(connection_manager.take_garnotify_adapter())),
 +        );
++
 +        Ok(Self {
 +            window,
 +            renderer,
 +            theme,
 +            gc,
 +            sidebar,
 +            layout,
 +            selected_component,
 +            panels,
 +            connection_manager,
 +            daemon_status,
 +            last_refresh: Instant::now(),
 +            last_ipc_poll: Instant::now(),
 +            status_message: None,
 +            should_quit: false,
 +            visible: Arc::new(AtomicBool::new(false)), // Start hidden
 +            instant_apply: true, // Enable instant-apply by default
 +            blit_buffer: None,
 +        })
 +    }
++
 +    /// Get visibility state (for IPC server)
 +    pub fn visible_state(&self) -> Arc<AtomicBool> {
 +        Arc::clone(&self.visible)
 +    }
++
 +    /// Show the window
 +    pub fn show(&mut self) -> Result<()> {
 +        if !self.visible.load(Ordering::Relaxed) {
 +            self.window.map()?;
 +            self.window.focus()?;
 +            self.visible.store(true, Ordering::Relaxed);
 +            tracing::info!("Window shown");
 +        }
 +        Ok(())
 +    }
++
 +    /// Hide the window
 +    pub fn hide(&mut self) -> Result<()> {
 +        if self.visible.load(Ordering::Relaxed) {
 +            self.window.unmap()?;
 +            self.visible.store(false, Ordering::Relaxed);
 +            tracing::info!("Window hidden");
 +        }
 +        Ok(())
 +    }
++
 +    /// Toggle window visibility
 +    pub fn toggle(&mut self) -> Result<()> {
 +        if self.visible.load(Ordering::Relaxed) {
 +            self.hide()
 +        } else {
 +            self.show()
 +        }
 +    }
++
 +    /// Run the application event loop
 +    pub fn run(&mut self) -> Result<()> {
 +        let mut event_loop = EventLoop::new(&self.window, EventLoopConfig::default())?;
++
 +        // Initial render
 +        self.render()?;
++
 +        event_loop.run(|ev, event| {
 +            match event.clone() {
 +                InputEvent::Key(key_event) if key_event.pressed => {
 +                    // First check global keys
 +                    if self.handle_key(&key_event.key) {
 +                        ev.request_redraw();
 +                    } else {
 +                        // Pass to current panel
 +                        if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +                            match panel.handle_event(&event) {
 +                                PanelAction::Apply => {
 +                                    if let Err(e) = panel.apply() {
 +                                        self.set_status(format!("Apply failed: {}", e));
 +                                    } else {
 +                                        self.set_status("Changes applied");
 +                                    }
 +                                }
 +                                PanelAction::InstantApply => {
 +                                    if let Err(e) = panel.apply_instant() {
 +                                        self.set_status(format!("Apply failed: {}", e));
 +                                    }
 +                                }
 +                                PanelAction::Reset => {
 +                                    panel.reset();
 +                                    self.set_status("Reset to original values");
 +                                }
 +                                PanelAction::Save => {
 +                                    if panel.has_config_file() {
 +                                        if let Err(e) = panel.save_to_config() {
 +                                            self.set_status(format!("Save failed: {}", e));
 +                                        } else {
 +                                            self.set_status("Saved to config file");
 +                                        }
 +                                    } else {
 +                                        self.set_status("No config file for this component");
 +                                    }
 +                                }
 +                                PanelAction::Redraw | PanelAction::None => {}
 +                            }
 +                            ev.request_redraw();
 +                        }
 +                    }
 +                }
 +                InputEvent::MousePress(mouse_event) => {
 +                    let x = mouse_event.position.x;
 +                    let y = mouse_event.position.y;
++
 +                    // Check if click is in sidebar
 +                    let sidebar_bounds = self.layout.sidebar_bounds();
 +                    if x >= sidebar_bounds.x
 +                        && x < sidebar_bounds.x + sidebar_bounds.width as i32
 +                        && y >= sidebar_bounds.y
 +                        && y < sidebar_bounds.y + sidebar_bounds.height as i32
 +                    {
 +                        if let Some(component) = self.sidebar.component_at_y(y, &self.layout, &self.theme) {
 +                            self.selected_component = component;
 +                        }
 +                    } else {
 +                        // Pass to current panel
 +                        if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +                            match panel.handle_event(&event) {
 +                                PanelAction::Apply => {
 +                                    if let Err(e) = panel.apply() {
 +                                        self.set_status(format!("Apply failed: {}", e));
 +                                    } else {
 +                                        self.set_status("Changes applied");
 +                                    }
 +                                }
 +                                PanelAction::InstantApply => {
 +                                    if let Err(e) = panel.apply_instant() {
 +                                        self.set_status(format!("Apply failed: {}", e));
 +                                    }
 +                                }
 +                                PanelAction::Reset => {
 +                                    panel.reset();
 +                                    self.set_status("Reset to original values");
 +                                }
 +                                PanelAction::Save => {
 +                                    if panel.has_config_file() {
 +                                        if let Err(e) = panel.save_to_config() {
 +                                            self.set_status(format!("Save failed: {}", e));
 +                                        } else {
 +                                            self.set_status("Saved to config file");
 +                                        }
 +                                    } else {
 +                                        self.set_status("No config file for this component");
 +                                    }
 +                                }
 +                                PanelAction::Redraw | PanelAction::None => {}
 +                            }
 +                        }
 +                    }
 +                    ev.request_redraw();
 +                }
 +                InputEvent::MouseMove(mouse_event) => {
 +                    // Update hover states - only redraw if needed
 +                    if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +                        if panel.on_mouse_move(mouse_event.position.x, mouse_event.position.y) {
 +                            ev.request_redraw();
 +                        }
 +                    }
 +                }
 +                InputEvent::Scroll(_) => {
 +                    if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +                        panel.handle_event(&event);
 +                    }
 +                    ev.request_redraw();
 +                }
 +                InputEvent::Expose => {
 +                    ev.request_redraw();
 +                }
 +                InputEvent::CloseRequested => {
 +                    self.should_quit = true;
 +                }
 +                InputEvent::FocusOut => {
 +                    // Don't close on focus out - this is a config app, not a popup
 +                }
 +                InputEvent::Resize { width, height } => {
 +                    self.layout = Layout::new(width, height);
 +                    if let Ok(new_renderer) =
 +                        Renderer::with_theme(width, height, self.theme.clone())
 +                    {
 +                        self.renderer = new_renderer;
 +                    }
 +                    self.blit_buffer = None; // Recreate on next render
 +                    ev.request_redraw();
 +                }
 +                _ => {}
 +            }
++
 +            // Poll for IPC events (throttled)
 +            if self.last_ipc_poll.elapsed().as_millis() >= IPC_POLL_INTERVAL_MS as u128 {
 +                self.poll_ipc_events();
 +                self.last_ipc_poll = Instant::now();
 +            }
++
 +            // Periodically refresh connections
 +            if self.last_refresh.elapsed().as_secs() >= REFRESH_INTERVAL_SECS {
 +                self.refresh_connections();
 +                ev.request_redraw();
 +            }
++
 +            if ev.needs_redraw() {
 +                let _ = self.render();
 +                ev.redraw_done();
 +            }
++
 +            Ok(!self.should_quit)
 +        })?;
++
 +        Ok(())
 +    }
++
 +    /// Run the application in daemon mode (handles IPC commands)
 +    pub fn run_daemon(&mut self, command_rx: Receiver<DaemonCommand>) -> Result<()> {
 +        let mut event_loop = EventLoop::new(&self.window, EventLoopConfig::default())?;
++
 +        tracing::info!("Daemon mode started (window hidden, use gargearsctl to show)");
++
 +        event_loop.run(|ev, event| {
 +            // Check for daemon commands first
 +            while let Some(cmd) = check_command(&command_rx) {
 +                match cmd {
 +                    DaemonCommand::Show => {
 +                        let _ = self.show();
 +                        ev.request_redraw();
 +                    }
 +                    DaemonCommand::Hide => {
 +                        let _ = self.hide();
 +                    }
 +                    DaemonCommand::Toggle => {
 +                        let _ = self.toggle();
 +                        if self.visible.load(Ordering::Relaxed) {
 +                            ev.request_redraw();
 +                        }
 +                    }
 +                    DaemonCommand::Status => {
 +                        // Handled by IPC server directly
 +                    }
 +                    DaemonCommand::Quit => {
 +                        self.should_quit = true;
 +                    }
 +                }
 +            }
++
 +            // Only process events when visible
 +            if self.visible.load(Ordering::Relaxed) {
 +                match event.clone() {
 +                    InputEvent::Key(key_event) if key_event.pressed => {
 +                        // Escape hides in daemon mode instead of quitting
 +                        if matches!(key_event.key, Key::Escape) {
 +                            let _ = self.hide();
 +                        } else if self.handle_key(&key_event.key) {
 +                            ev.request_redraw();
 +                        } else if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +                            match panel.handle_event(&event) {
 +                                PanelAction::Apply => {
 +                                    if let Err(e) = panel.apply() {
 +                                        self.set_status(format!("Apply failed: {}", e));
 +                                    } else {
 +                                        self.set_status("Changes applied");
 +                                    }
 +                                }
 +                                PanelAction::InstantApply => {
 +                                    if let Err(e) = panel.apply_instant() {
 +                                        self.set_status(format!("Apply failed: {}", e));
 +                                    }
 +                                }
 +                                PanelAction::Reset => {
 +                                    panel.reset();
 +                                    self.set_status("Reset to original values");
 +                                }
 +                                PanelAction::Save => {
 +                                    if panel.has_config_file() {
 +                                        if let Err(e) = panel.save_to_config() {
 +                                            self.set_status(format!("Save failed: {}", e));
 +                                        } else {
 +                                            self.set_status("Saved to config file");
 +                                        }
 +                                    }
 +                                }
 +                                PanelAction::Redraw | PanelAction::None => {}
 +                            }
 +                            ev.request_redraw();
 +                        }
 +                    }
 +                    InputEvent::MousePress(mouse_event) => {
 +                        let x = mouse_event.position.x;
 +                        let y = mouse_event.position.y;
++
 +                        let sidebar_bounds = self.layout.sidebar_bounds();
 +                        if x >= sidebar_bounds.x
 +                            && x < sidebar_bounds.x + sidebar_bounds.width as i32
 +                            && y >= sidebar_bounds.y
 +                            && y < sidebar_bounds.y + sidebar_bounds.height as i32
 +                        {
 +                            if let Some(component) =
 +                                self.sidebar.component_at_y(y, &self.layout, &self.theme)
 +                            {
 +                                self.selected_component = component;
 +                            }
 +                        } else if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +                            match panel.handle_event(&event) {
 +                                PanelAction::Apply => {
 +                                    if let Err(e) = panel.apply() {
 +                                        self.set_status(format!("Apply failed: {}", e));
 +                                    } else {
 +                                        self.set_status("Changes applied");
 +                                    }
 +                                }
 +                                PanelAction::InstantApply => {
 +                                    if let Err(e) = panel.apply_instant() {
 +                                        self.set_status(format!("Apply failed: {}", e));
 +                                    }
 +                                }
 +                                PanelAction::Reset => {
 +                                    panel.reset();
 +                                    self.set_status("Reset to original values");
 +                                }
 +                                PanelAction::Save => {
 +                                    if panel.has_config_file() {
 +                                        if let Err(e) = panel.save_to_config() {
 +                                            self.set_status(format!("Save failed: {}", e));
 +                                        } else {
 +                                            self.set_status("Saved to config file");
 +                                        }
 +                                    }
 +                                }
 +                                PanelAction::Redraw | PanelAction::None => {}
 +                            }
 +                        }
 +                        ev.request_redraw();
 +                    }
 +                    InputEvent::MouseMove(mouse_event) => {
 +                        if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +                            if panel.on_mouse_move(mouse_event.position.x, mouse_event.position.y) {
 +                                ev.request_redraw();
 +                            }
 +                        }
 +                    }
 +                    InputEvent::Scroll(_) => {
 +                        if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +                            panel.handle_event(&event);
 +                        }
 +                        ev.request_redraw();
 +                    }
 +                    InputEvent::Expose => {
 +                        ev.request_redraw();
 +                    }
 +                    InputEvent::CloseRequested => {
 +                        // In daemon mode, hide instead of quit
 +                        let _ = self.hide();
 +                    }
 +                    InputEvent::Resize { width, height } => {
 +                        self.layout = Layout::new(width, height);
 +                        if let Ok(new_renderer) =
 +                            Renderer::with_theme(width, height, self.theme.clone())
 +                        {
 +                            self.renderer = new_renderer;
 +                        }
 +                        self.blit_buffer = None; // Recreate on next render
 +                        ev.request_redraw();
 +                    }
 +                    _ => {}
 +                }
++
 +                if ev.needs_redraw() {
 +                    let _ = self.render();
 +                    ev.redraw_done();
 +                }
 +            }
++
 +            // Poll IPC events (throttled) and refresh connections
 +            if self.last_ipc_poll.elapsed().as_millis() >= IPC_POLL_INTERVAL_MS as u128 {
 +                self.poll_ipc_events();
 +                self.last_ipc_poll = Instant::now();
 +            }
 +            if self.last_refresh.elapsed().as_secs() >= REFRESH_INTERVAL_SECS {
 +                self.refresh_connections();
 +            }
++
 +            Ok(!self.should_quit)
 +        })?;
++
 +        Ok(())
 +    }
++
 +    /// Poll for IPC events from connected daemons
 +    fn poll_ipc_events(&mut self) {
 +        let events = self.connection_manager.poll_events();
++
 +        for event in events {
 +            match event {
 +                IpcEvent::Connected(component) => {
 +                    tracing::info!("Connected to {:?}", component);
 +                    self.set_status(format!("Connected to {}", component.display_name()));
 +                    self.daemon_status = self.connection_manager.get_statuses();
 +                }
 +                IpcEvent::Disconnected(component) => {
 +                    tracing::info!("Disconnected from {:?}", component);
 +                    self.set_status(format!("Disconnected from {}", component.display_name()));
 +                    self.daemon_status = self.connection_manager.get_statuses();
 +                }
 +                IpcEvent::WorkspaceChanged { new, .. } => {
 +                    tracing::debug!("Workspace changed to {}", new);
 +                }
 +                IpcEvent::WallpaperChanged { monitor, source } => {
 +                    tracing::debug!("Wallpaper changed on {}: {}", monitor, source);
 +                }
 +                IpcEvent::StatusUpdate { component, .. } => {
 +                    tracing::debug!("Status update from {:?}", component);
 +                }
 +                IpcEvent::Error { component, message } => {
 +                    tracing::warn!("Error from {:?}: {}", component, message);
 +                    self.set_status(format!("{}: {}", component.display_name(), message));
 +                }
 +            }
 +        }
 +    }
++
 +    /// Refresh connections to daemons
 +    fn refresh_connections(&mut self) {
 +        self.connection_manager.refresh_connections();
 +        self.daemon_status = self.connection_manager.get_statuses();
 +        self.last_refresh = Instant::now();
 +    }
++
 +    /// Handle a key press. Returns true if handled as a global key.
 +    fn handle_key(&mut self, key: &Key) -> bool {
 +        match key {
 +            Key::Escape => {
 +                self.should_quit = true;
 +                true
 +            }
 +            Key::Char('q') => {
 +                self.should_quit = true;
 +                true
 +            }
 +            Key::Char('r') => {
 +                // Manual refresh
 +                self.refresh_connections();
 +                self.set_status("Refreshed connections");
 +                true
 +            }
 +            Key::Char('i') => {
 +                // Toggle instant-apply mode
 +                self.instant_apply = !self.instant_apply;
 +                // Update all panels
 +                for panel in self.panels.values_mut() {
 +                    panel.set_instant_apply(self.instant_apply);
 +                }
 +                self.set_status(if self.instant_apply {
 +                    "Instant apply enabled"
 +                } else {
 +                    "Instant apply disabled"
 +                });
 +                true
 +            }
 +            Key::Tab => {
 +                self.select_next_component();
 +                true
 +            }
 +            _ => false,
 +        }
 +    }
++
 +    /// Set a status message that will auto-expire
 +    fn set_status(&mut self, message: impl Into<String>) {
 +        self.status_message = Some((message.into(), Instant::now()));
 +    }
 +    /// Clear expired status messages
 +    fn clear_expired_status(&mut self) {
 +        if let Some((_, timestamp)) = &self.status_message {
 +            if timestamp.elapsed() > STATUS_MESSAGE_DURATION {
 +                self.status_message = None;
 +            }
 +        }
 +    }
++
 +    /// Select the previous component
 +    fn select_prev_component(&mut self) {
 +        let components = Component::all();
 +        if let Some(idx) = components.iter().position(|c| *c == self.selected_component) {
 +            if idx > 0 {
 +                self.selected_component = components[idx - 1];
 +            }
 +        }
 +    }
++
 +    /// Select the next component
 +    fn select_next_component(&mut self) {
 +        let components = Component::all();
 +        if let Some(idx) = components.iter().position(|c| *c == self.selected_component) {
 +            if idx + 1 < components.len() {
 +                self.selected_component = components[idx + 1];
 +            }
 +        }
 +    }
++
 +    /// Render the application
 +    fn render(&mut self) -> Result<()> {
 +        // Clear background
 +        self.renderer.clear()?;
++
 +        // Draw sidebar
 +        self.sidebar.render(
 +            &mut self.renderer,
 +            &self.layout,
 +            &self.theme,
 +            self.selected_component,
 +            &self.daemon_status,
 +        )?;
++
 +        // Draw content panel
 +        self.render_content_panel()?;
++
 +        // Render status message if present
 +        self.render_status_message()?;
++
 +        // Flush and blit
 +        self.renderer.flush();
 +        self.blit_surface()?;
++
 +        Ok(())
 +    }
++
 +    /// Render the content panel
 +    fn render_content_panel(&mut self) -> Result<()> {
 +        let bounds = self.layout.content_bounds();
++
 +        // Draw panel background
 +        self.renderer.fill_rounded_rect(
 +            bounds,
 +            self.theme.border_radius,
 +            self.theme.item_background,
 +        )?;
++
 +        // Render the current panel
 +        if let Some(panel) = self.panels.get_mut(&self.selected_component) {
 +            // Panel content area (inset slightly from background)
 +            let content_bounds = Rect::new(
 +                bounds.x,
 +                bounds.y,
 +                bounds.width,
 +                bounds.height,
 +            );
++
 +            panel.render(&mut self.renderer, content_bounds, &self.theme)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Render status message at the bottom of the window
 +    fn render_status_message(&mut self) -> Result<()> {
 +        // Clear expired messages
 +        self.clear_expired_status();
++
 +        if let Some((message, timestamp)) = &self.status_message {
 +            let size = self.renderer.size();
 +            let elapsed = timestamp.elapsed();
++
 +            // Calculate fade opacity (fade out during last second)
 +            let opacity = if elapsed > STATUS_MESSAGE_DURATION - Duration::from_secs(1) {
 +                let fade_elapsed = (elapsed - (STATUS_MESSAGE_DURATION - Duration::from_secs(1))).as_secs_f64();
 +                (1.0 - fade_elapsed).max(0.0)
 +            } else {
 +                1.0
 +            };
++
 +            // Determine color based on message content
 +            let is_error = message.contains("failed") || message.contains("Error");
 +            let base_color = if is_error {
 +                gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff) // Red for errors
 +            } else {
 +                gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff) // Green for success
 +            };
++
 +            let color = base_color.with_alpha(opacity);
++
 +            let style = gartk_render::TextStyle::new()
 +                .font_family(&self.theme.font_family)
 +                .font_size(self.theme.font_size * 0.85)
 +                .color(color);
++
 +            // Render at bottom center
 +            let center = Point {
 +                x: (size.width / 2) as i32,
 +                y: (size.height - 24) as i32,
 +            };
++
 +            self.renderer.text_centered(message, center, &style)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Blit the rendered surface to the window
 +    fn blit_surface(&mut self) -> Result<()> {
 +        let size = self.renderer.size();
++
 +        // Ensure blit buffer exists and is the right size
 +        let needs_new_buffer = match &self.blit_buffer {
 +            Some(buf) => buf.width() != size.width || buf.height() != size.height,
 +            None => true,
 +        };
++
 +        if needs_new_buffer {
 +            self.blit_buffer = Some(gartk_render::Surface::new(size.width, size.height)?);
 +        }
++
 +        // Copy renderer surface to blit buffer
 +        {
 +            let ctx = self.renderer.context()?;
 +            ctx.target().flush();
 +        }
++
 +        let blit_buffer = self.blit_buffer.as_mut().unwrap();
 +        {
 +            let blit_ctx = blit_buffer.context()?;
 +            blit_ctx.set_source_surface(self.renderer.surface().cairo_surface(), 0.0, 0.0)?;
 +            blit_ctx.paint()?;
 +        }
++
 +        // Blit to X11 using with_data to avoid Vec allocation
 +        let conn = self.window.connection();
 +        let window_id = self.window.id();
 +        let gc = self.gc;
 +        let depth = self.window.depth();
++
 +        blit_buffer.with_data(|data| {
 +            let _ = conn.inner().put_image(
 +                ImageFormat::Z_PIXMAP,
 +                window_id,
 +                gc,
 +                size.width as u16,
 +                size.height as u16,
 +                0,
 +                0,
 +                0,
 +                depth,
 +                data,
 +            );
 +        })?;
++
 +        conn.flush()?;
++
 +        Ok(())
 +    }
 +}
++
 +impl Drop for App {
 +    fn drop(&mut self) {
 +        let _ = self.window.connection().inner().free_gc(self.gc);
 +    }
 +}

gargears/src/config/lua_writer.rsadded

 +//! Lua configuration writer for gardesk components
 +//!
 +//! Handles writing configuration for: gar, garbar, garterm
 +//! These share ~/.config/gar/init.lua
++
 +use anyhow::{Context, Result};
 +use std::collections::HashMap;
 +use std::fs;
 +use std::path::PathBuf;
++
 +/// Get the path to the shared Lua config
 +pub fn lua_config_path() -> PathBuf {
 +    let config_dir = std::env::var("XDG_CONFIG_HOME")
 +        .map(PathBuf::from)
 +        .unwrap_or_else(|_| {
 +            let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
 +            PathBuf::from(home).join(".config")
 +        });
 +    config_dir.join("gar").join("init.lua")
 +}
++
 +/// Represents a Lua value that can be serialized
 +#[derive(Debug, Clone)]
 +pub enum LuaValue {
 +    Number(i64),
 +    Float(f64),
 +    String(String),
 +    Bool(bool),
 +    Color(String),
 +}
++
 +impl LuaValue {
 +    pub fn to_lua(&self) -> String {
 +        match self {
 +            LuaValue::Number(n) => n.to_string(),
 +            LuaValue::Float(f) => format!("{:.2}", f),
 +            LuaValue::String(s) => format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\"")),
 +            LuaValue::Bool(b) => if *b { "true" } else { "false" }.to_string(),
 +            LuaValue::Color(c) => format!("\"{}\"", c),
 +        }
 +    }
 +}
++
 +/// gar window manager settings
 +#[derive(Debug, Clone, Default)]
 +pub struct GarSettings {
 +    pub border_width: Option<u32>,
 +    pub gap_inner: Option<u32>,
 +    pub gap_outer: Option<u32>,
 +    pub border_color_focused: Option<String>,
 +    pub border_color_unfocused: Option<String>,
 +    pub border_color_urgent: Option<String>,
 +    pub focus_follows_mouse: Option<bool>,
 +}
++
 +impl GarSettings {
 +    pub fn to_lua_statements(&self) -> Vec<(String, LuaValue)> {
 +        let mut statements = Vec::new();
++
 +        if let Some(v) = self.border_width {
 +            statements.push(("border_width".to_string(), LuaValue::Number(v as i64)));
 +        }
 +        if let Some(v) = self.gap_inner {
 +            statements.push(("gap_inner".to_string(), LuaValue::Number(v as i64)));
 +        }
 +        if let Some(v) = self.gap_outer {
 +            statements.push(("gap_outer".to_string(), LuaValue::Number(v as i64)));
 +        }
 +        if let Some(ref v) = self.border_color_focused {
 +            statements.push(("border_color_focused".to_string(), LuaValue::Color(v.clone())));
 +        }
 +        if let Some(ref v) = self.border_color_unfocused {
 +            statements.push(("border_color_unfocused".to_string(), LuaValue::Color(v.clone())));
 +        }
 +        if let Some(ref v) = self.border_color_urgent {
 +            statements.push(("border_color_urgent".to_string(), LuaValue::Color(v.clone())));
 +        }
 +        if let Some(v) = self.focus_follows_mouse {
 +            statements.push(("focus_follows_mouse".to_string(), LuaValue::Bool(v)));
 +        }
++
 +        statements
 +    }
 +}
++
 +/// garbar status bar settings
 +#[derive(Debug, Clone, Default)]
 +pub struct GarbarSettings {
 +    pub height: Option<u32>,
 +    pub position: Option<String>,
 +    pub font_family: Option<String>,
 +    pub font_size: Option<f64>,
 +    pub background_color: Option<String>,
 +    pub foreground_color: Option<String>,
 +    pub modules_left: Option<Vec<String>>,
 +    pub modules_center: Option<Vec<String>>,
 +    pub modules_right: Option<Vec<String>>,
 +}
++
 +impl GarbarSettings {
 +    pub fn to_lua_table(&self) -> String {
 +        let mut lines = Vec::new();
 +        lines.push("gar.bar = {".to_string());
++
 +        if let Some(v) = self.height {
 +            lines.push(format!("    height = {},", v));
 +        }
 +        if let Some(ref v) = self.position {
 +            lines.push(format!("    position = \"{}\",", v));
 +        }
 +        if let Some(ref v) = self.font_family {
 +            lines.push(format!("    font_family = \"{}\",", v));
 +        }
 +        if let Some(v) = self.font_size {
 +            lines.push(format!("    font_size = {:.1},", v));
 +        }
 +        if let Some(ref v) = self.background_color {
 +            lines.push(format!("    background = \"{}\",", v));
 +        }
 +        if let Some(ref v) = self.foreground_color {
 +            lines.push(format!("    foreground = \"{}\",", v));
 +        }
 +        if let Some(ref v) = self.modules_left {
 +            let mods: Vec<String> = v.iter().map(|m| format!("\"{}\"", m)).collect();
 +            lines.push(format!("    modules_left = {{ {} }},", mods.join(", ")));
 +        }
 +        if let Some(ref v) = self.modules_center {
 +            let mods: Vec<String> = v.iter().map(|m| format!("\"{}\"", m)).collect();
 +            lines.push(format!("    modules_center = {{ {} }},", mods.join(", ")));
 +        }
 +        if let Some(ref v) = self.modules_right {
 +            let mods: Vec<String> = v.iter().map(|m| format!("\"{}\"", m)).collect();
 +            lines.push(format!("    modules_right = {{ {} }},", mods.join(", ")));
 +        }
++
 +        lines.push("}".to_string());
 +        lines.join("\n")
 +    }
 +}
++
 +/// garterm terminal settings
 +#[derive(Debug, Clone, Default)]
 +pub struct GartermSettings {
 +    pub font_family: Option<String>,
 +    pub font_size: Option<f64>,
 +    pub scrollback_lines: Option<u32>,
 +    pub cursor_style: Option<String>,
 +    pub cursor_blink: Option<bool>,
 +}
++
 +impl GartermSettings {
 +    pub fn to_lua_table(&self) -> String {
 +        let mut lines = Vec::new();
 +        lines.push("gar.terminal = {".to_string());
++
 +        if let Some(ref v) = self.font_family {
 +            lines.push(format!("    font_family = \"{}\",", v));
 +        }
 +        if let Some(v) = self.font_size {
 +            lines.push(format!("    font_size = {:.1},", v));
 +        }
 +        if let Some(v) = self.scrollback_lines {
 +            lines.push(format!("    scrollback = {},", v));
 +        }
 +        if let Some(ref v) = self.cursor_style {
 +            lines.push(format!("    cursor_style = \"{}\",", v));
 +        }
 +        if let Some(v) = self.cursor_blink {
 +            lines.push(format!("    cursor_blink = {},", v));
 +        }
++
 +        lines.push("}".to_string());
 +        lines.join("\n")
 +    }
 +}
++
 +/// Lua config writer that preserves existing structure
 +pub struct LuaConfigWriter {
 +    content: String,
 +    path: PathBuf,
 +}
++
 +impl LuaConfigWriter {
 +    /// Load existing config or create empty
 +    pub fn load() -> Result<Self> {
 +        let path = lua_config_path();
 +        let content = if path.exists() {
 +            fs::read_to_string(&path)
 +                .with_context(|| format!("Failed to read {}", path.display()))?
 +        } else {
 +            String::new()
 +        };
 +        Ok(Self { content, path })
 +    }
++
 +    /// Update a gar.set() call, or add it if not present
 +    pub fn set_value(&mut self, key: &str, value: LuaValue) {
 +        let pattern = format!(r#"gar\.set\(\s*["']{}["']\s*,\s*[^)]+\)"#, regex::escape(key));
 +        let replacement = format!("gar.set(\"{}\", {})", key, value.to_lua());
++
 +        if let Ok(re) = regex::Regex::new(&pattern) {
 +            if re.is_match(&self.content) {
 +                self.content = re.replace(&self.content, replacement.as_str()).to_string();
 +            } else {
 +                // Add new setting after last gar.set() or at start
 +                if let Some(pos) = self.find_last_gar_set() {
 +                    // Find end of line
 +                    let end = self.content[pos..].find('\n').map(|p| pos + p + 1).unwrap_or(self.content.len());
 +                    self.content.insert_str(end, &format!("{}\n", replacement));
 +                } else {
 +                    // No existing gar.set(), add at beginning
 +                    self.content = format!("{}\n{}", replacement, self.content);
 +                }
 +            }
 +        }
 +    }
++
 +    /// Update multiple values
 +    pub fn set_values(&mut self, settings: &[(String, LuaValue)]) {
 +        for (key, value) in settings {
 +            self.set_value(key, value.clone());
 +        }
 +    }
++
 +    /// Update gar.bar table
 +    pub fn set_bar_table(&mut self, settings: &GarbarSettings) {
 +        let table = settings.to_lua_table();
++
 +        // Try to find and replace existing gar.bar block
 +        if let Ok(re) = regex::Regex::new(r"gar\.bar\s*=\s*\{[^}]*\}") {
 +            if re.is_match(&self.content) {
 +                self.content = re.replace(&self.content, table.as_str()).to_string();
 +                return;
 +            }
 +        }
++
 +        // No existing block, add after gar.set() calls or at end
 +        self.content.push_str("\n\n");
 +        self.content.push_str(&table);
 +        self.content.push('\n');
 +    }
++
 +    /// Update gar.terminal table
 +    pub fn set_terminal_table(&mut self, settings: &GartermSettings) {
 +        let table = settings.to_lua_table();
++
 +        // Try to find and replace existing gar.terminal block
 +        if let Ok(re) = regex::Regex::new(r"gar\.terminal\s*=\s*\{[^}]*\}") {
 +            if re.is_match(&self.content) {
 +                self.content = re.replace(&self.content, table.as_str()).to_string();
 +                return;
 +            }
 +        }
++
 +        // No existing block, add after gar.bar or at end
 +        self.content.push_str("\n\n");
 +        self.content.push_str(&table);
 +        self.content.push('\n');
 +    }
++
 +    /// Save the config file
 +    pub fn save(&self) -> Result<()> {
 +        if let Some(parent) = self.path.parent() {
 +            fs::create_dir_all(parent)
 +                .with_context(|| format!("Failed to create {}", parent.display()))?;
 +        }
++
 +        // Create backup
 +        if self.path.exists() {
 +            let backup = self.path.with_extension("lua.bak");
 +            let _ = fs::copy(&self.path, &backup);
 +        }
++
 +        fs::write(&self.path, &self.content)
 +            .with_context(|| format!("Failed to write {}", self.path.display()))
 +    }
++
 +    /// Find position of last gar.set() call
 +    fn find_last_gar_set(&self) -> Option<usize> {
 +        let pattern = r"gar\.set\(";
 +        let mut last_pos = None;
++
 +        if let Ok(re) = regex::Regex::new(pattern) {
 +            for m in re.find_iter(&self.content) {
 +                last_pos = Some(m.start());
 +            }
 +        }
++
 +        last_pos
 +    }
++
 +    /// Get current content (for preview)
 +    pub fn content(&self) -> &str {
 +        &self.content
 +    }
 +}
++
 +/// Helper to extract current gar.set() values from config
 +pub fn parse_gar_sets(content: &str) -> HashMap<String, String> {
 +    let mut values = HashMap::new();
++
 +    // Match gar.set("key", value) patterns
 +    if let Ok(re) = regex::Regex::new(r#"gar\.set\(\s*["']([^"']+)["']\s*,\s*([^)]+)\)"#) {
 +        for cap in re.captures_iter(content) {
 +            if let (Some(key), Some(val)) = (cap.get(1), cap.get(2)) {
 +                values.insert(key.as_str().to_string(), val.as_str().trim().to_string());
 +            }
 +        }
 +    }
++
 +    values
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_lua_value_serialization() {
 +        assert_eq!(LuaValue::Number(42).to_lua(), "42");
 +        assert_eq!(LuaValue::Float(3.14).to_lua(), "3.14");
 +        assert_eq!(LuaValue::String("hello".into()).to_lua(), "\"hello\"");
 +        assert_eq!(LuaValue::Bool(true).to_lua(), "true");
 +        assert_eq!(LuaValue::Color("#ff0000".into()).to_lua(), "\"#ff0000\"");
 +    }
++
 +    #[test]
 +    fn test_gar_settings() {
 +        let settings = GarSettings {
 +            border_width: Some(2),
 +            gap_inner: Some(10),
 +            ..Default::default()
 +        };
 +        let stmts = settings.to_lua_statements();
 +        assert_eq!(stmts.len(), 2);
 +    }
++
 +    #[test]
 +    fn test_garbar_table() {
 +        let settings = GarbarSettings {
 +            height: Some(28),
 +            position: Some("top".into()),
 +            modules_left: Some(vec!["workspaces".into()]),
 +            ..Default::default()
 +        };
 +        let table = settings.to_lua_table();
 +        assert!(table.contains("height = 28"));
 +        assert!(table.contains("position = \"top\""));
 +        assert!(table.contains("modules_left = { \"workspaces\" }"));
 +    }
++
 +    #[test]
 +    fn test_parse_gar_sets() {
 +        let content = r#"
 +gar.set("border_width", 2)
 +gar.set("gap_inner", 10)
 +gar.set('focus_follows_mouse', true)
 +"#;
 +        let values = parse_gar_sets(content);
 +        assert_eq!(values.get("border_width"), Some(&"2".to_string()));
 +        assert_eq!(values.get("gap_inner"), Some(&"10".to_string()));
 +        assert_eq!(values.get("focus_follows_mouse"), Some(&"true".to_string()));
 +    }
 +}

gargears/src/config/mod.rsadded

 +//! Configuration file reading and writing
 +//!
 +//! This module handles reading and writing configuration files for gardesk components.
 +//! - Lua config: gar, garbar, garterm (~/.config/gar/init.lua)
 +//! - TOML config: garbg, garlock, garshot, garclip
++
 +mod lua_writer;
 +mod toml_writer;
++
 +pub use lua_writer::{
 +    parse_gar_sets, GarSettings, GarbarSettings, GartermSettings, LuaConfigWriter, LuaValue,
 +};
 +pub use toml_writer::{
 +    GarbgConfig, GarbgSlideshow, GarbgSource, GarclipConfig, GarlockConfig, GarshotConfig,
 +};
++
 +use anyhow::Result;
 +use std::process::Command;
++
 +/// Trigger config reload for a component
 +pub fn reload_component(component: &str) -> Result<()> {
 +    match component {
 +        "gar" => {
 +            // Send SIGHUP to gar or use IPC reload command
 +            let _ = Command::new("garctl").arg("reload").spawn();
 +        }
 +        "garbar" => {
 +            // garbar reloads on config change via inotify, or SIGHUP
 +            let _ = Command::new("pkill")
 +                .args(["-HUP", "garbar"])
 +                .spawn();
 +        }
 +        "garbg" => {
 +            let _ = Command::new("garbgctl").arg("reload").spawn();
 +        }
 +        "garlock" => {
 +            // garlock typically reloads on next lock
 +        }
 +        "garshot" => {
 +            // garshot reads config on each invocation
 +        }
 +        "garclip" => {
 +            let _ = Command::new("pkill")
 +                .args(["-HUP", "garclip"])
 +                .spawn();
 +        }
 +        "garterm" => {
 +            // garterm reads config on new window
 +        }
 +        _ => {}
 +    }
 +    Ok(())
 +}
++
 +/// Check if a config file exists
 +pub fn config_exists(component: &str) -> bool {
 +    match component {
 +        "gar" | "garbar" | "garterm" => lua_writer::lua_config_path().exists(),
 +        "garbg" => toml_writer::GarbgConfig::config_path().exists(),
 +        "garlock" => toml_writer::GarlockConfig::config_path().exists(),
 +        "garshot" => toml_writer::GarshotConfig::config_path().exists(),
 +        "garclip" => toml_writer::GarclipConfig::config_path().exists(),
 +        _ => false,
 +    }
 +}
++
 +/// Get the config path for a component
 +pub fn config_path(component: &str) -> Option<std::path::PathBuf> {
 +    match component {
 +        "gar" | "garbar" | "garterm" => Some(lua_writer::lua_config_path()),
 +        "garbg" => Some(toml_writer::GarbgConfig::config_path()),
 +        "garlock" => Some(toml_writer::GarlockConfig::config_path()),
 +        "garshot" => Some(toml_writer::GarshotConfig::config_path()),
 +        "garclip" => Some(toml_writer::GarclipConfig::config_path()),
 +        _ => None,
 +    }
 +}

gargears/src/config/toml_writer.rsadded

 +//! TOML configuration writer for gardesk components
 +//!
 +//! Handles writing configuration for: garbg, garlock, garshot, garclip
++
 +use anyhow::{Context, Result};
 +use serde::{Deserialize, Serialize};
 +use std::fs;
 +use std::path::PathBuf;
++
 +/// Get XDG config directory
 +fn config_dir() -> PathBuf {
 +    std::env::var("XDG_CONFIG_HOME")
 +        .map(PathBuf::from)
 +        .unwrap_or_else(|_| {
 +            let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
 +            PathBuf::from(home).join(".config")
 +        })
 +}
++
 +/// garbg configuration
 +#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 +pub struct GarbgConfig {
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub sources: Option<Vec<GarbgSource>>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub slideshow: Option<GarbgSlideshow>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub fit: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub color: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub animation: Option<GarbgAnimation>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct GarbgSource {
 +    #[serde(rename = "type")]
 +    pub source_type: String,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub path: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub url: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub recursive: Option<bool>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct GarbgSlideshow {
 +    pub enabled: bool,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub interval_secs: Option<u64>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub shuffle: Option<bool>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct GarbgAnimation {
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub transition: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub duration_ms: Option<u64>,
 +}
++
 +impl GarbgConfig {
 +    pub fn config_path() -> PathBuf {
 +        config_dir().join("garbg").join("config.toml")
 +    }
++
 +    pub fn load() -> Result<Self> {
 +        let path = Self::config_path();
 +        if path.exists() {
 +            let content = fs::read_to_string(&path)
 +                .with_context(|| format!("Failed to read {}", path.display()))?;
 +            toml::from_str(&content)
 +                .with_context(|| format!("Failed to parse {}", path.display()))
 +        } else {
 +            Ok(Self::default())
 +        }
 +    }
++
 +    pub fn save(&self) -> Result<()> {
 +        let path = Self::config_path();
 +        if let Some(parent) = path.parent() {
 +            fs::create_dir_all(parent)
 +                .with_context(|| format!("Failed to create {}", parent.display()))?;
 +        }
 +        let content = toml::to_string_pretty(self)
 +            .context("Failed to serialize garbg config")?;
 +        fs::write(&path, content)
 +            .with_context(|| format!("Failed to write {}", path.display()))
 +    }
 +}
++
 +/// garlock configuration
 +#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 +pub struct GarlockConfig {
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub idle_timeout_secs: Option<u64>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub blur: Option<GarlockBlur>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub clock: Option<GarlockClock>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub background: Option<String>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct GarlockBlur {
 +    pub enabled: bool,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub radius: Option<u32>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct GarlockClock {
 +    pub enabled: bool,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub format: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub font_size: Option<u32>,
 +}
++
 +impl GarlockConfig {
 +    pub fn config_path() -> PathBuf {
 +        config_dir().join("garlock").join("config.toml")
 +    }
++
 +    pub fn load() -> Result<Self> {
 +        let path = Self::config_path();
 +        if path.exists() {
 +            let content = fs::read_to_string(&path)
 +                .with_context(|| format!("Failed to read {}", path.display()))?;
 +            toml::from_str(&content)
 +                .with_context(|| format!("Failed to parse {}", path.display()))
 +        } else {
 +            Ok(Self::default())
 +        }
 +    }
++
 +    pub fn save(&self) -> Result<()> {
 +        let path = Self::config_path();
 +        if let Some(parent) = path.parent() {
 +            fs::create_dir_all(parent)
 +                .with_context(|| format!("Failed to create {}", parent.display()))?;
 +        }
 +        let content = toml::to_string_pretty(self)
 +            .context("Failed to serialize garlock config")?;
 +        fs::write(&path, content)
 +            .with_context(|| format!("Failed to write {}", path.display()))
 +    }
 +}
++
 +/// garshot configuration
 +#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 +pub struct GarshotConfig {
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub format: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub save_path: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub default_region: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub copy_to_clipboard: Option<bool>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub show_notification: Option<bool>,
 +}
++
 +impl GarshotConfig {
 +    pub fn config_path() -> PathBuf {
 +        config_dir().join("garshot").join("config.toml")
 +    }
++
 +    pub fn load() -> Result<Self> {
 +        let path = Self::config_path();
 +        if path.exists() {
 +            let content = fs::read_to_string(&path)
 +                .with_context(|| format!("Failed to read {}", path.display()))?;
 +            toml::from_str(&content)
 +                .with_context(|| format!("Failed to parse {}", path.display()))
 +        } else {
 +            Ok(Self::default())
 +        }
 +    }
++
 +    pub fn save(&self) -> Result<()> {
 +        let path = Self::config_path();
 +        if let Some(parent) = path.parent() {
 +            fs::create_dir_all(parent)
 +                .with_context(|| format!("Failed to create {}", parent.display()))?;
 +        }
 +        let content = toml::to_string_pretty(self)
 +            .context("Failed to serialize garshot config")?;
 +        fs::write(&path, content)
 +            .with_context(|| format!("Failed to write {}", path.display()))
 +    }
 +}
++
 +/// garclip configuration
 +#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 +pub struct GarclipConfig {
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub max_history: Option<usize>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub persist_history: Option<bool>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub ignore_primary: Option<bool>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    pub deduplicate: Option<bool>,
 +}
++
 +impl GarclipConfig {
 +    pub fn config_path() -> PathBuf {
 +        config_dir().join("garclip").join("config.toml")
 +    }
++
 +    pub fn load() -> Result<Self> {
 +        let path = Self::config_path();
 +        if path.exists() {
 +            let content = fs::read_to_string(&path)
 +                .with_context(|| format!("Failed to read {}", path.display()))?;
 +            toml::from_str(&content)
 +                .with_context(|| format!("Failed to parse {}", path.display()))
 +        } else {
 +            Ok(Self::default())
 +        }
 +    }
++
 +    pub fn save(&self) -> Result<()> {
 +        let path = Self::config_path();
 +        if let Some(parent) = path.parent() {
 +            fs::create_dir_all(parent)
 +                .with_context(|| format!("Failed to create {}", parent.display()))?;
 +        }
 +        let content = toml::to_string_pretty(self)
 +            .context("Failed to serialize garclip config")?;
 +        fs::write(&path, content)
 +            .with_context(|| format!("Failed to write {}", path.display()))
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_garbg_serialize() {
 +        let config = GarbgConfig {
 +            fit: Some("fill".to_string()),
 +            color: Some("#282a36".to_string()),
 +            slideshow: Some(GarbgSlideshow {
 +                enabled: true,
 +                interval_secs: Some(300),
 +                shuffle: Some(true),
 +            }),
 +            ..Default::default()
 +        };
 +        let toml = toml::to_string_pretty(&config).unwrap();
 +        assert!(toml.contains("fit = \"fill\""));
 +        assert!(toml.contains("[slideshow]"));
 +    }
++
 +    #[test]
 +    fn test_garlock_serialize() {
 +        let config = GarlockConfig {
 +            idle_timeout_secs: Some(300),
 +            blur: Some(GarlockBlur {
 +                enabled: true,
 +                radius: Some(10),
 +            }),
 +            ..Default::default()
 +        };
 +        let toml = toml::to_string_pretty(&config).unwrap();
 +        assert!(toml.contains("idle_timeout_secs = 300"));
 +        assert!(toml.contains("[blur]"));
 +    }
 +}

gargears/src/daemon.rsadded

 +//! Daemon mode for gargears
 +//!
 +//! Provides IPC server functionality for controlling gargears from external tools.
++
 +use anyhow::{Context, Result};
 +use gargears_ipc::{Command, DaemonStatus, Response};
 +use std::io::{BufRead, BufReader, Write};
 +use std::os::unix::net::{UnixListener, UnixStream};
 +use std::path::PathBuf;
 +use std::process::Command as ProcessCommand;
 +use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
++
 +/// Commands sent from IPC server to main app
 +#[derive(Debug)]
 +pub enum DaemonCommand {
 +    Show,
 +    Hide,
 +    Toggle,
 +    Status,
 +    Quit,
 +}
++
 +/// IPC server for daemon mode
 +pub struct IpcServer {
 +    listener: UnixListener,
 +    socket_path: PathBuf,
 +    command_tx: Sender<DaemonCommand>,
 +}
++
 +impl IpcServer {
 +    /// Create a new IPC server
 +    pub fn new(command_tx: Sender<DaemonCommand>) -> Result<Self> {
 +        let socket_path = gargears_ipc::socket_path();
++
 +        // Remove existing socket if present
 +        if socket_path.exists() {
 +            std::fs::remove_file(&socket_path)
 +                .with_context(|| format!("Failed to remove existing socket: {:?}", socket_path))?;
 +        }
++
 +        let listener = UnixListener::bind(&socket_path)
 +            .with_context(|| format!("Failed to bind to socket: {:?}", socket_path))?;
++
 +        // Set non-blocking so we can check for shutdown
 +        listener.set_nonblocking(true)?;
++
 +        tracing::info!("IPC server listening on {:?}", socket_path);
++
 +        Ok(Self {
 +            listener,
 +            socket_path,
 +            command_tx,
 +        })
 +    }
++
 +    /// Run the server loop (should be called in a separate thread)
 +    pub fn run(&self, visible: std::sync::Arc<std::sync::atomic::AtomicBool>) {
 +        loop {
 +            match self.listener.accept() {
 +                Ok((stream, _)) => {
 +                    if let Err(e) = self.handle_client(stream, &visible) {
 +                        tracing::warn!("Error handling client: {}", e);
 +                    }
 +                }
 +                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
 +                    // No connection, sleep briefly
 +                    std::thread::sleep(std::time::Duration::from_millis(50));
 +                }
 +                Err(e) => {
 +                    tracing::error!("Accept error: {}", e);
 +                    break;
 +                }
 +            }
 +        }
 +    }
++
 +    fn handle_client(
 +        &self,
 +        mut stream: UnixStream,
 +        visible: &std::sync::Arc<std::sync::atomic::AtomicBool>,
 +    ) -> Result<()> {
 +        stream.set_nonblocking(false)?;
++
 +        let mut reader = BufReader::new(stream.try_clone()?);
 +        let mut line = String::new();
++
 +        if reader.read_line(&mut line)? == 0 {
 +            return Ok(());
 +        }
++
 +        let command: Command = serde_json::from_str(line.trim())
 +            .with_context(|| format!("Failed to parse command: {}", line.trim()))?;
++
 +        let response = match command {
 +            Command::Show => {
 +                self.command_tx.send(DaemonCommand::Show)?;
 +                Response::ok()
 +            }
 +            Command::Hide => {
 +                self.command_tx.send(DaemonCommand::Hide)?;
 +                Response::ok()
 +            }
 +            Command::Toggle => {
 +                self.command_tx.send(DaemonCommand::Toggle)?;
 +                Response::ok()
 +            }
 +            Command::Status => {
 +                let status = DaemonStatus {
 +                    visible: visible.load(std::sync::atomic::Ordering::Relaxed),
 +                    running: true,
 +                };
 +                Response::ok_with_data(serde_json::to_value(status)?)
 +            }
 +            Command::Quit => {
 +                self.command_tx.send(DaemonCommand::Quit)?;
 +                Response::ok()
 +            }
 +        };
++
 +        let response_str = serde_json::to_string(&response)?;
 +        stream.write_all(response_str.as_bytes())?;
 +        stream.write_all(b"\n")?;
 +        stream.flush()?;
++
 +        Ok(())
 +    }
 +}
++
 +impl Drop for IpcServer {
 +    fn drop(&mut self) {
 +        let _ = std::fs::remove_file(&self.socket_path);
 +    }
 +}
++
 +/// Create command channel for daemon mode
 +pub fn create_command_channel() -> (Sender<DaemonCommand>, Receiver<DaemonCommand>) {
 +    mpsc::channel()
 +}
++
 +/// Check for pending daemon commands (non-blocking)
 +pub fn check_command(rx: &Receiver<DaemonCommand>) -> Option<DaemonCommand> {
 +    match rx.try_recv() {
 +        Ok(cmd) => Some(cmd),
 +        Err(TryRecvError::Empty) => None,
 +        Err(TryRecvError::Disconnected) => Some(DaemonCommand::Quit),
 +    }
 +}
++
 +/// Send a desktop notification
 +pub fn notify(summary: &str, body: &str) {
 +    let _ = ProcessCommand::new("notify-send")
 +        .arg("--app-name=gargears")
 +        .arg("--icon=preferences-system")
 +        .arg(summary)
 +        .arg(body)
 +        .spawn();
 +}
++
 +/// Send startup notification
 +pub fn notify_startup() {
 +    notify(
 +        "gargears daemon started",
 +        "Use 'gargearsctl show' or keybind to open settings",
 +    );
 +}

gargears/src/ipc/adapter.rsadded

 +//! IPC adapter trait for communicating with gardesk daemons
++
 +use crate::panels::Component;
 +use anyhow::Result;
 +use std::path::PathBuf;
++
 +/// Status of a component
 +#[derive(Debug, Clone)]
 +pub struct ComponentStatus {
 +    /// Whether the daemon is running
 +    pub running: bool,
 +    /// Current configuration values (component-specific)
 +    pub config: serde_json::Value,
 +}
++
 +/// Trait for IPC adapters to gardesk components
 +pub trait IpcAdapter: Send {
 +    /// Get the component this adapter is for
 +    fn component(&self) -> Component;
++
 +    /// Get the socket path for this component
 +    fn socket_path(&self) -> PathBuf;
++
 +    /// Connect to the daemon
 +    fn connect(&mut self) -> Result<()>;
++
 +    /// Disconnect from the daemon
 +    fn disconnect(&mut self);
++
 +    /// Check if connected
 +    fn is_connected(&self) -> bool;
++
 +    /// Query the daemon's current status/config
 +    fn status(&mut self) -> Result<ComponentStatus>;
++
 +    /// Send a command to the daemon
 +    fn send_command(&mut self, command: &str, args: serde_json::Value) -> Result<serde_json::Value>;
++
 +    /// Subscribe to events from the daemon (if supported)
 +    fn subscribe(&mut self, _events: &[&str]) -> Result<()> {
 +        // Default: no-op for daemons that don't support subscriptions
 +        Ok(())
 +    }
++
 +    /// Check for pending events (non-blocking)
 +    fn poll_events(&mut self) -> Vec<serde_json::Value> {
 +        // Default: no events
 +        Vec::new()
 +    }
 +}

gargears/src/ipc/adapters/gar.rsadded

 +//! IPC adapter for gar (window manager)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::{json, Value};
 +use std::path::PathBuf;
++
 +/// Request format for gar IPC
 +#[derive(Debug, Serialize)]
 +struct GarRequest {
 +    command: String,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    args: Option<Value>,
 +}
++
 +/// Adapter for gar window manager
 +pub struct GarAdapter {
 +    client: IpcClient,
 +    subscribed: bool,
 +}
++
 +impl GarAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +            subscribed: false,
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Gar)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.subscribed = false;
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection (backoff elapsed)
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state (e.g., on manual refresh)
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +        self.subscribed = false;
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    /// Send a command to gar
 +    fn send_command(&mut self, command: &str, args: Option<Value>) -> Result<Option<Value>> {
 +        let request = GarRequest {
 +            command: command.to_string(),
 +            args,
 +        };
++
 +        let response: StandardResponse = self.client.send_receive(&request)?;
 +        response.into_result()
 +    }
++
 +    /// Get gar status
 +    pub fn status(&mut self) -> Result<GarStatus> {
 +        // Query workspaces
 +        let workspaces = self.send_command("workspaces", None)?;
++
 +        // Query focused window
 +        let focused = self.send_command("focused", None)?;
++
 +        // Query config values
 +        let config = self.query_config()?;
++
 +        Ok(GarStatus {
 +            workspaces: workspaces.unwrap_or(Value::Array(vec![])),
 +            focused_window: focused,
 +            config,
 +        })
 +    }
++
 +    /// Query configuration values
 +    pub fn query_config(&mut self) -> Result<GarConfig> {
 +        // These are the main configurable values
 +        let border_width = self.get_config_value("border_width")?;
 +        let gap_inner = self.get_config_value("gap_inner")?;
 +        let gap_outer = self.get_config_value("gap_outer")?;
 +        let border_color_focused = self.get_config_value("border_color_focused")?;
 +        let border_color_unfocused = self.get_config_value("border_color_unfocused")?;
 +        let focus_follows_mouse = self.get_config_value("focus_follows_mouse")?;
 +        let mouse_follows_focus = self.get_config_value("mouse_follows_focus")?;
 +        let titlebar_enabled = self.get_config_value("titlebar_enabled")?;
 +        let titlebar_height = self.get_config_value("titlebar_height")?;
++
 +        Ok(GarConfig {
 +            border_width: border_width.and_then(|v| v.as_u64()).map(|v| v as u32),
 +            gap_inner: gap_inner.and_then(|v| v.as_u64()).map(|v| v as u32),
 +            gap_outer: gap_outer.and_then(|v| v.as_u64()).map(|v| v as u32),
 +            border_color_focused: border_color_focused.and_then(|v| v.as_str().map(String::from)),
 +            border_color_unfocused: border_color_unfocused
 +                .and_then(|v| v.as_str().map(String::from)),
 +            focus_follows_mouse: focus_follows_mouse.and_then(|v| v.as_bool()),
 +            mouse_follows_focus: mouse_follows_focus.and_then(|v| v.as_bool()),
 +            titlebar_enabled: titlebar_enabled.and_then(|v| v.as_bool()),
 +            titlebar_height: titlebar_height.and_then(|v| v.as_u64()).map(|v| v as u32),
 +        })
 +    }
++
 +    /// Get a single config value
 +    fn get_config_value(&mut self, key: &str) -> Result<Option<Value>> {
 +        self.send_command("get", Some(json!({ "key": key })))
 +    }
++
 +    /// Set a config value
 +    pub fn set_config_value(&mut self, key: &str, value: Value) -> Result<()> {
 +        self.send_command("set", Some(json!({ "key": key, "value": value })))?;
 +        Ok(())
 +    }
++
 +    /// Query keybinds
 +    pub fn query_keybinds(&mut self) -> Result<Vec<GarKeybind>> {
 +        let result = self.send_command("keybinds", None)?;
 +        if let Some(data) = result {
 +            Ok(serde_json::from_value(data).unwrap_or_default())
 +        } else {
 +            Ok(vec![])
 +        }
 +    }
++
 +    /// Query window rules
 +    pub fn query_rules(&mut self) -> Result<Vec<GarRule>> {
 +        let result = self.send_command("rules", None)?;
 +        if let Some(data) = result {
 +            Ok(serde_json::from_value(data).unwrap_or_default())
 +        } else {
 +            Ok(vec![])
 +        }
 +    }
++
 +    /// Subscribe to events
 +    pub fn subscribe(&mut self, events: &[&str]) -> Result<()> {
 +        let events: Vec<String> = events.iter().map(|s| s.to_string()).collect();
 +        self.send_command("subscribe", Some(json!({ "events": events })))?;
 +        self.subscribed = true;
 +        Ok(())
 +    }
++
 +    /// Poll for events (non-blocking)
 +    pub fn poll_events(&mut self) -> Vec<GarEvent> {
 +        let mut events = Vec::new();
++
 +        while let Some(line) = self.client.try_read_line() {
 +            if let Ok(event) = serde_json::from_str::<GarEventRaw>(&line) {
 +                events.push(GarEvent {
 +                    event_type: event.event,
 +                    data: event.data,
 +                });
 +            }
 +        }
++
 +        events
 +    }
 +}
++
 +impl Default for GarAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +/// Gar status information
 +#[derive(Debug, Clone)]
 +pub struct GarStatus {
 +    pub workspaces: Value,
 +    pub focused_window: Option<Value>,
 +    pub config: GarConfig,
 +}
++
 +/// Gar configuration values
 +#[derive(Debug, Clone, Default)]
 +pub struct GarConfig {
 +    pub border_width: Option<u32>,
 +    pub gap_inner: Option<u32>,
 +    pub gap_outer: Option<u32>,
 +    pub border_color_focused: Option<String>,
 +    pub border_color_unfocused: Option<String>,
 +    pub focus_follows_mouse: Option<bool>,
 +    pub mouse_follows_focus: Option<bool>,
 +    pub titlebar_enabled: Option<bool>,
 +    pub titlebar_height: Option<u32>,
 +}
++
 +/// Raw event from gar
 +#[derive(Debug, Deserialize)]
 +struct GarEventRaw {
 +    event: String,
 +    data: Value,
 +}
++
 +/// Parsed gar event
 +#[derive(Debug, Clone)]
 +pub struct GarEvent {
 +    pub event_type: String,
 +    pub data: Value,
 +}
++
 +/// A keybind from gar
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarKeybind {
 +    #[serde(default)]
 +    pub key: String,
 +    #[serde(default)]
 +    pub modifiers: Vec<String>,
 +    #[serde(default)]
 +    pub action: String,
 +}
++
 +impl GarKeybind {
 +    /// Format as display string (e.g., "mod+Return → exec kitty")
 +    pub fn display(&self) -> String {
 +        let mods = self.modifiers.join("+");
 +        if mods.is_empty() {
 +            format!("{} → {}", self.key, self.action)
 +        } else {
 +            format!("{}+{} → {}", mods, self.key, self.action)
 +        }
 +    }
 +}
++
 +/// A window rule from gar
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarRule {
 +    #[serde(default)]
 +    pub class: Option<String>,
 +    #[serde(default)]
 +    pub title: Option<String>,
 +    #[serde(default)]
 +    pub workspace: Option<u32>,
 +    #[serde(default)]
 +    pub floating: Option<bool>,
 +}
++
 +impl GarRule {
 +    /// Format as display string
 +    pub fn display(&self) -> String {
 +        let mut matcher = Vec::new();
 +        if let Some(ref c) = self.class {
 +            matcher.push(format!("class={}", c));
 +        }
 +        if let Some(ref t) = self.title {
 +            matcher.push(format!("title={}", t));
 +        }
 +        let match_str = if matcher.is_empty() {
 +            "*".to_string()
 +        } else {
 +            matcher.join(", ")
 +        };
++
 +        let mut actions = Vec::new();
 +        if let Some(ws) = self.workspace {
 +            actions.push(format!("ws={}", ws));
 +        }
 +        if let Some(true) = self.floating {
 +            actions.push("floating".to_string());
 +        }
 +        let action_str = if actions.is_empty() {
 +            "none".to_string()
 +        } else {
 +            actions.join(", ")
 +        };
++
 +        format!("{} → {}", match_str, action_str)
 +    }
 +}

gargears/src/ipc/adapters/garbar.rsadded

 +//! IPC adapter for garbar (status bar)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garbar
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +enum GarbarCommand {
 +    Show,
 +    Hide,
 +    Toggle,
 +    Reload,
 +    Quit,
 +    Status,
 +    UpdateModule { module: String },
 +}
++
 +/// Adapter for garbar status bar
 +pub struct GarbarAdapter {
 +    client: IpcClient,
 +}
++
 +impl GarbarAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Garbar)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    /// Send a command
 +    fn send_command(&mut self, command: GarbarCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    /// Get status
 +    pub fn status(&mut self) -> Result<GarbarStatus> {
 +        let data = self.send_command(GarbarCommand::Status)?;
++
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GarbarStatus::default())
 +        }
 +    }
++
 +    /// Show the bar
 +    pub fn show(&mut self) -> Result<()> {
 +        self.send_command(GarbarCommand::Show)?;
 +        Ok(())
 +    }
++
 +    /// Hide the bar
 +    pub fn hide(&mut self) -> Result<()> {
 +        self.send_command(GarbarCommand::Hide)?;
 +        Ok(())
 +    }
++
 +    /// Toggle visibility
 +    pub fn toggle(&mut self) -> Result<()> {
 +        self.send_command(GarbarCommand::Toggle)?;
 +        Ok(())
 +    }
++
 +    /// Reload configuration
 +    pub fn reload(&mut self) -> Result<()> {
 +        self.send_command(GarbarCommand::Reload)?;
 +        Ok(())
 +    }
++
 +    /// Update a specific module
 +    pub fn update_module(&mut self, module: &str) -> Result<()> {
 +        self.send_command(GarbarCommand::UpdateModule {
 +            module: module.to_string(),
 +        })?;
 +        Ok(())
 +    }
 +}
++
 +impl Default for GarbarAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +/// Garbar status
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarbarStatus {
 +    #[serde(default)]
 +    pub visible: bool,
 +    #[serde(default)]
 +    pub width: u16,
 +    #[serde(default)]
 +    pub height: u16,
 +    #[serde(default)]
 +    pub position: Option<String>,
 +    #[serde(default)]
 +    pub modules_left: Vec<String>,
 +    #[serde(default)]
 +    pub modules_center: Vec<String>,
 +    #[serde(default)]
 +    pub modules_right: Vec<String>,
 +}

gargears/src/ipc/adapters/garbg.rsadded

 +//! IPC adapter for garbg (wallpaper daemon)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garbg (uses serde tag)
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +enum GarbgCommand {
 +    Status,
 +    Next {
 +        #[serde(skip_serializing_if = "Option::is_none")]
 +        monitor: Option<String>,
 +    },
 +    Prev {
 +        #[serde(skip_serializing_if = "Option::is_none")]
 +        monitor: Option<String>,
 +    },
 +    Pause,
 +    Resume,
 +    Toggle,
 +    QueryMonitors,
 +    QueryCurrent,
 +    Subscribe {
 +        events: Vec<String>,
 +    },
 +}
++
 +/// Adapter for garbg wallpaper daemon
 +pub struct GarbgAdapter {
 +    client: IpcClient,
 +    subscribed: bool,
 +}
++
 +impl GarbgAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +            subscribed: false,
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Garbg)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.subscribed = false;
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +        self.subscribed = false;
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    /// Send a command
 +    fn send_command(&mut self, command: GarbgCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    /// Get status
 +    pub fn status(&mut self) -> Result<GarbgStatus> {
 +        let data = self.send_command(GarbgCommand::Status)?;
++
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GarbgStatus::default())
 +        }
 +    }
++
 +    /// Query current wallpaper info
 +    pub fn query_current(&mut self) -> Result<Option<Value>> {
 +        self.send_command(GarbgCommand::QueryCurrent)
 +    }
++
 +    /// Query monitors
 +    pub fn query_monitors(&mut self) -> Result<Option<Value>> {
 +        self.send_command(GarbgCommand::QueryMonitors)
 +    }
++
 +    /// Next wallpaper
 +    pub fn next(&mut self, monitor: Option<String>) -> Result<()> {
 +        self.send_command(GarbgCommand::Next { monitor })?;
 +        Ok(())
 +    }
++
 +    /// Previous wallpaper
 +    pub fn prev(&mut self, monitor: Option<String>) -> Result<()> {
 +        self.send_command(GarbgCommand::Prev { monitor })?;
 +        Ok(())
 +    }
++
 +    /// Pause slideshow/animation
 +    pub fn pause(&mut self) -> Result<()> {
 +        self.send_command(GarbgCommand::Pause)?;
 +        Ok(())
 +    }
++
 +    /// Resume slideshow/animation
 +    pub fn resume(&mut self) -> Result<()> {
 +        self.send_command(GarbgCommand::Resume)?;
 +        Ok(())
 +    }
++
 +    /// Toggle pause state
 +    pub fn toggle(&mut self) -> Result<()> {
 +        self.send_command(GarbgCommand::Toggle)?;
 +        Ok(())
 +    }
++
 +    /// Subscribe to events
 +    pub fn subscribe(&mut self, events: &[&str]) -> Result<()> {
 +        let events: Vec<String> = events.iter().map(|s| s.to_string()).collect();
 +        self.send_command(GarbgCommand::Subscribe { events })?;
 +        self.subscribed = true;
 +        Ok(())
 +    }
++
 +    /// Poll for events
 +    pub fn poll_events(&mut self) -> Vec<GarbgEvent> {
 +        let mut events = Vec::new();
++
 +        while let Some(line) = self.client.try_read_line() {
 +            if let Ok(event) = serde_json::from_str::<GarbgEvent>(&line) {
 +                events.push(event);
 +            }
 +        }
++
 +        events
 +    }
 +}
++
 +impl Default for GarbgAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +/// Garbg status
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarbgStatus {
 +    #[serde(default)]
 +    pub paused: bool,
 +    #[serde(default)]
 +    pub current_source: Option<String>,
 +    #[serde(default)]
 +    pub current_wallpaper: Option<String>,
 +    #[serde(default)]
 +    pub interval_secs: Option<u64>,
 +    #[serde(default)]
 +    pub playlist_index: Option<usize>,
 +    #[serde(default)]
 +    pub playlist_total: Option<usize>,
 +}
++
 +/// Events from garbg
 +#[derive(Debug, Clone, Deserialize)]
 +#[serde(tag = "event", rename_all = "snake_case")]
 +pub enum GarbgEvent {
 +    WallpaperChanged {
 +        monitor: String,
 +        source: String,
 +        #[serde(default)]
 +        workspace: Option<usize>,
 +    },
 +    SourceUpdated {
 +        source: String,
 +        count: usize,
 +    },
 +    AnimationState {
 +        playing: bool,
 +    },
 +    SlideshowAdvanced {
 +        current: usize,
 +        total: usize,
 +        source: String,
 +    },
 +    Error {
 +        message: String,
 +        #[serde(default)]
 +        context: Option<String>,
 +    },
 +}

gargears/src/ipc/adapters/garclip.rsadded

 +//! IPC adapter for garclip (clipboard manager)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garclip
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +enum GarclipCommand {
 +    Status,
 +    History { limit: usize },
 +    Clear,
 +    ClearHistory { keep_pinned: bool },
 +    Reload,
 +}
++
 +/// Adapter for garclip clipboard manager
 +pub struct GarclipAdapter {
 +    client: IpcClient,
 +}
++
 +impl GarclipAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Garclip)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    fn send_command(&mut self, command: GarclipCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    pub fn status(&mut self) -> Result<GarclipStatus> {
 +        let data = self.send_command(GarclipCommand::Status)?;
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GarclipStatus::default())
 +        }
 +    }
++
 +    pub fn history(&mut self, limit: usize) -> Result<Option<Value>> {
 +        self.send_command(GarclipCommand::History { limit })
 +    }
++
 +    pub fn clear(&mut self) -> Result<()> {
 +        self.send_command(GarclipCommand::Clear)?;
 +        Ok(())
 +    }
++
 +    pub fn clear_history(&mut self, keep_pinned: bool) -> Result<()> {
 +        self.send_command(GarclipCommand::ClearHistory { keep_pinned })?;
 +        Ok(())
 +    }
 +}
++
 +impl Default for GarclipAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarclipStatus {
 +    #[serde(default)]
 +    pub history_count: usize,
 +    #[serde(default)]
 +    pub pinned_count: usize,
 +    #[serde(default)]
 +    pub owns_clipboard: bool,
 +    #[serde(default)]
 +    pub watching_primary: bool,
 +}

gargears/src/ipc/adapters/garfield.rsadded

 +//! IPC adapter for garfield (file explorer)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garfield
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +enum GarfieldCommand {
 +    Status,
 +    CurrentDir,
 +    Open { path: String },
 +}
++
 +/// Adapter for garfield file explorer
 +pub struct GarfieldAdapter {
 +    client: IpcClient,
 +}
++
 +impl GarfieldAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Garfield)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    fn send_command(&mut self, command: GarfieldCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    pub fn status(&mut self) -> Result<GarfieldStatus> {
 +        let data = self.send_command(GarfieldCommand::Status)?;
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GarfieldStatus::default())
 +        }
 +    }
++
 +    pub fn current_dir(&mut self) -> Result<Option<String>> {
 +        let data = self.send_command(GarfieldCommand::CurrentDir)?;
 +        Ok(data.and_then(|v| v.as_str().map(String::from)))
 +    }
++
 +    pub fn open(&mut self, path: &str) -> Result<()> {
 +        self.send_command(GarfieldCommand::Open {
 +            path: path.to_string(),
 +        })?;
 +        Ok(())
 +    }
 +}
++
 +impl Default for GarfieldAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarfieldStatus {
 +    #[serde(default)]
 +    pub running: bool,
 +    #[serde(default)]
 +    pub current_dir: Option<String>,
 +}

gargears/src/ipc/adapters/garlaunch.rsadded

 +//! IPC adapter for garlaunch (application launcher)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garlaunch
 +#[derive(Debug, Serialize)]
 +struct GarlaunchRequest {
 +    command: String,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    mode: Option<String>,
 +    #[serde(skip_serializing_if = "Option::is_none")]
 +    source: Option<String>,
 +}
++
 +/// Adapter for garlaunch application launcher
 +pub struct GarlaunchAdapter {
 +    client: IpcClient,
 +}
++
 +impl GarlaunchAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Garlaunch)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    fn send_command(&mut self, command: &str, mode: Option<&str>) -> Result<Option<Value>> {
 +        let request = GarlaunchRequest {
 +            command: command.to_string(),
 +            mode: mode.map(String::from),
 +            source: None,
 +        };
 +        let response: StandardResponse = self.client.send_receive(&request)?;
 +        response.into_result()
 +    }
++
 +    pub fn status(&mut self) -> Result<GarlaunchStatus> {
 +        let data = self.send_command("status", None)?;
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GarlaunchStatus::default())
 +        }
 +    }
++
 +    pub fn show(&mut self, mode: Option<&str>) -> Result<()> {
 +        self.send_command("show", mode)?;
 +        Ok(())
 +    }
++
 +    pub fn toggle(&mut self, mode: Option<&str>) -> Result<()> {
 +        self.send_command("toggle", mode)?;
 +        Ok(())
 +    }
 +}
++
 +impl Default for GarlaunchAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarlaunchStatus {
 +    #[serde(default)]
 +    pub daemon_running: bool,
 +}

gargears/src/ipc/adapters/garlock.rsadded

 +//! IPC adapter for garlock (screen locker)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garlock
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +enum GarlockCommand {
 +    Status,
 +    Lock,
 +}
++
 +/// Adapter for garlock screen locker
 +pub struct GarlockAdapter {
 +    client: IpcClient,
 +}
++
 +impl GarlockAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Garlock)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    fn send_command(&mut self, command: GarlockCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    pub fn status(&mut self) -> Result<GarlockStatus> {
 +        let data = self.send_command(GarlockCommand::Status)?;
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GarlockStatus::default())
 +        }
 +    }
++
 +    pub fn lock(&mut self) -> Result<()> {
 +        self.send_command(GarlockCommand::Lock)?;
 +        Ok(())
 +    }
 +}
++
 +impl Default for GarlockAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarlockStatus {
 +    #[serde(default)]
 +    pub locked: bool,
 +    #[serde(default)]
 +    pub idle_timeout_secs: Option<u64>,
 +}

gargears/src/ipc/adapters/garnotify.rsadded

 +//! IPC adapter for garnotify (notification daemon)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garnotify
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +enum GarnotifyCommand {
 +    Status,
 +    Clear,
 +    ClearAll,
 +    Pause,
 +    Resume,
 +    Toggle,
 +}
++
 +/// Adapter for garnotify notification daemon
 +pub struct GarnotifyAdapter {
 +    client: IpcClient,
 +}
++
 +impl GarnotifyAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Garnotify)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    fn send_command(&mut self, command: GarnotifyCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    pub fn status(&mut self) -> Result<GarnotifyStatus> {
 +        let data = self.send_command(GarnotifyCommand::Status)?;
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GarnotifyStatus::default())
 +        }
 +    }
++
 +    pub fn clear(&mut self) -> Result<()> {
 +        self.send_command(GarnotifyCommand::Clear)?;
 +        Ok(())
 +    }
++
 +    pub fn clear_all(&mut self) -> Result<()> {
 +        self.send_command(GarnotifyCommand::ClearAll)?;
 +        Ok(())
 +    }
++
 +    pub fn pause(&mut self) -> Result<()> {
 +        self.send_command(GarnotifyCommand::Pause)?;
 +        Ok(())
 +    }
++
 +    pub fn resume(&mut self) -> Result<()> {
 +        self.send_command(GarnotifyCommand::Resume)?;
 +        Ok(())
 +    }
++
 +    pub fn toggle(&mut self) -> Result<()> {
 +        self.send_command(GarnotifyCommand::Toggle)?;
 +        Ok(())
 +    }
 +}
++
 +impl Default for GarnotifyAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarnotifyStatus {
 +    #[serde(default)]
 +    pub paused: bool,
 +    #[serde(default)]
 +    pub pending_count: usize,
 +    #[serde(default)]
 +    pub history_count: usize,
 +}

gargears/src/ipc/adapters/garshot.rsadded

 +//! IPC adapter for garshot (screenshot tool)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garshot
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +enum GarshotCommand {
 +    Status,
 +    ListMonitors,
 +}
++
 +/// Adapter for garshot screenshot tool
 +pub struct GarshotAdapter {
 +    client: IpcClient,
 +}
++
 +impl GarshotAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Garshot)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    fn send_command(&mut self, command: GarshotCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    pub fn status(&mut self) -> Result<GarshotStatus> {
 +        let data = self.send_command(GarshotCommand::Status)?;
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GarshotStatus::default())
 +        }
 +    }
++
 +    pub fn list_monitors(&mut self) -> Result<Option<Value>> {
 +        self.send_command(GarshotCommand::ListMonitors)
 +    }
 +}
++
 +impl Default for GarshotAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GarshotStatus {
 +    #[serde(default)]
 +    pub ready: bool,
 +}

gargears/src/ipc/adapters/garterm.rsadded

 +//! IPC adapter for garterm (terminal emulator)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for garterm
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "cmd", rename_all = "snake_case")]
 +enum GartermCommand {
 +    Status,
 +    NewWindow,
 +    NewTab,
 +}
++
 +/// Adapter for garterm terminal emulator
 +///
 +/// Note: garterm uses per-instance sockets (garterm-{PID}.sock)
 +/// We connect to the focused instance via the "focused" file
 +pub struct GartermAdapter {
 +    client: IpcClient,
 +    focused_pid: Option<u32>,
 +}
++
 +impl GartermAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +            focused_pid: None,
 +        }
 +    }
++
 +    /// Get the directory containing garterm sockets
 +    fn socket_dir() -> PathBuf {
 +        let runtime_dir =
 +            std::env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| "/tmp".to_string());
 +        PathBuf::from(runtime_dir).join("garterm")
 +    }
++
 +    /// Get the focused PID file path
 +    fn focused_file() -> PathBuf {
 +        Self::socket_dir().join("focused")
 +    }
++
 +    /// Get socket path for a specific PID
 +    fn socket_for_pid(pid: u32) -> PathBuf {
 +        Self::socket_dir().join(format!("garterm-{}.sock", pid))
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        // Return the focused file path for discovery purposes
 +        Self::focused_file()
 +    }
++
 +    /// Read the focused PID
 +    fn read_focused_pid() -> Option<u32> {
 +        std::fs::read_to_string(Self::focused_file())
 +            .ok()
 +            .and_then(|s| s.trim().parse().ok())
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        // Read the focused PID and connect to that instance
 +        let pid = Self::read_focused_pid()
 +            .ok_or_else(|| anyhow::anyhow!("No focused garterm instance"))?;
++
 +        let socket_path = Self::socket_for_pid(pid);
 +        self.client.connect(&socket_path)?;
 +        self.focused_pid = Some(pid);
++
 +        Ok(())
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +        self.focused_pid = None;
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    /// List all running garterm instances
 +    pub fn list_instances() -> Vec<u32> {
 +        let socket_dir = Self::socket_dir();
 +        if !socket_dir.exists() {
 +            return Vec::new();
 +        }
++
 +        std::fs::read_dir(socket_dir)
 +            .map(|entries| {
 +                entries
 +                    .filter_map(|e| e.ok())
 +                    .filter_map(|e| {
 +                        let name = e.file_name().to_string_lossy().to_string();
 +                        if name.starts_with("garterm-") && name.ends_with(".sock") {
 +                            name.strip_prefix("garterm-")
 +                                .and_then(|s| s.strip_suffix(".sock"))
 +                                .and_then(|s| s.parse().ok())
 +                        } else {
 +                            None
 +                        }
 +                    })
 +                    .collect()
 +            })
 +            .unwrap_or_default()
 +    }
++
 +    fn send_command(&mut self, command: GartermCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    pub fn status(&mut self) -> Result<GartermStatus> {
 +        let data = self.send_command(GartermCommand::Status)?;
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GartermStatus {
 +                pid: self.focused_pid,
 +                ..Default::default()
 +            })
 +        }
 +    }
++
 +    pub fn new_window(&mut self) -> Result<()> {
 +        self.send_command(GartermCommand::NewWindow)?;
 +        Ok(())
 +    }
++
 +    pub fn new_tab(&mut self) -> Result<()> {
 +        self.send_command(GartermCommand::NewTab)?;
 +        Ok(())
 +    }
 +}
++
 +impl Default for GartermAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GartermStatus {
 +    #[serde(default)]
 +    pub pid: Option<u32>,
 +    #[serde(default)]
 +    pub title: Option<String>,
 +    #[serde(default)]
 +    pub tabs: Option<usize>,
 +}

gargears/src/ipc/adapters/gartray.rsadded

 +//! IPC adapter for gartray (system tray & quick settings)
++
 +use crate::ipc::client::{IpcClient, StandardResponse};
 +use crate::ipc::discovery::socket_path_for;
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde::{Deserialize, Serialize};
 +use serde_json::Value;
 +use std::path::PathBuf;
++
 +/// Commands for gartray
 +#[derive(Debug, Serialize)]
 +#[serde(tag = "command", rename_all = "snake_case")]
 +enum GartrayCommand {
 +    Status,
 +    Show,
 +    Hide,
 +    Toggle,
 +}
++
 +/// Adapter for gartray system tray
 +pub struct GartrayAdapter {
 +    client: IpcClient,
 +}
++
 +impl GartrayAdapter {
 +    pub fn new() -> Self {
 +        use std::time::Duration;
 +        Self {
 +            client: IpcClient::new().with_timeout(Duration::from_secs(5)),
 +        }
 +    }
++
 +    pub fn socket_path(&self) -> PathBuf {
 +        socket_path_for(Component::Gartray)
 +    }
++
 +    pub fn connect(&mut self) -> Result<()> {
 +        self.client.connect(&self.socket_path())
 +    }
++
 +    /// Attempt reconnection with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        self.client.reconnect()
 +    }
++
 +    /// Check if we should attempt reconnection
 +    pub fn should_reconnect(&self) -> bool {
 +        self.client.should_attempt_reconnect()
 +    }
++
 +    /// Reset backoff state
 +    pub fn reset_backoff(&mut self) {
 +        self.client.reset_backoff();
 +    }
++
 +    pub fn disconnect(&mut self) {
 +        self.client.disconnect();
 +    }
++
 +    pub fn is_connected(&self) -> bool {
 +        self.client.is_connected()
 +    }
++
 +    fn send_command(&mut self, command: GartrayCommand) -> Result<Option<Value>> {
 +        let response: StandardResponse = self.client.send_receive(&command)?;
 +        response.into_result()
 +    }
++
 +    pub fn status(&mut self) -> Result<GartrayStatus> {
 +        let data = self.send_command(GartrayCommand::Status)?;
 +        if let Some(data) = data {
 +            Ok(serde_json::from_value(data)?)
 +        } else {
 +            Ok(GartrayStatus::default())
 +        }
 +    }
++
 +    pub fn show(&mut self) -> Result<()> {
 +        self.send_command(GartrayCommand::Show)?;
 +        Ok(())
 +    }
++
 +    pub fn hide(&mut self) -> Result<()> {
 +        self.send_command(GartrayCommand::Hide)?;
 +        Ok(())
 +    }
++
 +    pub fn toggle(&mut self) -> Result<()> {
 +        self.send_command(GartrayCommand::Toggle)?;
 +        Ok(())
 +    }
 +}
++
 +impl Default for GartrayAdapter {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +#[derive(Debug, Clone, Default, Deserialize)]
 +pub struct GartrayStatus {
 +    #[serde(default)]
 +    pub visible: bool,
 +    #[serde(default)]
 +    pub tray_icons: usize,
 +}

gargears/src/ipc/adapters/mod.rsadded

 +//! IPC adapters for gardesk components
++
 +mod gar;
 +mod garbar;
 +mod garbg;
 +mod garclip;
 +mod garfield;
 +mod garlaunch;
 +mod garlock;
 +mod garnotify;
 +mod garshot;
 +mod garterm;
 +mod gartray;
++
 +pub use gar::{GarAdapter, GarKeybind, GarRule};
 +pub use garbar::GarbarAdapter;
 +pub use garbg::{GarbgAdapter, GarbgEvent};
 +pub use garclip::GarclipAdapter;
 +pub use garfield::GarfieldAdapter;
 +pub use garlaunch::GarlaunchAdapter;
 +pub use garlock::GarlockAdapter;
 +pub use garnotify::GarnotifyAdapter;
 +pub use garshot::GarshotAdapter;
 +pub use garterm::GartermAdapter;
 +pub use gartray::GartrayAdapter;

gargears/src/ipc/client.rsadded

 +//! Base IPC client functionality
++
 +use anyhow::{Context, Result};
 +use std::io::{BufRead, BufReader, Write};
 +use std::os::unix::net::UnixStream;
 +use std::path::{Path, PathBuf};
 +use std::thread;
 +use std::time::{Duration, Instant};
++
 +/// Default read/write timeout
 +const DEFAULT_TIMEOUT_SECS: u64 = 5;
++
 +/// Maximum reconnection attempts
 +const MAX_RECONNECT_ATTEMPTS: u32 = 5;
++
 +/// Initial backoff delay
 +const INITIAL_BACKOFF_MS: u64 = 100;
++
 +/// Maximum backoff delay
 +const MAX_BACKOFF_MS: u64 = 5000;
++
 +/// Base IPC client for Unix socket communication
 +pub struct IpcClient {
 +    stream: Option<UnixStream>,
 +    reader: Option<BufReader<UnixStream>>,
 +    socket_path: Option<PathBuf>,
 +    timeout: Duration,
 +    last_connect_attempt: Option<Instant>,
 +    backoff_ms: u64,
 +    connect_attempts: u32,
 +}
++
 +impl IpcClient {
 +    /// Create a new disconnected client
 +    pub fn new() -> Self {
 +        Self {
 +            stream: None,
 +            reader: None,
 +            socket_path: None,
 +            timeout: Duration::from_secs(DEFAULT_TIMEOUT_SECS),
 +            last_connect_attempt: None,
 +            backoff_ms: INITIAL_BACKOFF_MS,
 +            connect_attempts: 0,
 +        }
 +    }
++
 +    /// Set read/write timeout
 +    pub fn with_timeout(mut self, timeout: Duration) -> Self {
 +        self.timeout = timeout;
 +        self
 +    }
++
 +    /// Connect to a Unix socket
 +    pub fn connect(&mut self, path: &Path) -> Result<()> {
 +        self.socket_path = Some(path.to_path_buf());
 +        self.connect_internal(path)
 +    }
++
 +    /// Internal connect implementation
 +    fn connect_internal(&mut self, path: &Path) -> Result<()> {
 +        let stream = UnixStream::connect(path)
 +            .with_context(|| format!("Failed to connect to {:?}", path))?;
++
 +        // Set timeouts
 +        stream.set_read_timeout(Some(self.timeout))?;
 +        stream.set_write_timeout(Some(self.timeout))?;
++
 +        // Clone for reader
 +        let reader_stream = stream.try_clone()?;
++
 +        self.stream = Some(stream);
 +        self.reader = Some(BufReader::new(reader_stream));
++
 +        // Reset backoff on successful connection
 +        self.backoff_ms = INITIAL_BACKOFF_MS;
 +        self.connect_attempts = 0;
 +        self.last_connect_attempt = Some(Instant::now());
++
 +        Ok(())
 +    }
++
 +    /// Attempt to reconnect with exponential backoff
 +    pub fn reconnect(&mut self) -> Result<()> {
 +        let path = self.socket_path.clone().context("No socket path stored")?;
++
 +        // Check if we should wait before retrying
 +        if let Some(last_attempt) = self.last_connect_attempt {
 +            let elapsed = last_attempt.elapsed().as_millis() as u64;
 +            if elapsed < self.backoff_ms {
 +                let wait_time = self.backoff_ms - elapsed;
 +                thread::sleep(Duration::from_millis(wait_time));
 +            }
 +        }
++
 +        self.connect_attempts += 1;
 +        self.last_connect_attempt = Some(Instant::now());
++
 +        let result = self.connect_internal(&path);
++
 +        if result.is_err() {
 +            // Exponential backoff with cap
 +            self.backoff_ms = (self.backoff_ms * 2).min(MAX_BACKOFF_MS);
 +        }
++
 +        result
 +    }
++
 +    /// Attempt to reconnect with retry limit
 +    pub fn reconnect_with_retry(&mut self) -> Result<()> {
 +        for _ in 0..MAX_RECONNECT_ATTEMPTS {
 +            match self.reconnect() {
 +                Ok(()) => return Ok(()),
 +                Err(_) if self.connect_attempts < MAX_RECONNECT_ATTEMPTS => continue,
 +                Err(e) => return Err(e),
 +            }
 +        }
 +        Err(anyhow::anyhow!("Max reconnection attempts exceeded"))
 +    }
++
 +    /// Check if we should attempt reconnection (backoff elapsed)
 +    pub fn should_attempt_reconnect(&self) -> bool {
 +        if self.connect_attempts >= MAX_RECONNECT_ATTEMPTS {
 +            return false;
 +        }
 +        match self.last_connect_attempt {
 +            Some(last) => last.elapsed().as_millis() as u64 >= self.backoff_ms,
 +            None => true,
 +        }
 +    }
++
 +    /// Reset reconnection state (call when manual refresh requested)
 +    pub fn reset_backoff(&mut self) {
 +        self.backoff_ms = INITIAL_BACKOFF_MS;
 +        self.connect_attempts = 0;
 +        self.last_connect_attempt = None;
 +    }
++
 +    /// Disconnect from the socket
 +    pub fn disconnect(&mut self) {
 +        self.stream = None;
 +        self.reader = None;
 +    }
++
 +    /// Check if connected
 +    pub fn is_connected(&self) -> bool {
 +        self.stream.is_some()
 +    }
++
 +    /// Send a JSON message and receive a response
 +    pub fn send_receive<T: serde::Serialize, R: serde::de::DeserializeOwned>(
 +        &mut self,
 +        message: &T,
 +    ) -> Result<R> {
 +        let stream = self
 +            .stream
 +            .as_mut()
 +            .context("Not connected")?;
++
 +        // Serialize and send
 +        let json = serde_json::to_string(message)?;
 +        writeln!(stream, "{}", json)?;
 +        stream.flush()?;
++
 +        // Read response
 +        let reader = self.reader.as_mut().context("No reader")?;
 +        let mut line = String::new();
 +        reader.read_line(&mut line)?;
++
 +        // Parse response
 +        let response: R = serde_json::from_str(&line)
 +            .with_context(|| format!("Failed to parse response: {}", line.trim()))?;
++
 +        Ok(response)
 +    }
++
 +    /// Send a message without expecting a response
 +    pub fn send<T: serde::Serialize>(&mut self, message: &T) -> Result<()> {
 +        let stream = self.stream.as_mut().context("Not connected")?;
++
 +        let json = serde_json::to_string(message)?;
 +        writeln!(stream, "{}", json)?;
 +        stream.flush()?;
++
 +        Ok(())
 +    }
++
 +    /// Try to read a line (non-blocking style with short timeout)
 +    pub fn try_read_line(&mut self) -> Option<String> {
 +        let reader = self.reader.as_mut()?;
++
 +        // Set a very short timeout for polling
 +        if let Some(stream) = &self.stream {
 +            let _ = stream.set_read_timeout(Some(Duration::from_millis(10)));
 +        }
++
 +        let mut line = String::new();
 +        match reader.read_line(&mut line) {
 +            Ok(0) => None, // EOF
 +            Ok(_) => Some(line),
 +            Err(_) => None, // Timeout or error
 +        }
 +    }
 +}
++
 +impl Default for IpcClient {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +/// Standard response format used by most gardesk daemons
 +#[derive(Debug, Clone, serde::Deserialize)]
 +pub struct StandardResponse {
 +    pub success: bool,
 +    pub data: Option<serde_json::Value>,
 +    pub error: Option<String>,
 +}
++
 +impl StandardResponse {
 +    /// Get data or return error
 +    pub fn into_result(self) -> Result<Option<serde_json::Value>> {
 +        if self.success {
 +            Ok(self.data)
 +        } else {
 +            Err(anyhow::anyhow!(
 +                self.error.unwrap_or_else(|| "Unknown error".to_string())
 +            ))
 +        }
 +    }
 +}

gargears/src/ipc/discovery.rsadded

 +//! Daemon discovery - check which gardesk daemons are running
++
 +use crate::panels::Component;
 +use std::path::PathBuf;
++
 +/// Status of a daemon
 +#[derive(Debug, Clone)]
 +pub struct DaemonStatus {
 +    pub component: Component,
 +    pub running: bool,
 +    pub socket_path: PathBuf,
 +}
++
 +/// Get the socket path for a component
 +pub fn socket_path_for(component: Component) -> PathBuf {
 +    let runtime_dir = std::env::var("XDG_RUNTIME_DIR")
 +        .unwrap_or_else(|_| "/tmp".to_string());
++
 +    let socket_name = match component {
 +        Component::Gar => "gar.sock",
 +        Component::Garbar => "garbar.sock",
 +        Component::Garbg => "garbg.sock",
 +        Component::Garterm => "garterm/focused", // Special: points to focused instance
 +        Component::Gartray => "gartray.sock",
 +        Component::Garshot => "garshot.sock",
 +        Component::Garlock => "garlock.sock",
 +        Component::Garfield => "garfield.sock",
 +        Component::Garclip => "garclip.sock",
 +        Component::Garlaunch => "garlaunch.sock",
 +        Component::Garnotify => "garnotify.sock",
 +    };
++
 +    PathBuf::from(runtime_dir).join(socket_name)
 +}
++
 +/// Discover which daemons are running
 +pub fn discover_daemons() -> Vec<DaemonStatus> {
 +    Component::all()
 +        .into_iter()
 +        .map(|component| {
 +            let socket_path = socket_path_for(component);
 +            let running = socket_path.exists();
++
 +            DaemonStatus {
 +                component,
 +                running,
 +                socket_path,
 +            }
 +        })
 +        .collect()
 +}
++
 +/// Check if a specific daemon is running
 +pub fn is_daemon_running(component: Component) -> bool {
 +    socket_path_for(component).exists()
 +}

gargears/src/ipc/manager.rsadded

 +//! Connection manager for coordinating IPC with all gardesk daemons
++
 +use crate::ipc::adapters::{
 +    GarbgAdapter, GarbgEvent, GarAdapter, GarbarAdapter, GarclipAdapter, GarfieldAdapter,
 +    GarlaunchAdapter, GarlockAdapter, GarnotifyAdapter, GarshotAdapter, GartermAdapter,
 +    GartrayAdapter,
 +};
 +use crate::ipc::discovery::{discover_daemons, DaemonStatus};
 +use crate::panels::Component;
 +use anyhow::Result;
 +use serde_json::Value;
 +use std::collections::HashMap;
++
 +/// Events from gardesk daemons
 +#[derive(Debug, Clone)]
 +pub enum IpcEvent {
 +    /// A daemon connected
 +    Connected(Component),
 +    /// A daemon disconnected
 +    Disconnected(Component),
 +    /// Status update from a daemon
 +    StatusUpdate {
 +        component: Component,
 +        data: Value,
 +    },
 +    /// Workspace changed (from gar)
 +    WorkspaceChanged {
 +        old: Option<usize>,
 +        new: usize,
 +    },
 +    /// Wallpaper changed (from garbg)
 +    WallpaperChanged {
 +        monitor: String,
 +        source: String,
 +    },
 +    /// Error from a daemon
 +    Error {
 +        component: Component,
 +        message: String,
 +    },
 +}
++
 +/// Manages connections to all gardesk daemons
 +pub struct ConnectionManager {
 +    // Individual adapters
 +    pub gar: GarAdapter,
 +    pub garbar: GarbarAdapter,
 +    pub garbg: GarbgAdapter,
 +    pub garterm: GartermAdapter,
 +    pub gartray: GartrayAdapter,
 +    pub garshot: GarshotAdapter,
 +    pub garlock: GarlockAdapter,
 +    pub garfield: GarfieldAdapter,
 +    pub garclip: GarclipAdapter,
 +    pub garlaunch: GarlaunchAdapter,
 +    pub garnotify: GarnotifyAdapter,
++
 +    // Connection state
 +    connection_state: HashMap<Component, bool>,
++
 +    // Pending events
 +    pending_events: Vec<IpcEvent>,
 +}
++
 +impl ConnectionManager {
 +    /// Create a new connection manager
 +    pub fn new() -> Self {
 +        Self {
 +            gar: GarAdapter::new(),
 +            garbar: GarbarAdapter::new(),
 +            garbg: GarbgAdapter::new(),
 +            garterm: GartermAdapter::new(),
 +            gartray: GartrayAdapter::new(),
 +            garshot: GarshotAdapter::new(),
 +            garlock: GarlockAdapter::new(),
 +            garfield: GarfieldAdapter::new(),
 +            garclip: GarclipAdapter::new(),
 +            garlaunch: GarlaunchAdapter::new(),
 +            garnotify: GarnotifyAdapter::new(),
 +            connection_state: HashMap::new(),
 +            pending_events: Vec::new(),
 +        }
 +    }
++
 +    /// Discover which daemons are running and attempt to connect
 +    pub fn connect_all(&mut self) -> Vec<DaemonStatus> {
 +        let statuses = discover_daemons();
++
 +        for status in &statuses {
 +            if status.running {
 +                let _ = self.connect(status.component);
 +            }
 +        }
++
 +        statuses
 +    }
++
 +    /// Connect to a specific daemon
 +    pub fn connect(&mut self, component: Component) -> Result<()> {
 +        let was_connected = self.is_connected(component);
++
 +        let result = match component {
 +            Component::Gar => self.gar.connect(),
 +            Component::Garbar => self.garbar.connect(),
 +            Component::Garbg => self.garbg.connect(),
 +            Component::Garterm => self.garterm.connect(),
 +            Component::Gartray => self.gartray.connect(),
 +            Component::Garshot => self.garshot.connect(),
 +            Component::Garlock => self.garlock.connect(),
 +            Component::Garfield => self.garfield.connect(),
 +            Component::Garclip => self.garclip.connect(),
 +            Component::Garlaunch => self.garlaunch.connect(),
 +            Component::Garnotify => self.garnotify.connect(),
 +        };
++
 +        match &result {
 +            Ok(()) => {
 +                self.connection_state.insert(component, true);
 +                if !was_connected {
 +                    self.pending_events.push(IpcEvent::Connected(component));
 +                }
 +            }
 +            Err(_) => {
 +                self.connection_state.insert(component, false);
 +                if was_connected {
 +                    self.pending_events.push(IpcEvent::Disconnected(component));
 +                }
 +            }
 +        }
++
 +        result
 +    }
++
 +    /// Disconnect from a specific daemon
 +    pub fn disconnect(&mut self, component: Component) {
 +        let was_connected = self.is_connected(component);
++
 +        match component {
 +            Component::Gar => self.gar.disconnect(),
 +            Component::Garbar => self.garbar.disconnect(),
 +            Component::Garbg => self.garbg.disconnect(),
 +            Component::Garterm => self.garterm.disconnect(),
 +            Component::Gartray => self.gartray.disconnect(),
 +            Component::Garshot => self.garshot.disconnect(),
 +            Component::Garlock => self.garlock.disconnect(),
 +            Component::Garfield => self.garfield.disconnect(),
 +            Component::Garclip => self.garclip.disconnect(),
 +            Component::Garlaunch => self.garlaunch.disconnect(),
 +            Component::Garnotify => self.garnotify.disconnect(),
 +        }
++
 +        self.connection_state.insert(component, false);
 +        if was_connected {
 +            self.pending_events.push(IpcEvent::Disconnected(component));
 +        }
 +    }
++
 +    /// Check if connected to a specific daemon
 +    pub fn is_connected(&self, component: Component) -> bool {
 +        match component {
 +            Component::Gar => self.gar.is_connected(),
 +            Component::Garbar => self.garbar.is_connected(),
 +            Component::Garbg => self.garbg.is_connected(),
 +            Component::Garterm => self.garterm.is_connected(),
 +            Component::Gartray => self.gartray.is_connected(),
 +            Component::Garshot => self.garshot.is_connected(),
 +            Component::Garlock => self.garlock.is_connected(),
 +            Component::Garfield => self.garfield.is_connected(),
 +            Component::Garclip => self.garclip.is_connected(),
 +            Component::Garlaunch => self.garlaunch.is_connected(),
 +            Component::Garnotify => self.garnotify.is_connected(),
 +        }
 +    }
++
 +    /// Get connection statuses for all components
 +    pub fn get_statuses(&self) -> Vec<DaemonStatus> {
 +        Component::all()
 +            .into_iter()
 +            .map(|component| DaemonStatus {
 +                component,
 +                running: self.is_connected(component),
 +                socket_path: crate::ipc::discovery::socket_path_for(component),
 +            })
 +            .collect()
 +    }
++
 +    /// Poll for events from all connected daemons
 +    pub fn poll_events(&mut self) -> Vec<IpcEvent> {
 +        let mut events = std::mem::take(&mut self.pending_events);
++
 +        // Poll gar events
 +        if self.gar.is_connected() {
 +            for event in self.gar.poll_events() {
 +                match event.event_type.as_str() {
 +                    "workspace" => {
 +                        if let Some(new) = event.data.get("current").and_then(|v| v.as_u64()) {
 +                            let old = event.data.get("previous").and_then(|v| v.as_u64());
 +                            events.push(IpcEvent::WorkspaceChanged {
 +                                old: old.map(|v| v as usize),
 +                                new: new as usize,
 +                            });
 +                        }
 +                    }
 +                    _ => {
 +                        events.push(IpcEvent::StatusUpdate {
 +                            component: Component::Gar,
 +                            data: event.data,
 +                        });
 +                    }
 +                }
 +            }
 +        }
++
 +        // Poll garbg events
 +        if self.garbg.is_connected() {
 +            for event in self.garbg.poll_events() {
 +                match event {
 +                    GarbgEvent::WallpaperChanged { monitor, source, .. } => {
 +                        events.push(IpcEvent::WallpaperChanged { monitor, source });
 +                    }
 +                    GarbgEvent::Error { message, .. } => {
 +                        events.push(IpcEvent::Error {
 +                            component: Component::Garbg,
 +                            message,
 +                        });
 +                    }
 +                    _ => {}
 +                }
 +            }
 +        }
++
 +        events
 +    }
++
 +    /// Try to reconnect to daemons that have become available
 +    pub fn refresh_connections(&mut self) {
 +        let statuses = discover_daemons();
++
 +        for status in statuses {
 +            let currently_connected = self.is_connected(status.component);
++
 +            if status.running && !currently_connected {
 +                // Daemon is now available, try to connect
 +                let _ = self.connect(status.component);
 +            } else if !status.running && currently_connected {
 +                // Daemon is no longer available
 +                self.disconnect(status.component);
 +            }
 +        }
 +    }
++
 +    /// Attempt reconnection with exponential backoff for disconnected daemons
 +    pub fn reconnect_with_backoff(&mut self, component: Component) -> Result<()> {
 +        match component {
 +            Component::Gar => self.gar.reconnect(),
 +            Component::Garbar => self.garbar.reconnect(),
 +            Component::Garbg => self.garbg.reconnect(),
 +            Component::Gartray => self.gartray.reconnect(),
 +            Component::Garshot => self.garshot.reconnect(),
 +            Component::Garlock => self.garlock.reconnect(),
 +            Component::Garfield => self.garfield.reconnect(),
 +            Component::Garclip => self.garclip.reconnect(),
 +            Component::Garlaunch => self.garlaunch.reconnect(),
 +            Component::Garnotify => self.garnotify.reconnect(),
 +            // garterm uses different socket scheme, just try fresh connect
 +            Component::Garterm => self.garterm.connect(),
 +        }
 +    }
++
 +    /// Check if reconnection should be attempted for a component
 +    pub fn should_reconnect(&self, component: Component) -> bool {
 +        match component {
 +            Component::Gar => self.gar.should_reconnect(),
 +            Component::Garbar => self.garbar.should_reconnect(),
 +            Component::Garbg => self.garbg.should_reconnect(),
 +            Component::Gartray => self.gartray.should_reconnect(),
 +            Component::Garshot => self.garshot.should_reconnect(),
 +            Component::Garlock => self.garlock.should_reconnect(),
 +            Component::Garfield => self.garfield.should_reconnect(),
 +            Component::Garclip => self.garclip.should_reconnect(),
 +            Component::Garlaunch => self.garlaunch.should_reconnect(),
 +            Component::Garnotify => self.garnotify.should_reconnect(),
 +            Component::Garterm => true, // Always allow garterm reconnect
 +        }
 +    }
++
 +    /// Reset backoff state for a component (e.g., after manual refresh)
 +    pub fn reset_backoff(&mut self, component: Component) {
 +        match component {
 +            Component::Gar => self.gar.reset_backoff(),
 +            Component::Garbar => self.garbar.reset_backoff(),
 +            Component::Garbg => self.garbg.reset_backoff(),
 +            Component::Gartray => self.gartray.reset_backoff(),
 +            Component::Garshot => self.garshot.reset_backoff(),
 +            Component::Garlock => self.garlock.reset_backoff(),
 +            Component::Garfield => self.garfield.reset_backoff(),
 +            Component::Garclip => self.garclip.reset_backoff(),
 +            Component::Garlaunch => self.garlaunch.reset_backoff(),
 +            Component::Garnotify => self.garnotify.reset_backoff(),
 +            Component::Garterm => {} // garterm doesn't track backoff
 +        }
 +    }
++
 +    /// Reset backoff for all components
 +    pub fn reset_all_backoff(&mut self) {
 +        for component in Component::all() {
 +            self.reset_backoff(component);
 +        }
 +    }
++
 +    /// Subscribe to events from daemons that support it
 +    pub fn subscribe_to_events(&mut self) {
 +        // Subscribe to gar workspace events
 +        if self.gar.is_connected() {
 +            let _ = self.gar.subscribe(&["workspace", "monitor", "window"]);
 +        }
++
 +        // Subscribe to garbg events
 +        if self.garbg.is_connected() {
 +            let _ = self.garbg.subscribe(&["wallpaper_changed", "slideshow_advanced"]);
 +        }
 +    }
++
 +    /// Take the gar adapter, replacing it with a disconnected one
 +    pub fn take_gar_adapter(&mut self) -> GarAdapter {
 +        std::mem::take(&mut self.gar)
 +    }
++
 +    /// Take the garbar adapter, replacing it with a disconnected one
 +    pub fn take_garbar_adapter(&mut self) -> GarbarAdapter {
 +        std::mem::take(&mut self.garbar)
 +    }
++
 +    /// Take the garbg adapter, replacing it with a disconnected one
 +    pub fn take_garbg_adapter(&mut self) -> GarbgAdapter {
 +        std::mem::take(&mut self.garbg)
 +    }
++
 +    /// Take the garterm adapter, replacing it with a disconnected one
 +    pub fn take_garterm_adapter(&mut self) -> GartermAdapter {
 +        std::mem::take(&mut self.garterm)
 +    }
++
 +    /// Take the gartray adapter, replacing it with a disconnected one
 +    pub fn take_gartray_adapter(&mut self) -> GartrayAdapter {
 +        std::mem::take(&mut self.gartray)
 +    }
++
 +    /// Take the garshot adapter, replacing it with a disconnected one
 +    pub fn take_garshot_adapter(&mut self) -> GarshotAdapter {
 +        std::mem::take(&mut self.garshot)
 +    }
++
 +    /// Take the garlock adapter, replacing it with a disconnected one
 +    pub fn take_garlock_adapter(&mut self) -> GarlockAdapter {
 +        std::mem::take(&mut self.garlock)
 +    }
++
 +    /// Take the garfield adapter, replacing it with a disconnected one
 +    pub fn take_garfield_adapter(&mut self) -> GarfieldAdapter {
 +        std::mem::take(&mut self.garfield)
 +    }
++
 +    /// Take the garclip adapter, replacing it with a disconnected one
 +    pub fn take_garclip_adapter(&mut self) -> GarclipAdapter {
 +        std::mem::take(&mut self.garclip)
 +    }
++
 +    /// Take the garlaunch adapter, replacing it with a disconnected one
 +    pub fn take_garlaunch_adapter(&mut self) -> GarlaunchAdapter {
 +        std::mem::take(&mut self.garlaunch)
 +    }
++
 +    /// Take the garnotify adapter, replacing it with a disconnected one
 +    pub fn take_garnotify_adapter(&mut self) -> GarnotifyAdapter {
 +        std::mem::take(&mut self.garnotify)
 +    }
 +}
++
 +impl Default for ConnectionManager {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}

gargears/src/ipc/mod.rsadded

 +//! IPC communication with gardesk daemons
++
 +pub mod adapter;
 +pub mod adapters;
 +pub mod client;
 +pub mod discovery;
 +pub mod manager;
++
 +pub use adapter::IpcAdapter;
 +pub use manager::{ConnectionManager, IpcEvent};

gargears/src/main.rsadded

 +mod app;
 +mod config;
 +mod daemon;
 +mod ipc;
 +mod panels;
 +mod ui;
++
 +use anyhow::Result;
 +use clap::Parser;
 +use std::thread;
 +use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
++
 +#[derive(Parser, Debug)]
 +#[command(name = "gargears")]
 +#[command(about = "Centralized GUI for gardesk configuration")]
 +struct Args {
 +    /// Run as daemon (persistent, with tray integration)
 +    #[arg(short, long)]
 +    daemon: bool,
++
 +    /// Don't fork to background (daemon mode only)
 +    #[arg(long)]
 +    no_fork: bool,
++
 +    /// Initial panel to show
 +    #[arg(short, long)]
 +    panel: Option<String>,
 +}
++
 +fn main() -> Result<()> {
 +    // Initialize logging
 +    tracing_subscriber::registry()
 +        .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")))
 +        .with(tracing_subscriber::fmt::layer())
 +        .init();
++
 +    let args = Args::parse();
++
 +    tracing::info!("Starting gargears");
++
 +    if args.daemon {
 +        run_daemon(&args)
 +    } else {
 +        run_gui(&args)
 +    }
 +}
++
 +fn run_daemon(args: &Args) -> Result<()> {
 +    // Check if another daemon is already running
 +    let socket_path = gargears_ipc::socket_path();
 +    if socket_path.exists() {
 +        // Try to connect to see if it's actually running
 +        if std::os::unix::net::UnixStream::connect(&socket_path).is_ok() {
 +            tracing::error!("Another gargears daemon is already running");
 +            return Err(anyhow::anyhow!("Daemon already running"));
 +        }
 +        // Stale socket, remove it
 +        let _ = std::fs::remove_file(&socket_path);
 +    }
++
 +    // Create command channel
 +    let (command_tx, command_rx) = daemon::create_command_channel();
++
 +    // Create app in daemon mode (starts hidden)
 +    let initial_panel = args.panel.as_deref();
 +    let mut app = app::App::new_daemon(initial_panel)?;
++
 +    // Get visibility state for IPC server
 +    let visible_state = app.visible_state();
++
 +    // Start IPC server in background thread
 +    let ipc_server = daemon::IpcServer::new(command_tx)?;
 +    thread::spawn(move || {
 +        ipc_server.run(visible_state);
 +    });
++
 +    tracing::info!("gargears daemon started");
 +    tracing::info!("Use 'gargearsctl show' or 'gargearsctl toggle' to show the window");
++
 +    // Send startup notification
 +    daemon::notify_startup();
++
 +    // Run app event loop
 +    app.run_daemon(command_rx)
 +}
++
 +fn run_gui(args: &Args) -> Result<()> {
 +    let initial_panel = args.panel.as_deref();
 +    let mut app = app::App::new(initial_panel)?;
 +    app.run()
 +}

gargears/src/panels/gar.rsadded

 +//! Configuration panel for gar (window manager)
++
 +use crate::config::{GarSettings, LuaConfigWriter, LuaValue};
 +use crate::ipc::adapters::{GarAdapter, GarKeybind, GarRule};
 +use crate::ui::widgets::{Button, ColorPicker, List, NumberInput, Section, Toggle, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Key, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Gar configuration panel
 +pub struct GarPanel {
 +    adapter: GarAdapter,
++
 +    // Sections
 +    borders_section: Section,
 +    gaps_section: Section,
 +    titlebar_section: Section,
 +    behavior_section: Section,
++
 +    // Border settings
 +    border_width: NumberInput,
 +    border_color_focused: ColorPicker,
 +    border_color_unfocused: ColorPicker,
++
 +    // Gap settings
 +    gap_inner: NumberInput,
 +    gap_outer: NumberInput,
++
 +    // Titlebar settings
 +    titlebar_enabled: Toggle,
 +    titlebar_height: NumberInput,
++
 +    // Behavior settings
 +    focus_follows_mouse: Toggle,
 +    mouse_follows_focus: Toggle,
++
 +    // Keybinds section (read-only)
 +    keybinds_section: Section,
 +    keybinds_list: List,
++
 +    // Window rules section (read-only)
 +    rules_section: Section,
 +    rules_list: List,
++
 +    // Action buttons
 +    apply_button: Button,
 +    reset_button: Button,
 +    save_button: Button,
++
 +    // State
 +    original_values: GarValues,
 +    dirty: bool,
 +    scroll_offset: i32,
 +    instant_apply: bool,
 +    pending_change: Option<&'static str>,
 +}
++
 +#[derive(Clone, Default)]
 +struct GarValues {
 +    border_width: i32,
 +    border_color_focused: String,
 +    border_color_unfocused: String,
 +    gap_inner: i32,
 +    gap_outer: i32,
 +    titlebar_enabled: bool,
 +    titlebar_height: i32,
 +    focus_follows_mouse: bool,
 +    mouse_follows_focus: bool,
 +}
++
 +impl GarPanel {
 +    pub fn new(mut adapter: GarAdapter) -> Self {
 +        // Try to get current values
 +        let values = if adapter.is_connected() {
 +            Self::fetch_values(&mut adapter)
 +        } else {
 +            GarValues::default()
 +        };
++
 +        // Fetch keybinds and rules
 +        let keybinds = if adapter.is_connected() {
 +            adapter.query_keybinds().unwrap_or_default()
 +        } else {
 +            vec![]
 +        };
 +        let rules = if adapter.is_connected() {
 +            adapter.query_rules().unwrap_or_default()
 +        } else {
 +            vec![]
 +        };
++
 +        let keybind_items: Vec<String> = keybinds.iter().map(|k| k.display()).collect();
 +        let rule_items: Vec<String> = rules.iter().map(|r| r.display()).collect();
++
 +        Self {
 +            adapter,
 +            borders_section: Section::new("Borders"),
 +            gaps_section: Section::new("Gaps"),
 +            titlebar_section: Section::new("Titlebar"),
 +            behavior_section: Section::new("Behavior"),
 +            border_width: NumberInput::new("Border Width", values.border_width)
 +                .with_range(0, 10)
 +                .with_step(1),
 +            border_color_focused: ColorPicker::new("Focused Color", &values.border_color_focused),
 +            border_color_unfocused: ColorPicker::new("Unfocused Color", &values.border_color_unfocused),
 +            gap_inner: NumberInput::new("Inner Gap", values.gap_inner)
 +                .with_range(0, 50)
 +                .with_step(2),
 +            gap_outer: NumberInput::new("Outer Gap", values.gap_outer)
 +                .with_range(0, 50)
 +                .with_step(2),
 +            titlebar_enabled: Toggle::new("Enabled", values.titlebar_enabled),
 +            titlebar_height: NumberInput::new("Height", values.titlebar_height)
 +                .with_range(0, 48)
 +                .with_step(2),
 +            focus_follows_mouse: Toggle::new("Focus Follows Mouse", values.focus_follows_mouse),
 +            mouse_follows_focus: Toggle::new("Mouse Follows Focus", values.mouse_follows_focus),
 +            keybinds_section: Section::new("Keybinds (read-only)"),
 +            keybinds_list: List::new().with_items(keybind_items).with_max_visible(4),
 +            rules_section: Section::new("Window Rules (read-only)"),
 +            rules_list: List::new().with_items(rule_items).with_max_visible(4),
 +            apply_button: Button::new("Apply").primary(),
 +            reset_button: Button::new("Reset"),
 +            save_button: Button::new("Save"),
 +            original_values: values,
 +            dirty: false,
 +            scroll_offset: 0,
 +            instant_apply: true,
 +            pending_change: None,
 +        }
 +    }
++
 +    fn fetch_values(adapter: &mut GarAdapter) -> GarValues {
 +        // Try to query config from gar
 +        if let Ok(config) = adapter.query_config() {
 +            GarValues {
 +                border_width: config.border_width.unwrap_or(2) as i32,
 +                border_color_focused: config.border_color_focused.unwrap_or_else(|| "#5294e2".into()),
 +                border_color_unfocused: config
 +                    .border_color_unfocused
 +                    .unwrap_or_else(|| "#3c3c3c".into()),
 +                gap_inner: config.gap_inner.unwrap_or(8) as i32,
 +                gap_outer: config.gap_outer.unwrap_or(8) as i32,
 +                titlebar_enabled: config.titlebar_enabled.unwrap_or(false),
 +                titlebar_height: config.titlebar_height.unwrap_or(24) as i32,
 +                focus_follows_mouse: config.focus_follows_mouse.unwrap_or(false),
 +                mouse_follows_focus: config.mouse_follows_focus.unwrap_or(false),
 +            }
 +        } else {
 +            GarValues {
 +                border_width: 2,
 +                border_color_focused: "#5294e2".into(),
 +                border_color_unfocused: "#3c3c3c".into(),
 +                gap_inner: 8,
 +                gap_outer: 8,
 +                titlebar_enabled: false,
 +                titlebar_height: 24,
 +                focus_follows_mouse: false,
 +                mouse_follows_focus: false,
 +            }
 +        }
 +    }
++
 +    fn check_dirty(&mut self) {
 +        self.dirty = self.border_width.value != self.original_values.border_width
 +            || self.border_color_focused.value != self.original_values.border_color_focused
 +            || self.border_color_unfocused.value != self.original_values.border_color_unfocused
 +            || self.gap_inner.value != self.original_values.gap_inner
 +            || self.gap_outer.value != self.original_values.gap_outer
 +            || self.titlebar_enabled.value != self.original_values.titlebar_enabled
 +            || self.titlebar_height.value != self.original_values.titlebar_height
 +            || self.focus_follows_mouse.value != self.original_values.focus_follows_mouse
 +            || self.mouse_follows_focus.value != self.original_values.mouse_follows_focus;
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 36;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Borders section
 +        self.borders_section.bounds = Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.borders_section.expanded {
 +            self.border_width.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.border_color_focused.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.border_color_unfocused.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Gaps section
 +        self.gaps_section.bounds = Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.gaps_section.expanded {
 +            self.gap_inner.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.gap_outer.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Titlebar section
 +        self.titlebar_section.bounds = Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.titlebar_section.expanded {
 +            self.titlebar_enabled.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.titlebar_height.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Behavior section
 +        self.behavior_section.bounds = Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.behavior_section.expanded {
 +            self.focus_follows_mouse.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.mouse_follows_focus.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Keybinds section (read-only)
 +        self.keybinds_section.bounds = Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.keybinds_section.expanded {
 +            let list_height = (row_height * 4).min(120) as u32;
 +            self.keybinds_list.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, list_height);
 +            y += list_height as i32 + 4;
 +        }
++
 +        y += padding / 2;
++
 +        // Rules section (read-only)
 +        self.rules_section.bounds = Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.rules_section.expanded {
 +            let list_height = (row_height * 4).min(120) as u32;
 +            self.rules_list.bounds = Rect::new(bounds.x + padding + 16, y, widget_width - 16, list_height);
 +        }
++
 +        // Action buttons at bottom
 +        let button_y = bounds.y + bounds.height as i32 - padding - 36;
 +        let button_width = 80;
++
 +        self.reset_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width * 3 - 16,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
++
 +        self.apply_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width * 2 - 8,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
++
 +        self.save_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
 +    }
 +}
++
 +impl Panel for GarPanel {
 +    fn name(&self) -> &str {
 +        "gar"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Tiling window manager"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        self.dirty
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections and widgets
 +        self.borders_section.render(renderer, theme)?;
 +        if self.borders_section.expanded {
 +            self.border_width.render(renderer, theme)?;
 +            self.border_color_focused.render(renderer, theme)?;
 +            self.border_color_unfocused.render(renderer, theme)?;
 +        }
++
 +        self.gaps_section.render(renderer, theme)?;
 +        if self.gaps_section.expanded {
 +            self.gap_inner.render(renderer, theme)?;
 +            self.gap_outer.render(renderer, theme)?;
 +        }
++
 +        self.titlebar_section.render(renderer, theme)?;
 +        if self.titlebar_section.expanded {
 +            self.titlebar_enabled.render(renderer, theme)?;
 +            self.titlebar_height.render(renderer, theme)?;
 +        }
++
 +        self.behavior_section.render(renderer, theme)?;
 +        if self.behavior_section.expanded {
 +            self.focus_follows_mouse.render(renderer, theme)?;
 +            self.mouse_follows_focus.render(renderer, theme)?;
 +        }
++
 +        self.keybinds_section.render(renderer, theme)?;
 +        if self.keybinds_section.expanded {
 +            self.keybinds_list.render(renderer, theme)?;
 +        }
++
 +        self.rules_section.render(renderer, theme)?;
 +        if self.rules_section.expanded {
 +            self.rules_list.render(renderer, theme)?;
 +        }
++
 +        // Render action buttons
 +        self.reset_button.render(renderer, theme)?;
 +        self.apply_button.render(renderer, theme)?;
 +        self.save_button.render(renderer, theme)?;
++
 +        // Dirty indicator
 +        if self.dirty {
 +            let indicator_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.75)
 +                .color(gartk_core::Color::from_u8(0xff, 0xb8, 0x6c, 0xff));
++
 +            renderer.text(
 +                "● Unsaved changes",
 +                (bounds.x + theme.padding as i32) as f64,
 +                (bounds.y + bounds.height as i32 - theme.padding as i32 - 28) as f64,
 +                &indicator_style,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::Key(ke) if ke.pressed => {
 +                // Handle text input keys - with instant apply support
 +                if let WidgetEvent::Changed = self.border_color_focused.on_key(&ke.key) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("border_color_focused");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
 +                if let WidgetEvent::Changed = self.border_color_unfocused.on_key(&ke.key) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("border_color_unfocused");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
++
 +                // Scroll with Page Up/Down
 +                match &ke.key {
 +                    Key::PageUp => {
 +                        self.scroll_offset = (self.scroll_offset - 100).max(0);
 +                        return PanelAction::Redraw;
 +                    }
 +                    Key::PageDown => {
 +                        self.scroll_offset += 100;
 +                        return PanelAction::Redraw;
 +                    }
 +                    _ => {}
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.borders_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.gaps_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.titlebar_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.behavior_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.keybinds_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.rules_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Check widgets - with instant apply support
 +                if let WidgetEvent::Changed = self.border_width.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("border_width");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
 +                if let WidgetEvent::Changed = self.gap_inner.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("gap_inner");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
 +                if let WidgetEvent::Changed = self.gap_outer.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("gap_outer");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
 +                if let WidgetEvent::Changed = self.titlebar_enabled.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("titlebar_enabled");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
 +                if let WidgetEvent::Changed = self.titlebar_height.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("titlebar_height");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
 +                if let WidgetEvent::Changed = self.focus_follows_mouse.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("focus_follows_mouse");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
 +                if let WidgetEvent::Changed = self.mouse_follows_focus.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("mouse_follows_focus");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
++
 +                // Color inputs - clear other focus first, then check clicks
 +                // This ensures only one color picker is focused at a time
 +                let input1_bounds = self.border_color_focused.bounds;
 +                let input2_bounds = self.border_color_unfocused.bounds;
 +                let in_input1 = x >= input1_bounds.x && x < input1_bounds.x + input1_bounds.width as i32
 +                    && y >= input1_bounds.y && y < input1_bounds.y + input1_bounds.height as i32;
 +                let in_input2 = x >= input2_bounds.x && x < input2_bounds.x + input2_bounds.width as i32
 +                    && y >= input2_bounds.y && y < input2_bounds.y + input2_bounds.height as i32;
++
 +                // Clear focus from the other picker when clicking one
 +                if in_input1 {
 +                    self.border_color_unfocused.blur();
 +                } else if in_input2 {
 +                    self.border_color_focused.blur();
 +                } else {
 +                    // Clicking elsewhere - blur both
 +                    self.border_color_focused.blur();
 +                    self.border_color_unfocused.blur();
 +                }
++
 +                let focused1 = self.border_color_focused.on_click(x, y);
 +                let focused2 = self.border_color_unfocused.on_click(x, y);
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.apply_button.on_click(x, y) {
 +                    return PanelAction::Apply;
 +                }
 +                if let WidgetEvent::Clicked = self.reset_button.on_click(x, y) {
 +                    return PanelAction::Reset;
 +                }
 +                if let WidgetEvent::Clicked = self.save_button.on_click(x, y) {
 +                    return PanelAction::Save;
 +                }
++
 +                // Redraw if focus state changed (Focus or Blur events)
 +                if matches!(focused1, WidgetEvent::Focus | WidgetEvent::Blur)
 +                    || matches!(focused2, WidgetEvent::Focus | WidgetEvent::Blur)
 +                {
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
++
 +        changed |= self.borders_section.on_mouse_move(x, y);
 +        changed |= self.gaps_section.on_mouse_move(x, y);
 +        changed |= self.titlebar_section.on_mouse_move(x, y);
 +        changed |= self.behavior_section.on_mouse_move(x, y);
 +        changed |= self.keybinds_section.on_mouse_move(x, y);
 +        changed |= self.rules_section.on_mouse_move(x, y);
++
 +        changed |= self.border_width.on_mouse_move(x, y);
 +        changed |= self.border_color_focused.on_mouse_move(x, y);
 +        changed |= self.border_color_unfocused.on_mouse_move(x, y);
 +        changed |= self.gap_inner.on_mouse_move(x, y);
 +        changed |= self.gap_outer.on_mouse_move(x, y);
 +        changed |= self.titlebar_enabled.on_mouse_move(x, y);
 +        changed |= self.titlebar_height.on_mouse_move(x, y);
 +        changed |= self.focus_follows_mouse.on_mouse_move(x, y);
 +        changed |= self.mouse_follows_focus.on_mouse_move(x, y);
++
 +        changed |= self.apply_button.on_mouse_move(x, y);
 +        changed |= self.reset_button.on_mouse_move(x, y);
 +        changed |= self.save_button.on_mouse_move(x, y);
++
 +        changed
 +    }
++
 +    fn blur_focused(&mut self) {
 +        self.border_color_focused.blur();
 +        self.border_color_unfocused.blur();
 +    }
++
 +    fn reset(&mut self) {
 +        self.border_width.value = self.original_values.border_width;
 +        self.border_color_focused.value = self.original_values.border_color_focused.clone();
 +        self.border_color_unfocused.value = self.original_values.border_color_unfocused.clone();
 +        self.gap_inner.value = self.original_values.gap_inner;
 +        self.gap_outer.value = self.original_values.gap_outer;
 +        self.titlebar_enabled.value = self.original_values.titlebar_enabled;
 +        self.titlebar_height.value = self.original_values.titlebar_height;
 +        self.focus_follows_mouse.value = self.original_values.focus_follows_mouse;
 +        self.mouse_follows_focus.value = self.original_values.mouse_follows_focus;
 +        self.dirty = false;
 +    }
++
 +    fn apply(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        // Send IPC commands for changed values
 +        if self.border_width.value != self.original_values.border_width {
 +            self.adapter.set_config_value(
 +                "border_width",
 +                serde_json::json!(self.border_width.value),
 +            )?;
 +        }
++
 +        if self.gap_inner.value != self.original_values.gap_inner {
 +            self.adapter
 +                .set_config_value("gap_inner", serde_json::json!(self.gap_inner.value))?;
 +        }
++
 +        if self.gap_outer.value != self.original_values.gap_outer {
 +            self.adapter
 +                .set_config_value("gap_outer", serde_json::json!(self.gap_outer.value))?;
 +        }
++
 +        if self.border_color_focused.value != self.original_values.border_color_focused {
 +            self.adapter.set_config_value(
 +                "border_color_focused",
 +                serde_json::json!(self.border_color_focused.value),
 +            )?;
 +        }
++
 +        if self.border_color_unfocused.value != self.original_values.border_color_unfocused {
 +            self.adapter.set_config_value(
 +                "border_color_unfocused",
 +                serde_json::json!(self.border_color_unfocused.value),
 +            )?;
 +        }
++
 +        if self.focus_follows_mouse.value != self.original_values.focus_follows_mouse {
 +            self.adapter.set_config_value(
 +                "focus_follows_mouse",
 +                serde_json::json!(self.focus_follows_mouse.value),
 +            )?;
 +        }
++
 +        if self.mouse_follows_focus.value != self.original_values.mouse_follows_focus {
 +            self.adapter.set_config_value(
 +                "mouse_follows_focus",
 +                serde_json::json!(self.mouse_follows_focus.value),
 +            )?;
 +        }
++
 +        if self.titlebar_enabled.value != self.original_values.titlebar_enabled {
 +            self.adapter.set_config_value(
 +                "titlebar_enabled",
 +                serde_json::json!(self.titlebar_enabled.value),
 +            )?;
 +        }
++
 +        if self.titlebar_height.value != self.original_values.titlebar_height {
 +            self.adapter.set_config_value(
 +                "titlebar_height",
 +                serde_json::json!(self.titlebar_height.value),
 +            )?;
 +        }
++
 +        // Update original values
 +        self.original_values = GarValues {
 +            border_width: self.border_width.value,
 +            border_color_focused: self.border_color_focused.value.clone(),
 +            border_color_unfocused: self.border_color_unfocused.value.clone(),
 +            gap_inner: self.gap_inner.value,
 +            gap_outer: self.gap_outer.value,
 +            titlebar_enabled: self.titlebar_enabled.value,
 +            titlebar_height: self.titlebar_height.value,
 +            focus_follows_mouse: self.focus_follows_mouse.value,
 +            mouse_follows_focus: self.mouse_follows_focus.value,
 +        };
++
 +        self.dirty = false;
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        // Could refresh values from status
 +    }
++
 +    fn has_config_file(&self) -> bool {
 +        true
 +    }
++
 +    fn save_to_config(&mut self) -> Result<()> {
 +        let mut writer = LuaConfigWriter::load()?;
++
 +        // Build settings from current values
 +        let settings = GarSettings {
 +            border_width: Some(self.border_width.value as u32),
 +            gap_inner: Some(self.gap_inner.value as u32),
 +            gap_outer: Some(self.gap_outer.value as u32),
 +            border_color_focused: Some(self.border_color_focused.value.clone()),
 +            border_color_unfocused: Some(self.border_color_unfocused.value.clone()),
 +            border_color_urgent: None, // Not yet exposed in panel UI
 +            focus_follows_mouse: Some(self.focus_follows_mouse.value),
 +        };
++
 +        // Write settings as gar.set() calls
 +        writer.set_values(&settings.to_lua_statements());
++
 +        // Save the file
 +        writer.save()?;
++
 +        // Trigger reload
 +        crate::config::reload_component("gar")?;
++
 +        Ok(())
 +    }
++
 +    fn set_instant_apply(&mut self, enabled: bool) {
 +        self.instant_apply = enabled;
 +    }
++
 +    fn instant_apply_enabled(&self) -> bool {
 +        self.instant_apply
 +    }
++
 +    fn apply_instant(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        // Apply only the pending change
 +        if let Some(field) = self.pending_change.take() {
 +            let result = match field {
 +                "border_width" => self.adapter.set_config_value(
 +                    "border_width",
 +                    serde_json::json!(self.border_width.value),
 +                ),
 +                "gap_inner" => self.adapter.set_config_value(
 +                    "gap_inner",
 +                    serde_json::json!(self.gap_inner.value),
 +                ),
 +                "gap_outer" => self.adapter.set_config_value(
 +                    "gap_outer",
 +                    serde_json::json!(self.gap_outer.value),
 +                ),
 +                "border_color_focused" => self.adapter.set_config_value(
 +                    "border_color_focused",
 +                    serde_json::json!(self.border_color_focused.value),
 +                ),
 +                "border_color_unfocused" => self.adapter.set_config_value(
 +                    "border_color_unfocused",
 +                    serde_json::json!(self.border_color_unfocused.value),
 +                ),
 +                "focus_follows_mouse" => self.adapter.set_config_value(
 +                    "focus_follows_mouse",
 +                    serde_json::json!(self.focus_follows_mouse.value),
 +                ),
 +                "mouse_follows_focus" => self.adapter.set_config_value(
 +                    "mouse_follows_focus",
 +                    serde_json::json!(self.mouse_follows_focus.value),
 +                ),
 +                "titlebar_enabled" => self.adapter.set_config_value(
 +                    "titlebar_enabled",
 +                    serde_json::json!(self.titlebar_enabled.value),
 +                ),
 +                "titlebar_height" => self.adapter.set_config_value(
 +                    "titlebar_height",
 +                    serde_json::json!(self.titlebar_height.value),
 +                ),
 +                _ => Ok(()),
 +            };
++
 +            // Update original value for this field if successful
 +            if result.is_ok() {
 +                match field {
 +                    "border_width" => self.original_values.border_width = self.border_width.value,
 +                    "gap_inner" => self.original_values.gap_inner = self.gap_inner.value,
 +                    "gap_outer" => self.original_values.gap_outer = self.gap_outer.value,
 +                    "border_color_focused" => {
 +                        self.original_values.border_color_focused = self.border_color_focused.value.clone()
 +                    }
 +                    "border_color_unfocused" => {
 +                        self.original_values.border_color_unfocused = self.border_color_unfocused.value.clone()
 +                    }
 +                    "focus_follows_mouse" => {
 +                        self.original_values.focus_follows_mouse = self.focus_follows_mouse.value
 +                    }
 +                    "mouse_follows_focus" => {
 +                        self.original_values.mouse_follows_focus = self.mouse_follows_focus.value
 +                    }
 +                    "titlebar_enabled" => {
 +                        self.original_values.titlebar_enabled = self.titlebar_enabled.value
 +                    }
 +                    "titlebar_height" => {
 +                        self.original_values.titlebar_height = self.titlebar_height.value
 +                    }
 +                    _ => {}
 +                }
 +                self.check_dirty();
 +            }
++
 +            result
 +        } else {
 +            Ok(())
 +        }
 +    }
 +}

gargears/src/panels/garbar.rsadded

 +//! Configuration panel for garbar (status bar)
++
 +use crate::config::{GarbarSettings, LuaConfigWriter};
 +use crate::ipc::adapters::GarbarAdapter;
 +use crate::ui::widgets::{Button, NumberInput, Section, TextInput, Toggle, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Key, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garbar configuration panel
 +pub struct GarbarPanel {
 +    adapter: GarbarAdapter,
++
 +    // Sections
 +    general_section: Section,
 +    modules_left_section: Section,
 +    modules_center_section: Section,
 +    modules_right_section: Section,
++
 +    // General settings
 +    height: NumberInput,
 +    position: Toggle, // top/bottom
 +    visible: Toggle,
++
 +    // Module lists (display only for now, editing is complex)
 +    modules_left_display: TextInput,
 +    modules_center_display: TextInput,
 +    modules_right_display: TextInput,
++
 +    // Action buttons
 +    apply_button: Button,
 +    reset_button: Button,
 +    reload_button: Button,
 +    save_button: Button,
++
 +    // State
 +    original_values: GarbarValues,
 +    dirty: bool,
 +    scroll_offset: i32,
 +    instant_apply: bool,
 +    pending_change: Option<&'static str>,
 +}
++
 +#[derive(Clone, Default)]
 +struct GarbarValues {
 +    height: i32,
 +    position_top: bool,
 +    visible: bool,
 +    modules_left: String,
 +    modules_center: String,
 +    modules_right: String,
 +}
++
 +impl GarbarPanel {
 +    pub fn new(mut adapter: GarbarAdapter) -> Self {
 +        let values = if adapter.is_connected() {
 +            Self::fetch_values(&mut adapter)
 +        } else {
 +            GarbarValues::default()
 +        };
++
 +        Self {
 +            adapter,
 +            general_section: Section::new("General"),
 +            modules_left_section: Section::new("Modules Left"),
 +            modules_center_section: Section::new("Modules Center"),
 +            modules_right_section: Section::new("Modules Right"),
 +            height: NumberInput::new("Height", values.height)
 +                .with_range(16, 64)
 +                .with_step(2),
 +            position: Toggle::new("Position Top", values.position_top),
 +            visible: Toggle::new("Visible", values.visible),
 +            modules_left_display: TextInput::new("Modules", &values.modules_left)
 +                .with_placeholder("workspaces, title"),
 +            modules_center_display: TextInput::new("Modules", &values.modules_center)
 +                .with_placeholder("clock"),
 +            modules_right_display: TextInput::new("Modules", &values.modules_right)
 +                .with_placeholder("cpu, memory, battery"),
 +            apply_button: Button::new("Apply").primary(),
 +            reset_button: Button::new("Reset"),
 +            reload_button: Button::new("Reload"),
 +            save_button: Button::new("Save"),
 +            original_values: values,
 +            dirty: false,
 +            scroll_offset: 0,
 +            instant_apply: true,
 +            pending_change: None,
 +        }
 +    }
++
 +    fn fetch_values(adapter: &mut GarbarAdapter) -> GarbarValues {
 +        if let Ok(status) = adapter.status() {
 +            let position_top = status
 +                .position
 +                .as_ref()
 +                .map(|p| p == "top")
 +                .unwrap_or(true);
 +            GarbarValues {
 +                height: status.height as i32,
 +                position_top,
 +                visible: status.visible,
 +                modules_left: status.modules_left.join(", "),
 +                modules_center: status.modules_center.join(", "),
 +                modules_right: status.modules_right.join(", "),
 +            }
 +        } else {
 +            GarbarValues {
 +                height: 28,
 +                position_top: true,
 +                visible: true,
 +                modules_left: "workspaces".into(),
 +                modules_center: String::new(),
 +                modules_right: "clock".into(),
 +            }
 +        }
 +    }
++
 +    fn check_dirty(&mut self) {
 +        self.dirty = self.height.value != self.original_values.height
 +            || self.position.value != self.original_values.position_top
 +            || self.visible.value != self.original_values.visible
 +            || self.modules_left_display.value != self.original_values.modules_left
 +            || self.modules_center_display.value != self.original_values.modules_center
 +            || self.modules_right_display.value != self.original_values.modules_right;
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 36;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // General section
 +        self.general_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.general_section.expanded {
 +            self.height.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.position.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.visible.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Modules Left section
 +        self.modules_left_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.modules_left_section.expanded {
 +            self.modules_left_display.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Modules Center section
 +        self.modules_center_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.modules_center_section.expanded {
 +            self.modules_center_display.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Modules Right section
 +        self.modules_right_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.modules_right_section.expanded {
 +            self.modules_right_display.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +        }
++
 +        // Action buttons at bottom
 +        let button_y = bounds.y + bounds.height as i32 - padding - 36;
 +        let button_width = 68;
++
 +        self.reload_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width * 4 - 24,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
++
 +        self.reset_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width * 3 - 16,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
++
 +        self.apply_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width * 2 - 8,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
++
 +        self.save_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
 +    }
 +}
++
 +impl Panel for GarbarPanel {
 +    fn name(&self) -> &str {
 +        "garbar"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Status bar"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        self.dirty
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections and widgets
 +        self.general_section.render(renderer, theme)?;
 +        if self.general_section.expanded {
 +            self.height.render(renderer, theme)?;
 +            self.position.render(renderer, theme)?;
 +            self.visible.render(renderer, theme)?;
 +        }
++
 +        self.modules_left_section.render(renderer, theme)?;
 +        if self.modules_left_section.expanded {
 +            self.modules_left_display.render(renderer, theme)?;
 +        }
++
 +        self.modules_center_section.render(renderer, theme)?;
 +        if self.modules_center_section.expanded {
 +            self.modules_center_display.render(renderer, theme)?;
 +        }
++
 +        self.modules_right_section.render(renderer, theme)?;
 +        if self.modules_right_section.expanded {
 +            self.modules_right_display.render(renderer, theme)?;
 +        }
++
 +        // Render action buttons
 +        self.reload_button.render(renderer, theme)?;
 +        self.reset_button.render(renderer, theme)?;
 +        self.apply_button.render(renderer, theme)?;
 +        self.save_button.render(renderer, theme)?;
++
 +        // Dirty indicator
 +        if self.dirty {
 +            let indicator_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.75)
 +                .color(gartk_core::Color::from_u8(0xff, 0xb8, 0x6c, 0xff));
++
 +            renderer.text(
 +                "● Unsaved changes",
 +                (bounds.x + theme.padding as i32) as f64,
 +                (bounds.y + bounds.height as i32 - theme.padding as i32 - 28) as f64,
 +                &indicator_style,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::Key(ke) if ke.pressed => {
 +                // Handle text input keys
 +                if let WidgetEvent::Changed = self.modules_left_display.on_key(&ke.key) {
 +                    self.check_dirty();
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.modules_center_display.on_key(&ke.key) {
 +                    self.check_dirty();
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.modules_right_display.on_key(&ke.key) {
 +                    self.check_dirty();
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Scroll with Page Up/Down
 +                match &ke.key {
 +                    Key::PageUp => {
 +                        self.scroll_offset = (self.scroll_offset - 100).max(0);
 +                        return PanelAction::Redraw;
 +                    }
 +                    Key::PageDown => {
 +                        self.scroll_offset += 100;
 +                        return PanelAction::Redraw;
 +                    }
 +                    _ => {}
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.general_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.modules_left_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.modules_center_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.modules_right_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Check widgets - with instant apply support
 +                if let WidgetEvent::Changed = self.height.on_click(x, y) {
 +                    self.check_dirty();
 +                    // Height change needs config save + reload, no instant apply
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.position.on_click(x, y) {
 +                    self.check_dirty();
 +                    // Position change needs config save + reload, no instant apply
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.visible.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("visible");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
++
 +                // Text inputs
 +                self.modules_left_display.on_click(x, y);
 +                self.modules_center_display.on_click(x, y);
 +                self.modules_right_display.on_click(x, y);
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.apply_button.on_click(x, y) {
 +                    return PanelAction::Apply;
 +                }
 +                if let WidgetEvent::Clicked = self.reset_button.on_click(x, y) {
 +                    return PanelAction::Reset;
 +                }
 +                if let WidgetEvent::Clicked = self.reload_button.on_click(x, y) {
 +                    // Special: reload config
 +                    let _ = self.adapter.reload();
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.save_button.on_click(x, y) {
 +                    return PanelAction::Save;
 +                }
++
 +                PanelAction::Redraw
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.general_section.on_mouse_move(x, y);
 +        changed |= self.modules_left_section.on_mouse_move(x, y);
 +        changed |= self.modules_center_section.on_mouse_move(x, y);
 +        changed |= self.modules_right_section.on_mouse_move(x, y);
++
 +        changed |= self.height.on_mouse_move(x, y);
 +        changed |= self.position.on_mouse_move(x, y);
 +        changed |= self.visible.on_mouse_move(x, y);
 +        changed |= self.modules_left_display.on_mouse_move(x, y);
 +        changed |= self.modules_center_display.on_mouse_move(x, y);
 +        changed |= self.modules_right_display.on_mouse_move(x, y);
++
 +        changed |= self.apply_button.on_mouse_move(x, y);
 +        changed |= self.reset_button.on_mouse_move(x, y);
 +        changed |= self.reload_button.on_mouse_move(x, y);
 +        changed |= self.save_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {
 +        self.height.value = self.original_values.height;
 +        self.position.value = self.original_values.position_top;
 +        self.visible.value = self.original_values.visible;
 +        self.modules_left_display.value = self.original_values.modules_left.clone();
 +        self.modules_center_display.value = self.original_values.modules_center.clone();
 +        self.modules_right_display.value = self.original_values.modules_right.clone();
 +        self.dirty = false;
 +    }
++
 +    fn apply(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        // Toggle visibility if changed
 +        if self.visible.value != self.original_values.visible {
 +            if self.visible.value {
 +                self.adapter.show()?;
 +            } else {
 +                self.adapter.hide()?;
 +            }
 +        }
++
 +        // Note: height and module changes require config file edit + reload
 +        // For now we just reload to pick up any manual config changes
 +        if self.height.value != self.original_values.height {
 +            // Would need to edit Lua config and reload
 +            self.adapter.reload()?;
 +        }
++
 +        // Update original values
 +        self.original_values = GarbarValues {
 +            height: self.height.value,
 +            position_top: self.position.value,
 +            visible: self.visible.value,
 +            modules_left: self.modules_left_display.value.clone(),
 +            modules_center: self.modules_center_display.value.clone(),
 +            modules_right: self.modules_right_display.value.clone(),
 +        };
++
 +        self.dirty = false;
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        // Could refresh values from status
 +    }
++
 +    fn has_config_file(&self) -> bool {
 +        true
 +    }
++
 +    fn save_to_config(&mut self) -> Result<()> {
 +        let mut writer = LuaConfigWriter::load()?;
++
 +        // Parse module lists from comma-separated strings
 +        let parse_modules = |s: &str| -> Vec<String> {
 +            s.split(',')
 +                .map(|m| m.trim().to_string())
 +                .filter(|m| !m.is_empty())
 +                .collect()
 +        };
++
 +        let settings = GarbarSettings {
 +            height: Some(self.height.value as u32),
 +            position: Some(if self.position.value { "top" } else { "bottom" }.to_string()),
 +            modules_left: Some(parse_modules(&self.modules_left_display.value)),
 +            modules_center: Some(parse_modules(&self.modules_center_display.value)),
 +            modules_right: Some(parse_modules(&self.modules_right_display.value)),
 +            ..Default::default()
 +        };
++
 +        writer.set_bar_table(&settings);
 +        writer.save()?;
++
 +        // Trigger reload
 +        crate::config::reload_component("garbar")?;
++
 +        Ok(())
 +    }
++
 +    fn set_instant_apply(&mut self, enabled: bool) {
 +        self.instant_apply = enabled;
 +    }
++
 +    fn instant_apply_enabled(&self) -> bool {
 +        self.instant_apply
 +    }
++
 +    fn apply_instant(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        // Apply only the pending change
 +        if let Some(field) = self.pending_change.take() {
 +            match field {
 +                "visible" => {
 +                    if self.visible.value != self.original_values.visible {
 +                        if self.visible.value {
 +                            self.adapter.show()?;
 +                        } else {
 +                            self.adapter.hide()?;
 +                        }
 +                        self.original_values.visible = self.visible.value;
 +                    }
 +                }
 +                _ => {}
 +            }
 +            self.check_dirty();
 +        }
++
 +        Ok(())
 +    }
 +}

gargears/src/panels/garbg.rsadded

 +//! Configuration panel for garbg (wallpaper daemon)
++
 +use crate::config::{GarbgConfig, GarbgSlideshow};
 +use crate::ipc::adapters::GarbgAdapter;
 +use crate::ui::widgets::{Button, Label, NumberInput, Section, Toggle, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Key, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garbg configuration panel
 +pub struct GarbgPanel {
 +    adapter: GarbgAdapter,
++
 +    // Sections
 +    current_section: Section,
 +    playlist_section: Section,
 +    slideshow_section: Section,
 +    controls_section: Section,
++
 +    // Current wallpaper info (read-only display)
 +    current_source: Label,
 +    current_wallpaper: Label,
 +    playlist_position: Label,
++
 +    // Slideshow settings
 +    interval: NumberInput,
 +    paused: Toggle,
++
 +    // Control buttons
 +    prev_button: Button,
 +    next_button: Button,
 +    pause_button: Button,
++
 +    // Action buttons
 +    apply_button: Button,
 +    reset_button: Button,
 +    save_button: Button,
++
 +    // State
 +    original_values: GarbgValues,
 +    dirty: bool,
 +    scroll_offset: i32,
 +    instant_apply: bool,
 +    pending_change: Option<&'static str>,
 +}
++
 +#[derive(Clone, Default)]
 +struct GarbgValues {
 +    interval: i32,
 +    paused: bool,
 +}
++
 +impl GarbgPanel {
 +    pub fn new(mut adapter: GarbgAdapter) -> Self {
 +        let (values, current_source, current_wallpaper, playlist_pos) = if adapter.is_connected() {
 +            Self::fetch_values(&mut adapter)
 +        } else {
 +            (
 +                GarbgValues::default(),
 +                "Not connected".to_string(),
 +                "N/A".to_string(),
 +                "N/A".to_string(),
 +            )
 +        };
++
 +        Self {
 +            adapter,
 +            current_section: Section::new("Current Wallpaper"),
 +            playlist_section: Section::new("Playlist"),
 +            slideshow_section: Section::new("Slideshow"),
 +            controls_section: Section::new("Controls"),
 +            current_source: Label::new("Source", &current_source),
 +            current_wallpaper: Label::new("File", &current_wallpaper),
 +            playlist_position: Label::new("Position", &playlist_pos),
 +            interval: NumberInput::new("Interval (sec)", values.interval)
 +                .with_range(5, 3600)
 +                .with_step(5),
 +            paused: Toggle::new("Paused", values.paused),
 +            prev_button: Button::new("◀ Prev"),
 +            next_button: Button::new("Next ▶"),
 +            pause_button: Button::new(if values.paused { "Resume" } else { "Pause" }),
 +            apply_button: Button::new("Apply").primary(),
 +            reset_button: Button::new("Reset"),
 +            save_button: Button::new("Save"),
 +            original_values: values,
 +            dirty: false,
 +            scroll_offset: 0,
 +            instant_apply: true,
 +            pending_change: None,
 +        }
 +    }
++
 +    fn fetch_values(
 +        adapter: &mut GarbgAdapter,
 +    ) -> (GarbgValues, String, String, String) {
 +        if let Ok(status) = adapter.status() {
 +            let source = status.current_source.unwrap_or_else(|| "Unknown".into());
 +            let wallpaper = status
 +                .current_wallpaper
 +                .map(|w| {
 +                    // Shorten long paths
 +                    if w.len() > 40 {
 +                        format!("...{}", &w[w.len() - 37..])
 +                    } else {
 +                        w
 +                    }
 +                })
 +                .unwrap_or_else(|| "None".into());
 +            let playlist_pos = match (status.playlist_index, status.playlist_total) {
 +                (Some(idx), Some(total)) => format!("{} / {}", idx + 1, total),
 +                _ => "N/A".into(),
 +            };
++
 +            (
 +                GarbgValues {
 +                    interval: status.interval_secs.unwrap_or(300) as i32,
 +                    paused: status.paused,
 +                },
 +                source,
 +                wallpaper,
 +                playlist_pos,
 +            )
 +        } else {
 +            (
 +                GarbgValues {
 +                    interval: 300,
 +                    paused: false,
 +                },
 +                "Unknown".into(),
 +                "None".into(),
 +                "N/A".into(),
 +            )
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        if let Ok(status) = self.adapter.status() {
 +            self.current_source.text = status.current_source.unwrap_or_else(|| "Unknown".into());
 +            self.current_wallpaper.text = status
 +                .current_wallpaper
 +                .map(|w| {
 +                    if w.len() > 40 {
 +                        format!("...{}", &w[w.len() - 37..])
 +                    } else {
 +                        w
 +                    }
 +                })
 +                .unwrap_or_else(|| "None".into());
 +            self.playlist_position.text = match (status.playlist_index, status.playlist_total) {
 +                (Some(idx), Some(total)) => format!("{} / {}", idx + 1, total),
 +                _ => "N/A".into(),
 +            };
 +            self.paused.value = status.paused;
 +            self.pause_button = Button::new(if status.paused { "Resume" } else { "Pause" });
 +        }
 +    }
++
 +    fn check_dirty(&mut self) {
 +        self.dirty = self.interval.value != self.original_values.interval
 +            || self.paused.value != self.original_values.paused;
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 36;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Current section
 +        self.current_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.current_section.expanded {
 +            self.current_source.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.current_wallpaper.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Playlist section
 +        self.playlist_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.playlist_section.expanded {
 +            self.playlist_position.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Slideshow section
 +        self.slideshow_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.slideshow_section.expanded {
 +            self.interval.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.paused.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Controls section
 +        self.controls_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.controls_section.expanded {
 +            let control_button_width = 80;
 +            let control_y = y + 4;
++
 +            self.prev_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                control_y,
 +                control_button_width as u32,
 +                28,
 +            );
++
 +            self.pause_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + control_button_width + 8,
 +                control_y,
 +                control_button_width as u32,
 +                28,
 +            );
++
 +            self.next_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + (control_button_width + 8) * 2,
 +                control_y,
 +                control_button_width as u32,
 +                28,
 +            );
 +        }
++
 +        // Action buttons at bottom
 +        let button_y = bounds.y + bounds.height as i32 - padding - 36;
 +        let button_width = 80;
++
 +        self.reset_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width * 3 - 16,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
++
 +        self.apply_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width * 2 - 8,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
++
 +        self.save_button.bounds = Rect::new(
 +            bounds.x + bounds.width as i32 - padding - button_width,
 +            button_y,
 +            button_width as u32,
 +            32,
 +        );
 +    }
 +}
++
 +impl Panel for GarbgPanel {
 +    fn name(&self) -> &str {
 +        "garbg"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Wallpaper daemon"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        self.dirty
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections and widgets
 +        self.current_section.render(renderer, theme)?;
 +        if self.current_section.expanded {
 +            self.current_source.render(renderer, theme)?;
 +            self.current_wallpaper.render(renderer, theme)?;
 +        }
++
 +        self.playlist_section.render(renderer, theme)?;
 +        if self.playlist_section.expanded {
 +            self.playlist_position.render(renderer, theme)?;
 +        }
++
 +        self.slideshow_section.render(renderer, theme)?;
 +        if self.slideshow_section.expanded {
 +            self.interval.render(renderer, theme)?;
 +            self.paused.render(renderer, theme)?;
 +        }
++
 +        self.controls_section.render(renderer, theme)?;
 +        if self.controls_section.expanded {
 +            self.prev_button.render(renderer, theme)?;
 +            self.pause_button.render(renderer, theme)?;
 +            self.next_button.render(renderer, theme)?;
 +        }
++
 +        // Render action buttons
 +        self.reset_button.render(renderer, theme)?;
 +        self.apply_button.render(renderer, theme)?;
 +        self.save_button.render(renderer, theme)?;
++
 +        // Dirty indicator
 +        if self.dirty {
 +            let indicator_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.75)
 +                .color(gartk_core::Color::from_u8(0xff, 0xb8, 0x6c, 0xff));
++
 +            renderer.text(
 +                "● Unsaved changes",
 +                (bounds.x + theme.padding as i32) as f64,
 +                (bounds.y + bounds.height as i32 - theme.padding as i32 - 28) as f64,
 +                &indicator_style,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::Key(ke) if ke.pressed => {
 +                // Scroll with Page Up/Down
 +                match &ke.key {
 +                    Key::PageUp => {
 +                        self.scroll_offset = (self.scroll_offset - 100).max(0);
 +                        return PanelAction::Redraw;
 +                    }
 +                    Key::PageDown => {
 +                        self.scroll_offset += 100;
 +                        return PanelAction::Redraw;
 +                    }
 +                    _ => {}
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.current_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.playlist_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.slideshow_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.controls_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Check widgets - with instant apply support
 +                if let WidgetEvent::Changed = self.interval.on_click(x, y) {
 +                    self.check_dirty();
 +                    // Interval change currently needs config save, no instant apply
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.paused.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("paused");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
++
 +                // Control buttons
 +                if let WidgetEvent::Clicked = self.prev_button.on_click(x, y) {
 +                    let _ = self.adapter.prev(None);
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.next_button.on_click(x, y) {
 +                    let _ = self.adapter.next(None);
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.pause_button.on_click(x, y) {
 +                    let _ = self.adapter.toggle();
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.apply_button.on_click(x, y) {
 +                    return PanelAction::Apply;
 +                }
 +                if let WidgetEvent::Clicked = self.reset_button.on_click(x, y) {
 +                    return PanelAction::Reset;
 +                }
 +                if let WidgetEvent::Clicked = self.save_button.on_click(x, y) {
 +                    return PanelAction::Save;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.current_section.on_mouse_move(x, y);
 +        changed |= self.playlist_section.on_mouse_move(x, y);
 +        changed |= self.slideshow_section.on_mouse_move(x, y);
 +        changed |= self.controls_section.on_mouse_move(x, y);
++
 +        changed |= self.interval.on_mouse_move(x, y);
 +        changed |= self.paused.on_mouse_move(x, y);
++
 +        changed |= self.prev_button.on_mouse_move(x, y);
 +        changed |= self.pause_button.on_mouse_move(x, y);
 +        changed |= self.next_button.on_mouse_move(x, y);
++
 +        changed |= self.apply_button.on_mouse_move(x, y);
 +        changed |= self.reset_button.on_mouse_move(x, y);
 +        changed |= self.save_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {
 +        self.interval.value = self.original_values.interval;
 +        self.paused.value = self.original_values.paused;
 +        self.dirty = false;
 +    }
++
 +    fn apply(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        // Toggle pause state if changed
 +        if self.paused.value != self.original_values.paused {
 +            self.adapter.toggle()?;
 +        }
++
 +        // Note: interval changes require config file edit
 +        // For now we track it but it won't take effect until config save
++
 +        // Update original values
 +        self.original_values = GarbgValues {
 +            interval: self.interval.value,
 +            paused: self.paused.value,
 +        };
++
 +        self.dirty = false;
 +        self.refresh_status();
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
++
 +    fn has_config_file(&self) -> bool {
 +        true
 +    }
++
 +    fn save_to_config(&mut self) -> Result<()> {
 +        // Load existing config or create new
 +        let mut config = GarbgConfig::load().unwrap_or_default();
++
 +        // Update slideshow settings
 +        config.slideshow = Some(GarbgSlideshow {
 +            enabled: !self.paused.value,
 +            interval_secs: Some(self.interval.value as u64),
 +            shuffle: config.slideshow.as_ref().and_then(|s| s.shuffle),
 +        });
++
 +        // Save config
 +        config.save()?;
++
 +        // Trigger reload
 +        crate::config::reload_component("garbg")?;
++
 +        Ok(())
 +    }
++
 +    fn set_instant_apply(&mut self, enabled: bool) {
 +        self.instant_apply = enabled;
 +    }
++
 +    fn instant_apply_enabled(&self) -> bool {
 +        self.instant_apply
 +    }
++
 +    fn apply_instant(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        // Apply only the pending change
 +        if let Some(field) = self.pending_change.take() {
 +            match field {
 +                "paused" => {
 +                    // Toggle pause state
 +                    if self.paused.value != self.original_values.paused {
 +                        self.adapter.toggle()?;
 +                        self.original_values.paused = self.paused.value;
 +                        self.pause_button.label = if self.paused.value {
 +                            "Resume".to_string()
 +                        } else {
 +                            "Pause".to_string()
 +                        };
 +                    }
 +                }
 +                _ => {}
 +            }
 +            self.check_dirty();
 +            self.refresh_status();
 +        }
++
 +        Ok(())
 +    }
 +}

gargears/src/panels/garclip.rsadded

 +//! Configuration panel for garclip (clipboard manager)
++
 +use crate::ipc::adapters::GarclipAdapter;
 +use crate::ui::widgets::{Button, Label, Section, Toggle, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garclip configuration panel
 +pub struct GarclipPanel {
 +    adapter: GarclipAdapter,
++
 +    // Sections
 +    status_section: Section,
 +    actions_section: Section,
++
 +    // Status display
 +    history_count_label: Label,
 +    pinned_count_label: Label,
 +    owns_clipboard_label: Label,
 +    watching_primary_label: Label,
++
 +    // Action buttons
 +    clear_button: Button,
 +    clear_history_button: Button,
 +    keep_pinned_toggle: Toggle,
 +    refresh_button: Button,
++
 +    // State
 +    scroll_offset: i32,
 +}
++
 +impl GarclipPanel {
 +    pub fn new(mut adapter: GarclipAdapter) -> Self {
 +        let (history, pinned, owns, watching) = if adapter.is_connected() {
 +            if let Ok(status) = adapter.status() {
 +                (
 +                    format!("{} item(s)", status.history_count),
 +                    format!("{} pinned", status.pinned_count),
 +                    if status.owns_clipboard { "Yes" } else { "No" },
 +                    if status.watching_primary { "Yes" } else { "No" },
 +                )
 +            } else {
 +                ("Unknown".into(), "Unknown".into(), "Unknown", "Unknown")
 +            }
 +        } else {
 +            ("N/A".into(), "N/A".into(), "N/A", "N/A")
 +        };
++
 +        Self {
 +            adapter,
 +            status_section: Section::new("Status"),
 +            actions_section: Section::new("Actions"),
 +            history_count_label: Label::new("History Count", &history),
 +            pinned_count_label: Label::new("Pinned Count", &pinned),
 +            owns_clipboard_label: Label::new("Owns Clipboard", owns),
 +            watching_primary_label: Label::new("Watching PRIMARY", watching),
 +            clear_button: Button::new("Clear Clipboard"),
 +            clear_history_button: Button::new("Clear History").primary(),
 +            keep_pinned_toggle: Toggle::new("Keep Pinned Items", true),
 +            refresh_button: Button::new("Refresh"),
 +            scroll_offset: 0,
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        if !self.adapter.is_connected() {
 +            let _ = self.adapter.connect();
 +        }
++
 +        if let Ok(status) = self.adapter.status() {
 +            self.history_count_label.text = format!("{} item(s)", status.history_count);
 +            self.pinned_count_label.text = format!("{} pinned", status.pinned_count);
 +            self.owns_clipboard_label.text = if status.owns_clipboard { "Yes" } else { "No" }.into();
 +            self.watching_primary_label.text = if status.watching_primary { "Yes" } else { "No" }.into();
 +        }
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 32;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Status section
 +        self.status_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.status_section.expanded {
 +            self.history_count_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.pinned_count_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.owns_clipboard_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.watching_primary_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Actions section
 +        self.actions_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.actions_section.expanded {
 +            self.clear_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y,
 +                120,
 +                32,
 +            );
++
 +            self.refresh_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + 128,
 +                y,
 +                80,
 +                32,
 +            );
++
 +            y += 40;
++
 +            self.keep_pinned_toggle.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height + 8;
++
 +            self.clear_history_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y,
 +                120,
 +                32,
 +            );
 +        }
 +    }
 +}
++
 +impl Panel for GarclipPanel {
 +    fn name(&self) -> &str {
 +        "garclip"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Clipboard manager"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        false
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections
 +        self.status_section.render(renderer, theme)?;
 +        if self.status_section.expanded {
 +            self.history_count_label.render(renderer, theme)?;
 +            self.pinned_count_label.render(renderer, theme)?;
 +            self.owns_clipboard_label.render(renderer, theme)?;
 +            self.watching_primary_label.render(renderer, theme)?;
 +        }
++
 +        self.actions_section.render(renderer, theme)?;
 +        if self.actions_section.expanded {
 +            self.clear_button.render(renderer, theme)?;
 +            self.refresh_button.render(renderer, theme)?;
 +            self.keep_pinned_toggle.render(renderer, theme)?;
 +            self.clear_history_button.render(renderer, theme)?;
 +        }
++
 +        // Connection status
 +        let status_color = if self.adapter.is_connected() {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff)
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff)
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(status_color);
++
 +        let status_text = if self.adapter.is_connected() {
 +            "Connected"
 +        } else {
 +            "Not running"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +            &status_style,
 +        )?;
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.status_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.actions_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Toggle
 +                if let WidgetEvent::Changed = self.keep_pinned_toggle.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.clear_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.clear();
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.clear_history_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.clear_history(self.keep_pinned_toggle.value);
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.refresh_button.on_click(x, y) {
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.status_section.on_mouse_move(x, y);
 +        changed |= self.actions_section.on_mouse_move(x, y);
 +        changed |= self.keep_pinned_toggle.on_mouse_move(x, y);
 +        changed |= self.clear_button.on_mouse_move(x, y);
 +        changed |= self.clear_history_button.on_mouse_move(x, y);
 +        changed |= self.refresh_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {}
++
 +    fn apply(&mut self) -> Result<()> {
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
 +}

gargears/src/panels/garfield.rsadded

 +//! Configuration panel for garfield (file explorer)
++
 +use crate::ipc::adapters::GarfieldAdapter;
 +use crate::ui::widgets::{Button, Label, Section, TextInput, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Key, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garfield configuration panel
 +pub struct GarfieldPanel {
 +    adapter: GarfieldAdapter,
++
 +    // Sections
 +    status_section: Section,
 +    navigation_section: Section,
++
 +    // Status display
 +    running_label: Label,
 +    current_dir_label: Label,
++
 +    // Navigation
 +    open_path: TextInput,
++
 +    // Action buttons
 +    open_button: Button,
 +    refresh_button: Button,
++
 +    // State
 +    scroll_offset: i32,
 +}
++
 +impl GarfieldPanel {
 +    pub fn new(mut adapter: GarfieldAdapter) -> Self {
 +        let (running, current_dir): (String, String) = if adapter.is_connected() {
 +            if let Ok(status) = adapter.status() {
 +                let running = if status.running { "Running" } else { "Not running" };
 +                let dir = status.current_dir.unwrap_or_else(|| "Unknown".to_string());
 +                (running.to_string(), dir)
 +            } else {
 +                ("Unknown".to_string(), "Unknown".to_string())
 +            }
 +        } else {
 +            ("Not connected".to_string(), "N/A".to_string())
 +        };
++
 +        Self {
 +            adapter,
 +            status_section: Section::new("Status"),
 +            navigation_section: Section::new("Navigation"),
 +            running_label: Label::new("Status", &running),
 +            current_dir_label: Label::new("Current Directory", &current_dir),
 +            open_path: TextInput::new("Path", "").with_placeholder("/home/user"),
 +            open_button: Button::new("Open").primary(),
 +            refresh_button: Button::new("Refresh"),
 +            scroll_offset: 0,
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        if !self.adapter.is_connected() {
 +            let _ = self.adapter.connect();
 +        }
++
 +        if let Ok(status) = self.adapter.status() {
 +            let running = if status.running { "Running" } else { "Not running" };
 +            self.running_label.text = running.into();
 +            self.current_dir_label.text = status.current_dir.unwrap_or_else(|| "Unknown".into());
 +        }
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 36;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Status section
 +        self.status_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.status_section.expanded {
 +            self.running_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.current_dir_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Navigation section
 +        self.navigation_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.navigation_section.expanded {
 +            self.open_path.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height + 8;
++
 +            self.open_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y,
 +                80,
 +                32,
 +            );
++
 +            self.refresh_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + 88,
 +                y,
 +                80,
 +                32,
 +            );
 +        }
 +    }
 +}
++
 +impl Panel for GarfieldPanel {
 +    fn name(&self) -> &str {
 +        "garfield"
 +    }
++
 +    fn description(&self) -> &str {
 +        "File explorer"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        false
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections
 +        self.status_section.render(renderer, theme)?;
 +        if self.status_section.expanded {
 +            self.running_label.render(renderer, theme)?;
 +            self.current_dir_label.render(renderer, theme)?;
 +        }
++
 +        self.navigation_section.render(renderer, theme)?;
 +        if self.navigation_section.expanded {
 +            self.open_path.render(renderer, theme)?;
 +            self.open_button.render(renderer, theme)?;
 +            self.refresh_button.render(renderer, theme)?;
 +        }
++
 +        // Connection status
 +        let status_color = if self.adapter.is_connected() {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff)
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff)
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(status_color);
++
 +        let status_text = if self.adapter.is_connected() {
 +            "Connected"
 +        } else {
 +            "Not running"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +            &status_style,
 +        )?;
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::Key(ke) if ke.pressed => {
 +                // Handle text input
 +                if let WidgetEvent::Changed = self.open_path.on_key(&ke.key) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Enter to open path
 +                if matches!(ke.key, Key::Return) && !self.open_path.value.is_empty() {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.open(&self.open_path.value);
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.status_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.navigation_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.open_button.on_click(x, y) {
 +                    if self.adapter.is_connected() && !self.open_path.value.is_empty() {
 +                        let _ = self.adapter.open(&self.open_path.value);
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.refresh_button.on_click(x, y) {
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Text input - check if focus changed
 +                if let WidgetEvent::Changed = self.open_path.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.status_section.on_mouse_move(x, y);
 +        changed |= self.navigation_section.on_mouse_move(x, y);
 +        changed |= self.open_path.on_mouse_move(x, y);
 +        changed |= self.open_button.on_mouse_move(x, y);
 +        changed |= self.refresh_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {}
++
 +    fn apply(&mut self) -> Result<()> {
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
 +}

gargears/src/panels/garlaunch.rsadded

 +//! Configuration panel for garlaunch (application launcher)
++
 +use crate::ipc::adapters::GarlaunchAdapter;
 +use crate::ui::widgets::{Button, Label, Section, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garlaunch configuration panel
 +pub struct GarlaunchPanel {
 +    adapter: GarlaunchAdapter,
++
 +    // Sections
 +    status_section: Section,
 +    actions_section: Section,
++
 +    // Status display
 +    daemon_running_label: Label,
++
 +    // Action buttons
 +    show_button: Button,
 +    toggle_button: Button,
 +    refresh_button: Button,
++
 +    // State
 +    scroll_offset: i32,
 +}
++
 +impl GarlaunchPanel {
 +    pub fn new(mut adapter: GarlaunchAdapter) -> Self {
 +        let daemon_running = if adapter.is_connected() {
 +            if let Ok(status) = adapter.status() {
 +                if status.daemon_running { "Running" } else { "Not running" }
 +            } else {
 +                "Unknown"
 +            }
 +        } else {
 +            "Not connected"
 +        };
++
 +        Self {
 +            adapter,
 +            status_section: Section::new("Status"),
 +            actions_section: Section::new("Actions"),
 +            daemon_running_label: Label::new("Daemon Status", daemon_running),
 +            show_button: Button::new("Show Launcher").primary(),
 +            toggle_button: Button::new("Toggle"),
 +            refresh_button: Button::new("Refresh"),
 +            scroll_offset: 0,
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        if !self.adapter.is_connected() {
 +            let _ = self.adapter.connect();
 +        }
++
 +        if let Ok(status) = self.adapter.status() {
 +            self.daemon_running_label.text =
 +                if status.daemon_running { "Running" } else { "Not running" }.into();
 +        }
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 32;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Status section
 +        self.status_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.status_section.expanded {
 +            self.daemon_running_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Actions section
 +        self.actions_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.actions_section.expanded {
 +            self.show_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y,
 +                120,
 +                32,
 +            );
++
 +            self.toggle_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + 128,
 +                y,
 +                80,
 +                32,
 +            );
++
 +            self.refresh_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + 128 + 88,
 +                y,
 +                80,
 +                32,
 +            );
 +        }
 +    }
 +}
++
 +impl Panel for GarlaunchPanel {
 +    fn name(&self) -> &str {
 +        "garlaunch"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Application launcher"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        false
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections
 +        self.status_section.render(renderer, theme)?;
 +        if self.status_section.expanded {
 +            self.daemon_running_label.render(renderer, theme)?;
 +        }
++
 +        self.actions_section.render(renderer, theme)?;
 +        if self.actions_section.expanded {
 +            self.show_button.render(renderer, theme)?;
 +            self.toggle_button.render(renderer, theme)?;
 +            self.refresh_button.render(renderer, theme)?;
 +        }
++
 +        // Hint text
 +        let hint_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(theme.item_description);
++
 +        renderer.text(
 +            "Use keybind or CLI to show launcher",
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 40) as f64,
 +            &hint_style,
 +        )?;
++
 +        // Connection status
 +        let status_color = if self.adapter.is_connected() {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff)
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff)
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(status_color);
++
 +        let status_text = if self.adapter.is_connected() {
 +            "Connected"
 +        } else {
 +            "Not running"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +            &status_style,
 +        )?;
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.status_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.actions_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.show_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.show(None);
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.toggle_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.toggle(None);
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.refresh_button.on_click(x, y) {
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.status_section.on_mouse_move(x, y);
 +        changed |= self.actions_section.on_mouse_move(x, y);
 +        changed |= self.show_button.on_mouse_move(x, y);
 +        changed |= self.toggle_button.on_mouse_move(x, y);
 +        changed |= self.refresh_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {}
++
 +    fn apply(&mut self) -> Result<()> {
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
 +}

gargears/src/panels/garlock.rsadded

 +//! Configuration panel for garlock (screen locker)
++
 +use crate::config::GarlockConfig;
 +use crate::ipc::adapters::GarlockAdapter;
 +use crate::ui::widgets::{Button, Label, NumberInput, Section, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garlock configuration panel
 +pub struct GarlockPanel {
 +    adapter: GarlockAdapter,
++
 +    // Sections
 +    status_section: Section,
 +    settings_section: Section,
 +    actions_section: Section,
++
 +    // Status display
 +    locked_label: Label,
++
 +    // Settings
 +    idle_timeout: NumberInput,
++
 +    // Action buttons
 +    lock_button: Button,
 +    refresh_button: Button,
 +    save_button: Button,
++
 +    // State
 +    original_timeout: i32,
 +    dirty: bool,
 +    scroll_offset: i32,
 +}
++
 +impl GarlockPanel {
 +    pub fn new(mut adapter: GarlockAdapter) -> Self {
 +        let (locked, timeout): (String, i32) = if adapter.is_connected() {
 +            if let Ok(status) = adapter.status() {
 +                let locked_text = if status.locked { "Locked" } else { "Unlocked" };
 +                let timeout = status.idle_timeout_secs.unwrap_or(300) as i32;
 +                (locked_text.to_string(), timeout)
 +            } else {
 +                ("Unknown".to_string(), 300)
 +            }
 +        } else {
 +            ("Not connected".to_string(), 300)
 +        };
++
 +        Self {
 +            adapter,
 +            status_section: Section::new("Status"),
 +            settings_section: Section::new("Settings"),
 +            actions_section: Section::new("Actions"),
 +            locked_label: Label::new("Lock Status", &locked),
 +            idle_timeout: NumberInput::new("Idle Timeout (seconds)", timeout)
 +                .with_range(30, 3600)
 +                .with_step(30),
 +            lock_button: Button::new("Lock Now").primary(),
 +            refresh_button: Button::new("Refresh"),
 +            save_button: Button::new("Save"),
 +            original_timeout: timeout,
 +            dirty: false,
 +            scroll_offset: 0,
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        if !self.adapter.is_connected() {
 +            let _ = self.adapter.connect();
 +        }
++
 +        if let Ok(status) = self.adapter.status() {
 +            let locked_text = if status.locked { "Locked" } else { "Unlocked" };
 +            self.locked_label.text = locked_text.into();
++
 +            if let Some(timeout) = status.idle_timeout_secs {
 +                self.idle_timeout.value = timeout as i32;
 +                self.original_timeout = timeout as i32;
 +            }
 +            self.dirty = false;
 +        }
 +    }
++
 +    fn check_dirty(&mut self) {
 +        self.dirty = self.idle_timeout.value != self.original_timeout;
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 36;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Status section
 +        self.status_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.status_section.expanded {
 +            self.locked_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Settings section
 +        self.settings_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.settings_section.expanded {
 +            self.idle_timeout.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Actions section
 +        self.actions_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.actions_section.expanded {
 +            self.lock_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y,
 +                100,
 +                32,
 +            );
++
 +            self.refresh_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + 108,
 +                y,
 +                100,
 +                32,
 +            );
++
 +            self.save_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + 216,
 +                y,
 +                80,
 +                32,
 +            );
 +        }
 +    }
 +}
++
 +impl Panel for GarlockPanel {
 +    fn name(&self) -> &str {
 +        "garlock"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Screen locker"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        self.dirty
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections
 +        self.status_section.render(renderer, theme)?;
 +        if self.status_section.expanded {
 +            self.locked_label.render(renderer, theme)?;
 +        }
++
 +        self.settings_section.render(renderer, theme)?;
 +        if self.settings_section.expanded {
 +            self.idle_timeout.render(renderer, theme)?;
 +        }
++
 +        self.actions_section.render(renderer, theme)?;
 +        if self.actions_section.expanded {
 +            self.lock_button.render(renderer, theme)?;
 +            self.refresh_button.render(renderer, theme)?;
 +            self.save_button.render(renderer, theme)?;
 +        }
++
 +        // Connection status
 +        let status_color = if self.adapter.is_connected() {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff)
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff)
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(status_color);
++
 +        let status_text = if self.adapter.is_connected() {
 +            "Connected"
 +        } else {
 +            "Not running"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +            &status_style,
 +        )?;
++
 +        // Dirty indicator
 +        if self.dirty {
 +            let indicator_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.75)
 +                .color(gartk_core::Color::from_u8(0xff, 0xb8, 0x6c, 0xff));
++
 +            renderer.text(
 +                "Unsaved changes",
 +                (bounds.x + bounds.width as i32 - theme.padding as i32 - 100) as f64,
 +                (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +                &indicator_style,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.status_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.settings_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.actions_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Settings
 +                if let WidgetEvent::Changed = self.idle_timeout.on_click(x, y) {
 +                    self.check_dirty();
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.lock_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.lock();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.refresh_button.on_click(x, y) {
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.save_button.on_click(x, y) {
 +                    return PanelAction::Save;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.status_section.on_mouse_move(x, y);
 +        changed |= self.settings_section.on_mouse_move(x, y);
 +        changed |= self.actions_section.on_mouse_move(x, y);
 +        changed |= self.idle_timeout.on_mouse_move(x, y);
 +        changed |= self.lock_button.on_mouse_move(x, y);
 +        changed |= self.refresh_button.on_mouse_move(x, y);
 +        changed |= self.save_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {
 +        self.idle_timeout.value = self.original_timeout;
 +        self.dirty = false;
 +    }
++
 +    fn apply(&mut self) -> Result<()> {
 +        // Note: Timeout changes would need config file edit
 +        // For now, just update original values
 +        self.original_timeout = self.idle_timeout.value;
 +        self.dirty = false;
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
++
 +    fn has_config_file(&self) -> bool {
 +        true
 +    }
++
 +    fn save_to_config(&mut self) -> Result<()> {
 +        let mut config = GarlockConfig::load().unwrap_or_default();
++
 +        // Update idle timeout
 +        config.idle_timeout_secs = Some(self.idle_timeout.value as u64);
++
 +        // Save config
 +        config.save()?;
++
 +        // Trigger reload (garlock reads on next lock)
 +        crate::config::reload_component("garlock")?;
++
 +        Ok(())
 +    }
 +}

gargears/src/panels/garnotify.rsadded

 +//! Configuration panel for garnotify (notification daemon)
++
 +use crate::ipc::adapters::GarnotifyAdapter;
 +use crate::ui::widgets::{Button, Label, Section, Toggle, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garnotify configuration panel
 +pub struct GarnotifyPanel {
 +    adapter: GarnotifyAdapter,
++
 +    // Sections
 +    status_section: Section,
 +    actions_section: Section,
++
 +    // Status display
 +    paused_toggle: Toggle,
 +    pending_count_label: Label,
 +    history_count_label: Label,
++
 +    // Action buttons
 +    clear_button: Button,
 +    clear_all_button: Button,
 +    refresh_button: Button,
++
 +    // State
 +    original_paused: bool,
 +    dirty: bool,
 +    scroll_offset: i32,
 +    instant_apply: bool,
 +    pending_change: Option<&'static str>,
 +}
++
 +impl GarnotifyPanel {
 +    pub fn new(mut adapter: GarnotifyAdapter) -> Self {
 +        let (paused, pending, history) = if adapter.is_connected() {
 +            if let Ok(status) = adapter.status() {
 +                (
 +                    status.paused,
 +                    format!("{} pending", status.pending_count),
 +                    format!("{} in history", status.history_count),
 +                )
 +            } else {
 +                (false, "Unknown".into(), "Unknown".into())
 +            }
 +        } else {
 +            (false, "N/A".into(), "N/A".into())
 +        };
++
 +        Self {
 +            adapter,
 +            status_section: Section::new("Status"),
 +            actions_section: Section::new("Actions"),
 +            paused_toggle: Toggle::new("Paused", paused),
 +            pending_count_label: Label::new("Pending", &pending),
 +            history_count_label: Label::new("History", &history),
 +            clear_button: Button::new("Clear Current"),
 +            clear_all_button: Button::new("Clear All").primary(),
 +            refresh_button: Button::new("Refresh"),
 +            original_paused: paused,
 +            dirty: false,
 +            scroll_offset: 0,
 +            instant_apply: true,
 +            pending_change: None,
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        if !self.adapter.is_connected() {
 +            let _ = self.adapter.connect();
 +        }
++
 +        if let Ok(status) = self.adapter.status() {
 +            self.paused_toggle.value = status.paused;
 +            self.original_paused = status.paused;
 +            self.pending_count_label.text = format!("{} pending", status.pending_count);
 +            self.history_count_label.text = format!("{} in history", status.history_count);
 +            self.dirty = false;
 +        }
 +    }
++
 +    fn check_dirty(&mut self) {
 +        self.dirty = self.paused_toggle.value != self.original_paused;
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 32;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Status section
 +        self.status_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.status_section.expanded {
 +            self.paused_toggle.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.pending_count_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.history_count_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Actions section
 +        self.actions_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.actions_section.expanded {
 +            self.clear_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y,
 +                110,
 +                32,
 +            );
++
 +            self.clear_all_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + 118,
 +                y,
 +                90,
 +                32,
 +            );
++
 +            self.refresh_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + 118 + 98,
 +                y,
 +                80,
 +                32,
 +            );
 +        }
 +    }
 +}
++
 +impl Panel for GarnotifyPanel {
 +    fn name(&self) -> &str {
 +        "garnotify"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Notification daemon"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        self.dirty
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections
 +        self.status_section.render(renderer, theme)?;
 +        if self.status_section.expanded {
 +            self.paused_toggle.render(renderer, theme)?;
 +            self.pending_count_label.render(renderer, theme)?;
 +            self.history_count_label.render(renderer, theme)?;
 +        }
++
 +        self.actions_section.render(renderer, theme)?;
 +        if self.actions_section.expanded {
 +            self.clear_button.render(renderer, theme)?;
 +            self.clear_all_button.render(renderer, theme)?;
 +            self.refresh_button.render(renderer, theme)?;
 +        }
++
 +        // Connection status
 +        let status_color = if self.adapter.is_connected() {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff)
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff)
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(status_color);
++
 +        let status_text = if self.adapter.is_connected() {
 +            "Connected"
 +        } else {
 +            "Not running"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +            &status_style,
 +        )?;
++
 +        // Dirty indicator
 +        if self.dirty {
 +            let indicator_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.75)
 +                .color(gartk_core::Color::from_u8(0xff, 0xb8, 0x6c, 0xff));
++
 +            renderer.text(
 +                "Unsaved changes",
 +                (bounds.x + bounds.width as i32 - theme.padding as i32 - 100) as f64,
 +                (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +                &indicator_style,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.status_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.actions_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Toggle
 +                if let WidgetEvent::Changed = self.paused_toggle.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("paused");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.clear_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.clear();
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.clear_all_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.clear_all();
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.refresh_button.on_click(x, y) {
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.status_section.on_mouse_move(x, y);
 +        changed |= self.actions_section.on_mouse_move(x, y);
 +        changed |= self.paused_toggle.on_mouse_move(x, y);
 +        changed |= self.clear_button.on_mouse_move(x, y);
 +        changed |= self.clear_all_button.on_mouse_move(x, y);
 +        changed |= self.refresh_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {
 +        self.paused_toggle.value = self.original_paused;
 +        self.dirty = false;
 +    }
++
 +    fn apply(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        if self.paused_toggle.value != self.original_paused {
 +            if self.paused_toggle.value {
 +                self.adapter.pause()?;
 +            } else {
 +                self.adapter.resume()?;
 +            }
 +            self.original_paused = self.paused_toggle.value;
 +        }
++
 +        self.dirty = false;
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
++
 +    fn set_instant_apply(&mut self, enabled: bool) {
 +        self.instant_apply = enabled;
 +    }
++
 +    fn instant_apply_enabled(&self) -> bool {
 +        self.instant_apply
 +    }
++
 +    fn apply_instant(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        if let Some(field) = self.pending_change.take() {
 +            match field {
 +                "paused" => {
 +                    if self.paused_toggle.value != self.original_paused {
 +                        if self.paused_toggle.value {
 +                            self.adapter.pause()?;
 +                        } else {
 +                            self.adapter.resume()?;
 +                        }
 +                        self.original_paused = self.paused_toggle.value;
 +                    }
 +                }
 +                _ => {}
 +            }
 +            self.check_dirty();
 +        }
++
 +        Ok(())
 +    }
 +}

gargears/src/panels/garshot.rsadded

 +//! Configuration panel for garshot (screenshot tool)
++
 +use crate::ipc::adapters::GarshotAdapter;
 +use crate::ui::widgets::{Button, Label, Section, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garshot configuration panel
 +pub struct GarshotPanel {
 +    adapter: GarshotAdapter,
++
 +    // Sections
 +    status_section: Section,
 +    info_section: Section,
++
 +    // Status display
 +    ready_label: Label,
 +    monitors_label: Label,
++
 +    // Action buttons
 +    refresh_button: Button,
++
 +    // State
 +    scroll_offset: i32,
 +}
++
 +impl GarshotPanel {
 +    pub fn new(mut adapter: GarshotAdapter) -> Self {
 +        let ready = if adapter.is_connected() {
 +            if let Ok(status) = adapter.status() {
 +                if status.ready { "Ready" } else { "Not ready" }
 +            } else {
 +                "Unknown"
 +            }
 +        } else {
 +            "Not connected"
 +        };
++
 +        let monitors = if adapter.is_connected() {
 +            if let Ok(Some(monitors)) = adapter.list_monitors() {
 +                if let Some(arr) = monitors.as_array() {
 +                    format!("{} monitor(s) detected", arr.len())
 +                } else {
 +                    "Monitors: Unknown format".into()
 +                }
 +            } else {
 +                "No monitor info".into()
 +            }
 +        } else {
 +            "Not connected".into()
 +        };
++
 +        Self {
 +            adapter,
 +            status_section: Section::new("Status"),
 +            info_section: Section::new("Information"),
 +            ready_label: Label::new("Status", ready),
 +            monitors_label: Label::new("Monitors", &monitors),
 +            refresh_button: Button::new("Refresh").primary(),
 +            scroll_offset: 0,
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        if !self.adapter.is_connected() {
 +            let _ = self.adapter.connect();
 +        }
++
 +        let ready = if self.adapter.is_connected() {
 +            if let Ok(status) = self.adapter.status() {
 +                if status.ready { "Ready" } else { "Not ready" }
 +            } else {
 +                "Error"
 +            }
 +        } else {
 +            "Not connected"
 +        };
++
 +        let monitors = if self.adapter.is_connected() {
 +            if let Ok(Some(monitors)) = self.adapter.list_monitors() {
 +                if let Some(arr) = monitors.as_array() {
 +                    format!("{} monitor(s) detected", arr.len())
 +                } else {
 +                    "Monitors: Unknown format".into()
 +                }
 +            } else {
 +                "No monitor info".into()
 +            }
 +        } else {
 +            "Not connected".into()
 +        };
++
 +        self.ready_label.text = ready.into();
 +        self.monitors_label.text = monitors;
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 32;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Status section
 +        self.status_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.status_section.expanded {
 +            self.ready_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Info section
 +        self.info_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.info_section.expanded {
 +            self.monitors_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.refresh_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y + 8,
 +                100,
 +                32,
 +            );
 +        }
 +    }
 +}
++
 +impl Panel for GarshotPanel {
 +    fn name(&self) -> &str {
 +        "garshot"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Screenshot tool"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        false
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections
 +        self.status_section.render(renderer, theme)?;
 +        if self.status_section.expanded {
 +            self.ready_label.render(renderer, theme)?;
 +        }
++
 +        self.info_section.render(renderer, theme)?;
 +        if self.info_section.expanded {
 +            self.monitors_label.render(renderer, theme)?;
 +            self.refresh_button.render(renderer, theme)?;
 +        }
++
 +        // Hint text
 +        let hint_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(theme.item_description);
++
 +        renderer.text(
 +            "Use keybinds or CLI to capture screenshots",
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 40) as f64,
 +            &hint_style,
 +        )?;
++
 +        // Connection status
 +        let status_color = if self.adapter.is_connected() {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff)
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff)
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(status_color);
++
 +        let status_text = if self.adapter.is_connected() {
 +            "Connected"
 +        } else {
 +            "Not running"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +            &status_style,
 +        )?;
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.status_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.info_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Refresh button
 +                if let WidgetEvent::Clicked = self.refresh_button.on_click(x, y) {
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.status_section.on_mouse_move(x, y);
 +        changed |= self.info_section.on_mouse_move(x, y);
 +        changed |= self.refresh_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {}
++
 +    fn apply(&mut self) -> Result<()> {
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
 +}

gargears/src/panels/garterm.rsadded

 +//! Configuration panel for garterm (terminal emulator)
++
 +use crate::ipc::adapters::GartermAdapter;
 +use crate::ui::widgets::{Button, Label, Section, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Garterm configuration panel
 +pub struct GartermPanel {
 +    adapter: GartermAdapter,
++
 +    // Sections
 +    status_section: Section,
 +    actions_section: Section,
++
 +    // Status display
 +    pid_label: Label,
 +    title_label: Label,
 +    tabs_label: Label,
 +    instances_label: Label,
++
 +    // Action buttons
 +    new_window_button: Button,
 +    new_tab_button: Button,
 +    refresh_button: Button,
++
 +    // State
 +    scroll_offset: i32,
 +}
++
 +impl GartermPanel {
 +    pub fn new(mut adapter: GartermAdapter) -> Self {
 +        let (pid, title, tabs) = if adapter.is_connected() {
 +            if let Ok(status) = adapter.status() {
 +                (
 +                    status.pid.map(|p| format!("PID: {}", p)).unwrap_or_else(|| "PID: -".into()),
 +                    status.title.unwrap_or_else(|| "No title".into()),
 +                    status.tabs.map(|t| format!("{} tab(s)", t)).unwrap_or_else(|| "- tabs".into()),
 +                )
 +            } else {
 +                ("PID: -".into(), "Not connected".into(), "- tabs".into())
 +            }
 +        } else {
 +            ("PID: -".into(), "Not running".into(), "- tabs".into())
 +        };
++
 +        let instances = GartermAdapter::list_instances();
 +        let instances_text = if instances.is_empty() {
 +            "No instances running".into()
 +        } else {
 +            format!("{} instance(s): {}", instances.len(),
 +                instances.iter().map(|p| p.to_string()).collect::<Vec<_>>().join(", "))
 +        };
++
 +        Self {
 +            adapter,
 +            status_section: Section::new("Status"),
 +            actions_section: Section::new("Actions"),
 +            pid_label: Label::new("Process", &pid),
 +            title_label: Label::new("Title", &title),
 +            tabs_label: Label::new("Tabs", &tabs),
 +            instances_label: Label::new("Instances", &instances_text),
 +            new_window_button: Button::new("New Window").primary(),
 +            new_tab_button: Button::new("New Tab"),
 +            refresh_button: Button::new("Refresh"),
 +            scroll_offset: 0,
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        // Reconnect to potentially new focused instance
 +        let _ = self.adapter.connect();
++
 +        let (pid, title, tabs) = if self.adapter.is_connected() {
 +            if let Ok(status) = self.adapter.status() {
 +                (
 +                    status.pid.map(|p| format!("PID: {}", p)).unwrap_or_else(|| "PID: -".into()),
 +                    status.title.unwrap_or_else(|| "No title".into()),
 +                    status.tabs.map(|t| format!("{} tab(s)", t)).unwrap_or_else(|| "- tabs".into()),
 +                )
 +            } else {
 +                ("PID: -".into(), "Error getting status".into(), "- tabs".into())
 +            }
 +        } else {
 +            ("PID: -".into(), "Not running".into(), "- tabs".into())
 +        };
++
 +        let instances = GartermAdapter::list_instances();
 +        let instances_text = if instances.is_empty() {
 +            "No instances running".into()
 +        } else {
 +            format!("{} instance(s): {}", instances.len(),
 +                instances.iter().map(|p| p.to_string()).collect::<Vec<_>>().join(", "))
 +        };
++
 +        self.pid_label.text = pid;
 +        self.title_label.text = title;
 +        self.tabs_label.text = tabs;
 +        self.instances_label.text = instances_text;
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 32;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Status section
 +        self.status_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.status_section.expanded {
 +            self.pid_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.title_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.tabs_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.instances_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Actions section
 +        self.actions_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.actions_section.expanded {
 +            let button_width = 100;
 +            let button_spacing = 8;
++
 +            self.new_window_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y,
 +                button_width,
 +                32,
 +            );
++
 +            self.new_tab_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + button_width as i32 + button_spacing,
 +                y,
 +                button_width,
 +                32,
 +            );
++
 +            self.refresh_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + (button_width as i32 + button_spacing) * 2,
 +                y,
 +                button_width,
 +                32,
 +            );
 +        }
 +    }
 +}
++
 +impl Panel for GartermPanel {
 +    fn name(&self) -> &str {
 +        "garterm"
 +    }
++
 +    fn description(&self) -> &str {
 +        "Terminal emulator"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        false // Status display only, no editable settings yet
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections
 +        self.status_section.render(renderer, theme)?;
 +        if self.status_section.expanded {
 +            self.pid_label.render(renderer, theme)?;
 +            self.title_label.render(renderer, theme)?;
 +            self.tabs_label.render(renderer, theme)?;
 +            self.instances_label.render(renderer, theme)?;
 +        }
++
 +        self.actions_section.render(renderer, theme)?;
 +        if self.actions_section.expanded {
 +            self.new_window_button.render(renderer, theme)?;
 +            self.new_tab_button.render(renderer, theme)?;
 +            self.refresh_button.render(renderer, theme)?;
 +        }
++
 +        // Connection status at bottom
 +        let status_color = if self.adapter.is_connected() {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff)
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff)
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(status_color);
++
 +        let status_text = if self.adapter.is_connected() {
 +            "Connected to focused instance"
 +        } else {
 +            "No garterm instance focused"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +            &status_style,
 +        )?;
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.status_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.actions_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.new_window_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.new_window();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.new_tab_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.new_tab();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.refresh_button.on_click(x, y) {
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.status_section.on_mouse_move(x, y);
 +        changed |= self.actions_section.on_mouse_move(x, y);
 +        changed |= self.new_window_button.on_mouse_move(x, y);
 +        changed |= self.new_tab_button.on_mouse_move(x, y);
 +        changed |= self.refresh_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {
 +        // Nothing to reset
 +    }
++
 +    fn apply(&mut self) -> Result<()> {
 +        // No settings to apply
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
 +}

gargears/src/panels/gartray.rsadded

 +//! Configuration panel for gartray (system tray & quick settings)
++
 +use crate::ipc::adapters::GartrayAdapter;
 +use crate::ui::widgets::{Button, Label, Section, Toggle, WidgetEvent};
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Gartray configuration panel
 +pub struct GartrayPanel {
 +    adapter: GartrayAdapter,
++
 +    // Sections
 +    status_section: Section,
 +    actions_section: Section,
++
 +    // Status display
 +    visible_toggle: Toggle,
 +    tray_icons_label: Label,
++
 +    // Action buttons
 +    show_button: Button,
 +    hide_button: Button,
 +    toggle_button: Button,
 +    refresh_button: Button,
++
 +    // State
 +    original_visible: bool,
 +    dirty: bool,
 +    scroll_offset: i32,
 +    instant_apply: bool,
 +    pending_change: Option<&'static str>,
 +}
++
 +impl GartrayPanel {
 +    pub fn new(mut adapter: GartrayAdapter) -> Self {
 +        let (visible, tray_icons) = if adapter.is_connected() {
 +            if let Ok(status) = adapter.status() {
 +                (status.visible, format!("{} tray icon(s)", status.tray_icons))
 +            } else {
 +                (false, "Unknown".into())
 +            }
 +        } else {
 +            (false, "Not connected".into())
 +        };
++
 +        Self {
 +            adapter,
 +            status_section: Section::new("Status"),
 +            actions_section: Section::new("Actions"),
 +            visible_toggle: Toggle::new("Visible", visible),
 +            tray_icons_label: Label::new("Tray Icons", &tray_icons),
 +            show_button: Button::new("Show"),
 +            hide_button: Button::new("Hide"),
 +            toggle_button: Button::new("Toggle").primary(),
 +            refresh_button: Button::new("Refresh"),
 +            original_visible: visible,
 +            dirty: false,
 +            scroll_offset: 0,
 +            instant_apply: true,
 +            pending_change: None,
 +        }
 +    }
++
 +    fn refresh_status(&mut self) {
 +        if !self.adapter.is_connected() {
 +            let _ = self.adapter.connect();
 +        }
++
 +        if let Ok(status) = self.adapter.status() {
 +            self.visible_toggle.value = status.visible;
 +            self.original_visible = status.visible;
 +            self.tray_icons_label.text = format!("{} tray icon(s)", status.tray_icons);
 +            self.dirty = false;
 +        }
 +    }
++
 +    fn check_dirty(&mut self) {
 +        self.dirty = self.visible_toggle.value != self.original_visible;
 +    }
++
 +    fn layout_widgets(&mut self, bounds: Rect, theme: &Theme) {
 +        let padding = theme.padding as i32;
 +        let row_height = 32;
 +        let section_height = 32;
 +        let widget_width = bounds.width - (padding * 2) as u32;
++
 +        let mut y = bounds.y + padding - self.scroll_offset;
++
 +        // Status section
 +        self.status_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.status_section.expanded {
 +            self.visible_toggle.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
++
 +            self.tray_icons_label.bounds =
 +                Rect::new(bounds.x + padding + 16, y, widget_width - 16, row_height as u32);
 +            y += row_height;
 +        }
++
 +        y += padding / 2;
++
 +        // Actions section
 +        self.actions_section.bounds =
 +            Rect::new(bounds.x + padding, y, widget_width, section_height as u32);
 +        y += section_height;
++
 +        if self.actions_section.expanded {
 +            let button_width = 80;
 +            let button_spacing = 8;
++
 +            self.show_button.bounds = Rect::new(
 +                bounds.x + padding + 16,
 +                y,
 +                button_width,
 +                32,
 +            );
++
 +            self.hide_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + button_width as i32 + button_spacing,
 +                y,
 +                button_width,
 +                32,
 +            );
++
 +            self.toggle_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + (button_width as i32 + button_spacing) * 2,
 +                y,
 +                button_width,
 +                32,
 +            );
++
 +            self.refresh_button.bounds = Rect::new(
 +                bounds.x + padding + 16 + (button_width as i32 + button_spacing) * 3,
 +                y,
 +                button_width,
 +                32,
 +            );
 +        }
 +    }
 +}
++
 +impl Panel for GartrayPanel {
 +    fn name(&self) -> &str {
 +        "gartray"
 +    }
++
 +    fn description(&self) -> &str {
 +        "System tray & quick settings"
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        self.dirty
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        self.layout_widgets(bounds, theme);
++
 +        // Render sections
 +        self.status_section.render(renderer, theme)?;
 +        if self.status_section.expanded {
 +            self.visible_toggle.render(renderer, theme)?;
 +            self.tray_icons_label.render(renderer, theme)?;
 +        }
++
 +        self.actions_section.render(renderer, theme)?;
 +        if self.actions_section.expanded {
 +            self.show_button.render(renderer, theme)?;
 +            self.hide_button.render(renderer, theme)?;
 +            self.toggle_button.render(renderer, theme)?;
 +            self.refresh_button.render(renderer, theme)?;
 +        }
++
 +        // Connection status
 +        let status_color = if self.adapter.is_connected() {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff)
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff)
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.85)
 +            .color(status_color);
++
 +        let status_text = if self.adapter.is_connected() {
 +            "Connected"
 +        } else {
 +            "Not running"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +            &status_style,
 +        )?;
++
 +        // Dirty indicator
 +        if self.dirty {
 +            let indicator_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.75)
 +                .color(gartk_core::Color::from_u8(0xff, 0xb8, 0x6c, 0xff));
++
 +            renderer.text(
 +                "Unsaved changes",
 +                (bounds.x + bounds.width as i32 - theme.padding as i32 - 100) as f64,
 +                (bounds.y + bounds.height as i32 - theme.padding as i32 - 16) as f64,
 +                &indicator_style,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction {
 +        match event {
 +            InputEvent::MousePress(me) => {
 +                let x = me.position.x;
 +                let y = me.position.y;
++
 +                // Check sections
 +                if let WidgetEvent::Changed = self.status_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Changed = self.actions_section.on_click(x, y) {
 +                    return PanelAction::Redraw;
 +                }
++
 +                // Toggle
 +                if let WidgetEvent::Changed = self.visible_toggle.on_click(x, y) {
 +                    self.check_dirty();
 +                    self.pending_change = Some("visible");
 +                    return if self.instant_apply { PanelAction::InstantApply } else { PanelAction::Redraw };
 +                }
++
 +                // Action buttons
 +                if let WidgetEvent::Clicked = self.show_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.show();
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.hide_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.hide();
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.toggle_button.on_click(x, y) {
 +                    if self.adapter.is_connected() {
 +                        let _ = self.adapter.toggle();
 +                        self.refresh_status();
 +                    }
 +                    return PanelAction::Redraw;
 +                }
 +                if let WidgetEvent::Clicked = self.refresh_button.on_click(x, y) {
 +                    self.refresh_status();
 +                    return PanelAction::Redraw;
 +                }
++
 +                PanelAction::None
 +            }
 +            InputEvent::Scroll(se) => {
 +                self.scroll_offset = (self.scroll_offset - se.delta_y * 20).max(0);
 +                PanelAction::Redraw
 +            }
 +            _ => PanelAction::None,
 +        }
 +    }
++
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let mut changed = false;
 +        changed |= self.status_section.on_mouse_move(x, y);
 +        changed |= self.actions_section.on_mouse_move(x, y);
 +        changed |= self.visible_toggle.on_mouse_move(x, y);
 +        changed |= self.show_button.on_mouse_move(x, y);
 +        changed |= self.hide_button.on_mouse_move(x, y);
 +        changed |= self.toggle_button.on_mouse_move(x, y);
 +        changed |= self.refresh_button.on_mouse_move(x, y);
 +        changed
 +    }
++
 +    fn reset(&mut self) {
 +        self.visible_toggle.value = self.original_visible;
 +        self.dirty = false;
 +    }
++
 +    fn apply(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        if self.visible_toggle.value != self.original_visible {
 +            if self.visible_toggle.value {
 +                self.adapter.show()?;
 +            } else {
 +                self.adapter.hide()?;
 +            }
 +            self.original_visible = self.visible_toggle.value;
 +        }
++
 +        self.dirty = false;
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {
 +        self.refresh_status();
 +    }
++
 +    fn set_instant_apply(&mut self, enabled: bool) {
 +        self.instant_apply = enabled;
 +    }
++
 +    fn instant_apply_enabled(&self) -> bool {
 +        self.instant_apply
 +    }
++
 +    fn apply_instant(&mut self) -> Result<()> {
 +        if !self.adapter.is_connected() {
 +            self.adapter.connect()?;
 +        }
++
 +        if let Some(field) = self.pending_change.take() {
 +            match field {
 +                "visible" => {
 +                    if self.visible_toggle.value != self.original_visible {
 +                        if self.visible_toggle.value {
 +                            self.adapter.show()?;
 +                        } else {
 +                            self.adapter.hide()?;
 +                        }
 +                        self.original_visible = self.visible_toggle.value;
 +                    }
 +                }
 +                _ => {}
 +            }
 +            self.check_dirty();
 +        }
++
 +        Ok(())
 +    }
 +}

gargears/src/panels/mod.rsadded

 +//! Configuration panels for each gardesk component
++
 +mod gar;
 +mod garbar;
 +mod garbg;
 +mod garclip;
 +mod garfield;
 +mod garlaunch;
 +mod garlock;
 +mod garnotify;
 +mod garshot;
 +mod garterm;
 +mod gartray;
 +mod placeholder;
++
 +pub use gar::GarPanel;
 +pub use garbar::GarbarPanel;
 +pub use garbg::GarbgPanel;
 +pub use garclip::GarclipPanel;
 +pub use garfield::GarfieldPanel;
 +pub use garlaunch::GarlaunchPanel;
 +pub use garlock::GarlockPanel;
 +pub use garnotify::GarnotifyPanel;
 +pub use garshot::GarshotPanel;
 +pub use garterm::GartermPanel;
 +pub use gartray::GartrayPanel;
 +pub use placeholder::PlaceholderPanel;
++
 +use serde::{Deserialize, Serialize};
++
 +/// All gardesk components that can be configured
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 +pub enum Component {
 +    Gar,
 +    Garbar,
 +    Garbg,
 +    Garterm,
 +    Gartray,
 +    Garshot,
 +    Garlock,
 +    Garfield,
 +    Garclip,
 +    Garlaunch,
 +    Garnotify,
 +}
++
 +impl Component {
 +    /// Get all components in display order
 +    pub fn all() -> Vec<Component> {
 +        vec![
 +            Component::Gar,
 +            Component::Garbar,
 +            Component::Garbg,
 +            Component::Garterm,
 +            Component::Gartray,
 +            Component::Garshot,
 +            Component::Garlock,
 +            Component::Garfield,
 +            Component::Garclip,
 +            Component::Garlaunch,
 +            Component::Garnotify,
 +        ]
 +    }
++
 +    /// Get display name for a component
 +    pub fn display_name(&self) -> &'static str {
 +        match self {
 +            Component::Gar => "gar",
 +            Component::Garbar => "garbar",
 +            Component::Garbg => "garbg",
 +            Component::Garterm => "garterm",
 +            Component::Gartray => "gartray",
 +            Component::Garshot => "garshot",
 +            Component::Garlock => "garlock",
 +            Component::Garfield => "garfield",
 +            Component::Garclip => "garclip",
 +            Component::Garlaunch => "garlaunch",
 +            Component::Garnotify => "garnotify",
 +        }
 +    }
++
 +    /// Get description for a component
 +    pub fn description(&self) -> &'static str {
 +        match self {
 +            Component::Gar => "Tiling window manager",
 +            Component::Garbar => "Status bar",
 +            Component::Garbg => "Wallpaper daemon",
 +            Component::Garterm => "Terminal emulator",
 +            Component::Gartray => "System tray & quick settings",
 +            Component::Garshot => "Screenshot tool",
 +            Component::Garlock => "Screen locker",
 +            Component::Garfield => "File explorer",
 +            Component::Garclip => "Clipboard manager",
 +            Component::Garlaunch => "Application launcher",
 +            Component::Garnotify => "Notification daemon",
 +        }
 +    }
++
 +    /// Parse a component from a name
 +    pub fn from_name(name: &str) -> Option<Component> {
 +        match name.to_lowercase().as_str() {
 +            "gar" => Some(Component::Gar),
 +            "garbar" => Some(Component::Garbar),
 +            "garbg" => Some(Component::Garbg),
 +            "garterm" => Some(Component::Garterm),
 +            "gartray" => Some(Component::Gartray),
 +            "garshot" => Some(Component::Garshot),
 +            "garlock" => Some(Component::Garlock),
 +            "garfield" => Some(Component::Garfield),
 +            "garclip" => Some(Component::Garclip),
 +            "garlaunch" => Some(Component::Garlaunch),
 +            "garnotify" => Some(Component::Garnotify),
 +            _ => None,
 +        }
 +    }
 +}

gargears/src/panels/placeholder.rsadded

 +//! Placeholder panel for components without full implementations
++
 +use crate::ui::{Panel, PanelAction};
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Placeholder panel for components not yet implemented
 +pub struct PlaceholderPanel {
 +    name: String,
 +    description: String,
 +    connected: bool,
 +}
++
 +impl PlaceholderPanel {
 +    pub fn new(name: impl Into<String>, description: impl Into<String>, connected: bool) -> Self {
 +        Self {
 +            name: name.into(),
 +            description: description.into(),
 +            connected,
 +        }
 +    }
 +}
++
 +impl Panel for PlaceholderPanel {
 +    fn name(&self) -> &str {
 +        &self.name
 +    }
++
 +    fn description(&self) -> &str {
 +        &self.description
 +    }
++
 +    fn is_dirty(&self) -> bool {
 +        false
 +    }
++
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()> {
 +        let padding = theme.padding as i32;
++
 +        // Title
 +        let title_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size + 4.0)
 +            .color(theme.foreground);
++
 +        renderer.text(
 +            &self.name,
 +            (bounds.x + padding) as f64,
 +            (bounds.y + padding) as f64,
 +            &title_style,
 +        )?;
++
 +        // Description
 +        let desc_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.item_description);
++
 +        renderer.text(
 +            &self.description,
 +            (bounds.x + padding) as f64,
 +            (bounds.y + padding + theme.font_size as i32 + 12) as f64,
 +            &desc_style,
 +        )?;
++
 +        // Connection status
 +        let status_color = if self.connected {
 +            gartk_core::Color::from_u8(0x50, 0xfa, 0x7b, 0xff) // green
 +        } else {
 +            gartk_core::Color::from_u8(0xff, 0x55, 0x55, 0xff) // red
 +        };
++
 +        let status_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(status_color);
++
 +        let status_text = if self.connected {
 +            "● Connected"
 +        } else {
 +            "○ Not running"
 +        };
++
 +        renderer.text(
 +            status_text,
 +            (bounds.x + padding) as f64,
 +            (bounds.y + padding + (theme.font_size as i32 + 12) * 2) as f64,
 +            &status_style,
 +        )?;
++
 +        // Coming soon message
 +        let coming_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.item_description);
++
 +        renderer.text(
 +            "Configuration panel coming soon...",
 +            (bounds.x + padding) as f64,
 +            (bounds.y + bounds.height as i32 / 2) as f64,
 +            &coming_style,
 +        )?;
++
 +        Ok(())
 +    }
++
 +    fn handle_event(&mut self, _event: &InputEvent) -> PanelAction {
 +        PanelAction::None
 +    }
++
 +    fn on_mouse_move(&mut self, _x: i32, _y: i32) -> bool {
 +        false
 +    }
++
 +    fn reset(&mut self) {}
++
 +    fn apply(&mut self) -> Result<()> {
 +        Ok(())
 +    }
++
 +    fn update_status(&mut self, _status: serde_json::Value) {}
 +}

gargears/src/ui/layout.rsadded

 +//! Layout calculations for gargears
++
 +use gartk_core::Rect;
++
 +/// Layout constants
 +const SIDEBAR_WIDTH: u32 = 200;
 +const PADDING: i32 = 12;
 +const GAP: i32 = 8;
++
 +/// Layout manager
 +pub struct Layout {
 +    width: u32,
 +    height: u32,
 +}
++
 +impl Layout {
 +    /// Create a new layout for the given window size
 +    pub fn new(width: u32, height: u32) -> Self {
 +        Self { width, height }
 +    }
++
 +    /// Get the sidebar bounds
 +    pub fn sidebar_bounds(&self) -> Rect {
 +        Rect::new(
 +            PADDING,
 +            PADDING,
 +            SIDEBAR_WIDTH,
 +            self.height - (PADDING * 2) as u32,
 +        )
 +    }
++
 +    /// Get the content panel bounds
 +    pub fn content_bounds(&self) -> Rect {
 +        let x = PADDING + SIDEBAR_WIDTH as i32 + GAP;
 +        Rect::new(
 +            x,
 +            PADDING,
 +            self.width - x as u32 - PADDING as u32,
 +            self.height - (PADDING * 2) as u32,
 +        )
 +    }
++
 +    /// Get the action buttons bounds (bottom of content panel)
 +    pub fn action_bounds(&self) -> Rect {
 +        let content = self.content_bounds();
 +        let button_height = 40;
 +        Rect::new(
 +            content.x,
 +            content.y + content.height as i32 - button_height,
 +            content.width,
 +            button_height as u32,
 +        )
 +    }
++
 +    /// Sidebar width constant
 +    pub fn sidebar_width(&self) -> u32 {
 +        SIDEBAR_WIDTH
 +    }
++
 +    /// Padding constant
 +    pub fn padding(&self) -> i32 {
 +        PADDING
 +    }
 +}

gargears/src/ui/mod.rsadded

 +//! UI components for gargears
++
 +mod layout;
 +pub mod panel;
 +mod sidebar;
 +pub mod widgets;
++
 +pub use layout::Layout;
 +pub use panel::{Panel, PanelAction};
 +pub use sidebar::Sidebar;

gargears/src/ui/panel.rsadded

 +//! Panel trait for configuration panels
++
 +use anyhow::Result;
 +use gartk_core::{InputEvent, Rect, Theme};
 +use gartk_render::Renderer;
++
 +/// Actions that a panel can request
 +#[derive(Debug, Clone)]
 +pub enum PanelAction {
 +    /// No action
 +    None,
 +    /// Apply changes via IPC
 +    Apply,
 +    /// Reset to original values
 +    Reset,
 +    /// Request a redraw
 +    Redraw,
 +    /// Save changes to config file
 +    Save,
 +    /// Instant apply - apply the most recently changed field immediately
 +    InstantApply,
 +}
++
 +/// Trait for configuration panels
 +pub trait Panel {
 +    /// Get the panel name (for display)
 +    fn name(&self) -> &str;
++
 +    /// Get the component description
 +    fn description(&self) -> &str;
++
 +    /// Check if the panel has unsaved changes
 +    fn is_dirty(&self) -> bool;
++
 +    /// Render the panel
 +    fn render(&mut self, renderer: &mut Renderer, bounds: Rect, theme: &Theme) -> Result<()>;
++
 +    /// Handle an input event
 +    fn handle_event(&mut self, event: &InputEvent) -> PanelAction;
++
 +    /// Handle mouse move (for hover states). Returns true if redraw needed.
 +    fn on_mouse_move(&mut self, x: i32, y: i32) -> bool;
++
 +    /// Clear focus from any focused widget in this panel
 +    fn blur_focused(&mut self) {}
++
 +    /// Reset to original/saved values
 +    fn reset(&mut self);
++
 +    /// Apply changes (send IPC commands)
 +    fn apply(&mut self) -> Result<()>;
++
 +    /// Update with fresh status from daemon
 +    fn update_status(&mut self, status: serde_json::Value);
++
 +    /// Check if this panel has a config file that can be saved
 +    fn has_config_file(&self) -> bool {
 +        false
 +    }
++
 +    /// Save current settings to config file
 +    fn save_to_config(&mut self) -> Result<()> {
 +        Ok(())
 +    }
++
 +    /// Set instant-apply mode
 +    fn set_instant_apply(&mut self, _enabled: bool) {
 +        // Default: do nothing (panel doesn't support instant apply)
 +    }
++
 +    /// Check if instant-apply is enabled
 +    fn instant_apply_enabled(&self) -> bool {
 +        false
 +    }
++
 +    /// Apply the most recently changed field (for instant-apply mode)
 +    fn apply_instant(&mut self) -> Result<()> {
 +        // Default: fall back to full apply
 +        self.apply()
 +    }
 +}

gargears/src/ui/sidebar.rsadded

 +//! Sidebar navigation component
++
 +use crate::ipc::discovery::DaemonStatus;
 +use crate::panels::Component;
 +use crate::ui::Layout;
 +use anyhow::Result;
 +use gartk_core::{Color, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Item height in sidebar
 +const ITEM_HEIGHT: i32 = 36;
 +/// Status indicator radius
 +const STATUS_RADIUS: f64 = 4.0;
++
 +/// Sidebar navigation
 +pub struct Sidebar {
 +    hovered: Option<Component>,
 +}
++
 +impl Sidebar {
 +    /// Create a new sidebar
 +    pub fn new() -> Self {
 +        Self { hovered: None }
 +    }
++
 +    /// Get the component at a given y position
 +    pub fn component_at_y(
 +        &self,
 +        y: i32,
 +        layout: &Layout,
 +        theme: &Theme,
 +    ) -> Option<Component> {
 +        let bounds = layout.sidebar_bounds();
 +        let start_y = bounds.y + theme.padding as i32;
++
 +        let components = Component::all();
 +        for (i, component) in components.iter().enumerate() {
 +            let item_y = start_y + (i as i32 * ITEM_HEIGHT);
 +            if y >= item_y && y < item_y + ITEM_HEIGHT {
 +                return Some(*component);
 +            }
 +        }
 +        None
 +    }
++
 +    /// Render the sidebar
 +    pub fn render(
 +        &self,
 +        renderer: &mut Renderer,
 +        layout: &Layout,
 +        theme: &Theme,
 +        selected: Component,
 +        daemon_status: &[DaemonStatus],
 +    ) -> Result<()> {
 +        let bounds = layout.sidebar_bounds();
++
 +        // Draw sidebar background
 +        renderer.fill_rounded_rect(bounds, theme.border_radius, theme.item_background)?;
++
 +        // Draw title
 +        let title_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 1.2)
 +            .color(theme.foreground);
++
 +        renderer.text(
 +            "Components",
 +            (bounds.x + theme.padding as i32) as f64,
 +            (bounds.y + theme.padding as i32) as f64,
 +            &title_style,
 +        )?;
++
 +        // Draw components
 +        let start_y = bounds.y + theme.padding as i32 + theme.font_size as i32 + 16;
 +        let components = Component::all();
++
 +        for (i, component) in components.iter().enumerate() {
 +            let item_y = start_y + (i as i32 * ITEM_HEIGHT);
 +            let item_rect = Rect::new(
 +                bounds.x + 4,
 +                item_y,
 +                bounds.width - 8,
 +                ITEM_HEIGHT as u32,
 +            );
++
 +            // Highlight selected
 +            if *component == selected {
 +                renderer.fill_rounded_rect(
 +                    item_rect,
 +                    theme.border_radius / 2.0,
 +                    theme.item_selected_background,
 +                )?;
 +            }
++
 +            // Draw status indicator
 +            let status = daemon_status.iter().find(|s| s.component == *component);
 +            let indicator_color = match status {
 +                Some(s) if s.running => Color::from_u8(0x50, 0xfa, 0x7b, 0xff), // Green
 +                _ => Color::from_u8(0x6c, 0x75, 0x7d, 0xff),                     // Gray
 +            };
++
 +            let indicator_x = bounds.x + theme.padding as i32 + STATUS_RADIUS as i32;
 +            let indicator_y = item_y + (ITEM_HEIGHT / 2);
++
 +            renderer.fill_circle(
 +                indicator_x as f64,
 +                indicator_y as f64,
 +                STATUS_RADIUS,
 +                indicator_color,
 +            )?;
++
 +            // Draw component name
 +            let name_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size)
 +                .color(if *component == selected {
 +                    theme.item_selected_foreground
 +                } else {
 +                    theme.item_foreground
 +                });
++
 +            let text_x = bounds.x + theme.padding as i32 + (STATUS_RADIUS * 2.0) as i32 + 12;
 +            let text_y = item_y + (ITEM_HEIGHT - theme.font_size as i32) / 2;
++
 +            renderer.text(
 +                component.display_name(),
 +                text_x as f64,
 +                text_y as f64,
 +                &name_style,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
 +}

gargears/src/ui/widgets/button.rsadded

 +//! Clickable button widget
++
 +use super::{point_in_rect, WidgetEvent, WidgetState};
 +use anyhow::Result;
 +use gartk_core::{Color, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// A clickable button
 +pub struct Button {
 +    pub label: String,
 +    pub bounds: Rect,
 +    pub state: WidgetState,
 +    pub primary: bool,
 +}
++
 +impl Button {
 +    /// Create a new button
 +    pub fn new(label: impl Into<String>) -> Self {
 +        Self {
 +            label: label.into(),
 +            bounds: Rect::new(0, 0, 100, 32),
 +            state: WidgetState::Normal,
 +            primary: false,
 +        }
 +    }
++
 +    /// Mark as primary (highlighted) button
 +    pub fn primary(mut self) -> Self {
 +        self.primary = true;
 +        self
 +    }
++
 +    /// Set bounds
 +    pub fn with_bounds(mut self, bounds: Rect) -> Self {
 +        self.bounds = bounds;
 +        self
 +    }
++
 +    /// Handle mouse move. Returns true if state changed (needs redraw).
 +    pub fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        if self.state == WidgetState::Disabled {
 +            return false;
 +        }
 +        let old_state = self.state;
 +        if point_in_rect(x, y, self.bounds) {
 +            self.state = WidgetState::Hovered;
 +        } else {
 +            self.state = WidgetState::Normal;
 +        }
 +        old_state != self.state
 +    }
++
 +    /// Handle mouse click
 +    pub fn on_click(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if self.state != WidgetState::Disabled && point_in_rect(x, y, self.bounds) {
 +            WidgetEvent::Clicked
 +        } else {
 +            WidgetEvent::None
 +        }
 +    }
++
 +    /// Render the button
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        // Background color based on state
 +        let bg_color = match self.state {
 +            WidgetState::Hovered => {
 +                if self.primary {
 +                    Color::from_u8(0x6c, 0xa4, 0xf8, 0xff) // Lighter primary
 +                } else {
 +                    theme.item_hover_background
 +                }
 +            }
 +            WidgetState::Disabled => Color::from_u8(0x40, 0x40, 0x40, 0xff),
 +            _ => {
 +                if self.primary {
 +                    Color::from_u8(0x5c, 0x94, 0xe8, 0xff) // Primary blue
 +                } else {
 +                    theme.input_background
 +                }
 +            }
 +        };
++
 +        // Draw background
 +        renderer.fill_rounded_rect(self.bounds, theme.border_radius / 2.0, bg_color)?;
++
 +        // Draw border
 +        renderer.stroke_rounded_rect(
 +            self.bounds,
 +            theme.border_radius / 2.0,
 +            theme.border,
 +            1.0,
 +        )?;
++
 +        // Draw text centered
 +        let text_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(if self.state == WidgetState::Disabled {
 +                theme.item_description
 +            } else {
 +                theme.foreground
 +            });
++
 +        let text_size = renderer.measure_text(&self.label, &text_style)?;
 +        let text_x = self.bounds.x + (self.bounds.width as i32 - text_size.width as i32) / 2;
 +        let text_y = self.bounds.y + (self.bounds.height as i32 - text_size.height as i32) / 2;
++
 +        renderer.text(&self.label, text_x as f64, text_y as f64, &text_style)?;
++
 +        Ok(())
 +    }
 +}

gargears/src/ui/widgets/color_picker.rsadded

 +//! Color picker widget with hex input and preview
++
 +use super::{point_in_rect, WidgetEvent, WidgetState};
 +use anyhow::Result;
 +use gartk_core::{Color, Key, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// A color picker with hex input and preview square
 +pub struct ColorPicker {
 +    pub label: String,
 +    pub value: String,
 +    pub bounds: Rect,
 +    pub state: WidgetState,
 +    pub cursor: usize,
 +}
++
 +impl ColorPicker {
 +    /// Create a new color picker
 +    pub fn new(label: impl Into<String>, value: impl Into<String>) -> Self {
 +        let value = value.into();
 +        let cursor = value.len();
 +        Self {
 +            label: label.into(),
 +            value,
 +            bounds: Rect::new(0, 0, 250, 28),
 +            state: WidgetState::Normal,
 +            cursor,
 +        }
 +    }
++
 +    /// Parse hex color string to Color
 +    fn parse_color(&self) -> Option<Color> {
 +        let hex = self.value.trim_start_matches('#');
 +        if hex.len() == 6 {
 +            let r = u8::from_str_radix(&hex[0..2], 16).ok()?;
 +            let g = u8::from_str_radix(&hex[2..4], 16).ok()?;
 +            let b = u8::from_str_radix(&hex[4..6], 16).ok()?;
 +            Some(Color::from_u8(r, g, b, 0xff))
 +        } else if hex.len() == 8 {
 +            let r = u8::from_str_radix(&hex[0..2], 16).ok()?;
 +            let g = u8::from_str_radix(&hex[2..4], 16).ok()?;
 +            let b = u8::from_str_radix(&hex[4..6], 16).ok()?;
 +            let a = u8::from_str_radix(&hex[6..8], 16).ok()?;
 +            Some(Color::from_u8(r, g, b, a))
 +        } else {
 +            None
 +        }
 +    }
++
 +    /// Get input field bounds
 +    fn input_bounds(&self) -> Rect {
 +        let preview_size = 24;
 +        let input_width = 100;
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 - input_width - preview_size - 8,
 +            self.bounds.y + 2,
 +            input_width as u32,
 +            self.bounds.height - 4,
 +        )
 +    }
++
 +    /// Get preview square bounds
 +    fn preview_bounds(&self) -> Rect {
 +        let preview_size = 24;
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 - preview_size - 2,
 +            self.bounds.y + (self.bounds.height as i32 - preview_size) / 2,
 +            preview_size as u32,
 +            preview_size as u32,
 +        )
 +    }
++
 +    /// Clear focus from this widget
 +    pub fn blur(&mut self) {
 +        if self.state == WidgetState::Focused {
 +            self.state = WidgetState::Normal;
 +        }
 +    }
++
 +    /// Handle mouse move. Returns true if state changed (needs redraw).
 +    pub fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        if self.state == WidgetState::Disabled || self.state == WidgetState::Focused {
 +            return false;
 +        }
 +        let old_state = self.state;
 +        if point_in_rect(x, y, self.input_bounds()) {
 +            self.state = WidgetState::Hovered;
 +        } else {
 +            self.state = WidgetState::Normal;
 +        }
 +        old_state != self.state
 +    }
++
 +    /// Handle mouse click
 +    pub fn on_click(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if self.state != WidgetState::Disabled && point_in_rect(x, y, self.input_bounds()) {
 +            self.state = WidgetState::Focused;
 +            WidgetEvent::Focus
 +        } else if self.state == WidgetState::Focused {
 +            self.state = WidgetState::Normal;
 +            WidgetEvent::Blur
 +        } else {
 +            WidgetEvent::None
 +        }
 +    }
++
 +    /// Handle key press (only when focused)
 +    pub fn on_key(&mut self, key: &Key) -> WidgetEvent {
 +        if self.state != WidgetState::Focused {
 +            return WidgetEvent::None;
 +        }
++
 +        match key {
 +            Key::Char(c) => {
 +                // Only allow hex characters and #
 +                if c.is_ascii_hexdigit() || *c == '#' {
 +                    self.value.insert(self.cursor, *c);
 +                    self.cursor += 1;
 +                    WidgetEvent::Changed
 +                } else {
 +                    WidgetEvent::None
 +                }
 +            }
 +            Key::Backspace => {
 +                if self.cursor > 0 {
 +                    self.value.remove(self.cursor - 1);
 +                    self.cursor -= 1;
 +                    WidgetEvent::Changed
 +                } else {
 +                    WidgetEvent::None
 +                }
 +            }
 +            Key::Delete => {
 +                if self.cursor < self.value.len() {
 +                    self.value.remove(self.cursor);
 +                    WidgetEvent::Changed
 +                } else {
 +                    WidgetEvent::None
 +                }
 +            }
 +            Key::Left => {
 +                if self.cursor > 0 {
 +                    self.cursor -= 1;
 +                }
 +                WidgetEvent::None
 +            }
 +            Key::Right => {
 +                if self.cursor < self.value.len() {
 +                    self.cursor += 1;
 +                }
 +                WidgetEvent::None
 +            }
 +            Key::Home => {
 +                self.cursor = 0;
 +                WidgetEvent::None
 +            }
 +            Key::End => {
 +                self.cursor = self.value.len();
 +                WidgetEvent::None
 +            }
 +            Key::Escape | Key::Return => {
 +                self.state = WidgetState::Normal;
 +                WidgetEvent::Blur
 +            }
 +            _ => WidgetEvent::None,
 +        }
 +    }
++
 +    /// Render the color picker
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        // Draw label
 +        let label_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        let label_y = self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(&self.label, self.bounds.x as f64, label_y as f64, &label_style)?;
++
 +        // Draw input field
 +        let input = self.input_bounds();
++
 +        let bg_color = match self.state {
 +            WidgetState::Focused => theme.input_background,
 +            WidgetState::Hovered => theme.item_hover_background,
 +            _ => theme.input_background,
 +        };
++
 +        renderer.fill_rounded_rect(input, 4.0, bg_color)?;
++
 +        let border_color = if self.state == WidgetState::Focused {
 +            theme.input_cursor
 +        } else {
 +            theme.border
 +        };
 +        renderer.stroke_rounded_rect(input, 4.0, border_color, 1.0)?;
++
 +        // Draw value
 +        let text_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.input_foreground)
 +            .ellipsize(true)
 +            .max_width(input.width as i32 - 12);
++
 +        let text_x = input.x + 6;
 +        let text_y = input.y + (input.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(&self.value, text_x as f64, text_y as f64, &text_style)?;
++
 +        // Draw cursor if focused
 +        if self.state == WidgetState::Focused {
 +            let cursor_text = &self.value[..self.cursor];
 +            let cursor_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size);
 +            let cursor_size = renderer.measure_text(cursor_text, &cursor_style)?;
 +            let cursor_x = text_x + cursor_size.width as i32;
++
 +            renderer.fill_rect(
 +                Rect::new(cursor_x, input.y + 4, 2, input.height - 8),
 +                theme.input_cursor,
 +            )?;
 +        }
++
 +        // Draw color preview square
 +        let preview = self.preview_bounds();
++
 +        // Draw checkerboard pattern for transparency indication
 +        let checker_color = Color::from_u8(0x80, 0x80, 0x80, 0xff);
 +        renderer.fill_rounded_rect(preview, 3.0, checker_color)?;
++
 +        // Draw the actual color
 +        if let Some(color) = self.parse_color() {
 +            renderer.fill_rounded_rect(preview, 3.0, color)?;
 +        }
++
 +        // Draw preview border
 +        renderer.stroke_rounded_rect(preview, 3.0, theme.border, 1.0)?;
++
 +        Ok(())
 +    }
 +}

gargears/src/ui/widgets/dropdown.rsadded

 +//! Dropdown selection widget
++
 +use super::{point_in_rect, WidgetEvent, WidgetState};
 +use anyhow::Result;
 +use gartk_core::{Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Dropdown widget height
 +const DROPDOWN_HEIGHT: u32 = 32;
 +/// Item height in dropdown
 +const ITEM_HEIGHT: u32 = 28;
 +/// Max visible items before scrolling
 +const MAX_VISIBLE_ITEMS: usize = 6;
++
 +/// A dropdown selection widget
 +pub struct Dropdown {
 +    pub label: String,
 +    pub options: Vec<String>,
 +    pub selected_index: usize,
 +    pub bounds: Rect,
 +    pub state: WidgetState,
 +    pub expanded: bool,
 +    scroll_offset: usize,
 +    hovered_item: Option<usize>,
 +}
++
 +impl Dropdown {
 +    /// Create a new dropdown
 +    pub fn new(label: impl Into<String>, options: Vec<String>) -> Self {
 +        Self {
 +            label: label.into(),
 +            options,
 +            selected_index: 0,
 +            bounds: Rect::new(0, 0, 300, DROPDOWN_HEIGHT),
 +            state: WidgetState::Normal,
 +            expanded: false,
 +            scroll_offset: 0,
 +            hovered_item: None,
 +        }
 +    }
++
 +    /// Set initial selection
 +    pub fn with_selection(mut self, index: usize) -> Self {
 +        if index < self.options.len() {
 +            self.selected_index = index;
 +        }
 +        self
 +    }
++
 +    /// Get the selected value
 +    pub fn selected_value(&self) -> Option<&str> {
 +        self.options.get(self.selected_index).map(|s| s.as_str())
 +    }
++
 +    /// Set selected by value
 +    pub fn set_selected(&mut self, value: &str) {
 +        if let Some(idx) = self.options.iter().position(|o| o == value) {
 +            self.selected_index = idx;
 +        }
 +    }
++
 +    /// Get the dropdown button bounds (clickable area)
 +    fn button_bounds(&self) -> Rect {
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 / 2,
 +            self.bounds.y,
 +            self.bounds.width / 2,
 +            DROPDOWN_HEIGHT,
 +        )
 +    }
++
 +    /// Get the expanded dropdown list bounds
 +    fn list_bounds(&self) -> Rect {
 +        let visible_count = self.options.len().min(MAX_VISIBLE_ITEMS);
 +        let list_height = (visible_count as u32 * ITEM_HEIGHT) + 4; // +4 for border
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 / 2,
 +            self.bounds.y + DROPDOWN_HEIGHT as i32,
 +            self.bounds.width / 2,
 +            list_height,
 +        )
 +    }
++
 +    /// Get item bounds for an index (relative to scroll)
 +    fn item_bounds(&self, display_index: usize) -> Rect {
 +        let list = self.list_bounds();
 +        Rect::new(
 +            list.x + 2,
 +            list.y + 2 + (display_index as i32 * ITEM_HEIGHT as i32),
 +            list.width - 4,
 +            ITEM_HEIGHT,
 +        )
 +    }
++
 +    /// Handle mouse move
 +    pub fn on_mouse_move(&mut self, x: i32, y: i32) {
 +        if self.state == WidgetState::Disabled {
 +            return;
 +        }
++
 +        if self.expanded {
 +            // Check if hovering over list items
 +            let list = self.list_bounds();
 +            if point_in_rect(x, y, list) {
 +                let visible_count = self.options.len().min(MAX_VISIBLE_ITEMS);
 +                for i in 0..visible_count {
 +                    let item = self.item_bounds(i);
 +                    if point_in_rect(x, y, item) {
 +                        self.hovered_item = Some(self.scroll_offset + i);
 +                        self.state = WidgetState::Hovered;
 +                        return;
 +                    }
 +                }
 +            }
 +            self.hovered_item = None;
 +        }
++
 +        // Check button hover
 +        if point_in_rect(x, y, self.button_bounds()) {
 +            self.state = WidgetState::Hovered;
 +        } else if !self.expanded {
 +            self.state = WidgetState::Normal;
 +        }
 +    }
++
 +    /// Handle mouse click
 +    pub fn on_click(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if self.state == WidgetState::Disabled {
 +            return WidgetEvent::None;
 +        }
++
 +        if self.expanded {
 +            // Check if clicking on an item
 +            if let Some(hovered) = self.hovered_item {
 +                if hovered < self.options.len() {
 +                    self.selected_index = hovered;
 +                    self.expanded = false;
 +                    self.hovered_item = None;
 +                    return WidgetEvent::Changed;
 +                }
 +            }
++
 +            // Click outside closes dropdown
 +            let list = self.list_bounds();
 +            let button = self.button_bounds();
 +            if !point_in_rect(x, y, list) && !point_in_rect(x, y, button) {
 +                self.expanded = false;
 +                self.hovered_item = None;
 +                return WidgetEvent::None;
 +            }
 +        }
++
 +        // Toggle expansion
 +        if point_in_rect(x, y, self.button_bounds()) {
 +            self.expanded = !self.expanded;
 +            if self.expanded {
 +                // Scroll to show selected item
 +                if self.selected_index >= MAX_VISIBLE_ITEMS {
 +                    self.scroll_offset = self.selected_index - MAX_VISIBLE_ITEMS + 1;
 +                } else {
 +                    self.scroll_offset = 0;
 +                }
 +            } else {
 +                self.hovered_item = None;
 +            }
 +            return WidgetEvent::Clicked;
 +        }
++
 +        WidgetEvent::None
 +    }
++
 +    /// Handle scroll (when expanded)
 +    pub fn on_scroll(&mut self, delta: i32) {
 +        if !self.expanded || self.options.len() <= MAX_VISIBLE_ITEMS {
 +            return;
 +        }
++
 +        let max_scroll = self.options.len() - MAX_VISIBLE_ITEMS;
 +        if delta < 0 && self.scroll_offset > 0 {
 +            self.scroll_offset = self.scroll_offset.saturating_sub((-delta) as usize);
 +        } else if delta > 0 {
 +            self.scroll_offset = (self.scroll_offset + delta as usize).min(max_scroll);
 +        }
 +    }
++
 +    /// Close the dropdown
 +    pub fn close(&mut self) {
 +        self.expanded = false;
 +        self.hovered_item = None;
 +    }
++
 +    /// Render the dropdown
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        // Draw label
 +        let label_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        let label_y = self.bounds.y + (DROPDOWN_HEIGHT as i32 - theme.font_size as i32) / 2;
 +        renderer.text(&self.label, self.bounds.x as f64, label_y as f64, &label_style)?;
++
 +        // Draw dropdown button
 +        let button = self.button_bounds();
++
 +        // Button background
 +        let bg_color = if self.state == WidgetState::Hovered && !self.expanded {
 +            theme.item_hover_background
 +        } else {
 +            theme.input_background
 +        };
 +        renderer.fill_rounded_rect(button, 4.0, bg_color)?;
 +        renderer.stroke_rounded_rect(button, 4.0, theme.border, 1.0)?;
++
 +        // Selected text
 +        let text = self
 +            .options
 +            .get(self.selected_index)
 +            .map(|s| s.as_str())
 +            .unwrap_or("Select...");
++
 +        let text_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.9)
 +            .color(theme.foreground)
 +            .ellipsize(true)
 +            .max_width(button.width as i32 - 28);
++
 +        renderer.text(
 +            text,
 +            (button.x + 8) as f64,
 +            (button.y + 8) as f64,
 +            &text_style,
 +        )?;
++
 +        // Dropdown arrow
 +        let arrow = if self.expanded { "▲" } else { "▼" };
 +        let arrow_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.75)
 +            .color(theme.item_description);
++
 +        renderer.text(
 +            arrow,
 +            (button.x + button.width as i32 - 18) as f64,
 +            (button.y + 10) as f64,
 +            &arrow_style,
 +        )?;
++
 +        // Draw expanded list
 +        if self.expanded {
 +            self.render_list(renderer, theme)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Render the expanded list
 +    fn render_list(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        let list = self.list_bounds();
++
 +        // List background
 +        renderer.fill_rounded_rect(list, 4.0, theme.background)?;
 +        renderer.stroke_rounded_rect(list, 4.0, theme.border, 1.0)?;
++
 +        // Items
 +        let visible_count = self.options.len().min(MAX_VISIBLE_ITEMS);
 +        for i in 0..visible_count {
 +            let actual_index = self.scroll_offset + i;
 +            if actual_index >= self.options.len() {
 +                break;
 +            }
++
 +            let item = self.item_bounds(i);
 +            let is_selected = actual_index == self.selected_index;
 +            let is_hovered = self.hovered_item == Some(actual_index);
++
 +            // Item background
 +            if is_selected {
 +                renderer.fill_rounded_rect(item, 2.0, theme.item_selected_background)?;
 +            } else if is_hovered {
 +                renderer.fill_rounded_rect(item, 2.0, theme.item_hover_background)?;
 +            }
++
 +            // Item text
 +            let text_color = if is_selected {
 +                theme.item_selected_foreground
 +            } else {
 +                theme.foreground
 +            };
++
 +            let text_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.9)
 +                .color(text_color)
 +                .ellipsize(true)
 +                .max_width(item.width as i32 - 16);
++
 +            renderer.text(
 +                &self.options[actual_index],
 +                (item.x + 8) as f64,
 +                (item.y + 6) as f64,
 +                &text_style,
 +            )?;
 +        }
++
 +        // Scroll indicators
 +        if self.options.len() > MAX_VISIBLE_ITEMS {
 +            let indicator_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.6)
 +                .color(theme.item_description);
++
 +            if self.scroll_offset > 0 {
 +                renderer.text(
 +                    "▲",
 +                    (list.x + list.width as i32 - 14) as f64,
 +                    (list.y + 4) as f64,
 +                    &indicator_style,
 +                )?;
 +            }
++
 +            let max_scroll = self.options.len() - MAX_VISIBLE_ITEMS;
 +            if self.scroll_offset < max_scroll {
 +                renderer.text(
 +                    "▼",
 +                    (list.x + list.width as i32 - 14) as f64,
 +                    (list.y + list.height as i32 - 14) as f64,
 +                    &indicator_style,
 +                )?;
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Get total height including expanded list (for layout purposes)
 +    pub fn expanded_height(&self) -> u32 {
 +        if self.expanded {
 +            let list = self.list_bounds();
 +            DROPDOWN_HEIGHT + list.height
 +        } else {
 +            DROPDOWN_HEIGHT
 +        }
 +    }
 +}

gargears/src/ui/widgets/label.rsadded

 +//! Static text label widget
++
 +use anyhow::Result;
 +use gartk_core::{Color, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// A static text label with optional key-value display
 +pub struct Label {
 +    pub label: String,
 +    pub text: String,
 +    pub bounds: Rect,
 +    pub color: Option<Color>,
 +    pub font_size_multiplier: f64,
 +}
++
 +impl Label {
 +    /// Create a new label
 +    pub fn new(label: impl Into<String>, text: impl Into<String>) -> Self {
 +        Self {
 +            label: label.into(),
 +            text: text.into(),
 +            bounds: Rect::new(0, 0, 0, 0),
 +            color: None,
 +            font_size_multiplier: 1.0,
 +        }
 +    }
++
 +    /// Create a label with just text (no key)
 +    pub fn text_only(text: impl Into<String>) -> Self {
 +        Self {
 +            label: String::new(),
 +            text: text.into(),
 +            bounds: Rect::new(0, 0, 0, 0),
 +            color: None,
 +            font_size_multiplier: 1.0,
 +        }
 +    }
++
 +    /// Set custom color
 +    pub fn with_color(mut self, color: Color) -> Self {
 +        self.color = Some(color);
 +        self
 +    }
++
 +    /// Set font size multiplier
 +    pub fn with_size(mut self, multiplier: f64) -> Self {
 +        self.font_size_multiplier = multiplier;
 +        self
 +    }
++
 +    /// Render the label at a specific position
 +    pub fn render_at(&self, renderer: &mut Renderer, x: i32, y: i32, theme: &Theme) -> Result<()> {
 +        let style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * self.font_size_multiplier)
 +            .color(self.color.unwrap_or(theme.foreground));
++
 +        renderer.text(&self.text, x as f64, y as f64, &style)?;
 +        Ok(())
 +    }
++
 +    /// Render the label using its bounds (with optional label prefix)
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        let y = self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2;
++
 +        // Draw label if present
 +        if !self.label.is_empty() {
 +            let label_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * self.font_size_multiplier)
 +                .color(theme.foreground);
++
 +            renderer.text(&self.label, self.bounds.x as f64, y as f64, &label_style)?;
++
 +            // Draw value on the right side
 +            let value_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * self.font_size_multiplier)
 +                .color(self.color.unwrap_or(theme.item_description));
++
 +            let value_x = self.bounds.x + self.bounds.width as i32 / 2;
 +            renderer.text(&self.text, value_x as f64, y as f64, &value_style)?;
 +        } else {
 +            let style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * self.font_size_multiplier)
 +                .color(self.color.unwrap_or(theme.foreground));
++
 +            renderer.text(&self.text, self.bounds.x as f64, y as f64, &style)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Measure the label size
 +    pub fn measure(&self, renderer: &Renderer, theme: &Theme) -> Result<(u32, u32)> {
 +        let style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * self.font_size_multiplier);
++
 +        let size = renderer.measure_text(&self.text, &style)?;
 +        Ok((size.width, size.height))
 +    }
 +}

gargears/src/ui/widgets/list.rsadded

 +//! Read-only list widget for displaying items
++
 +use anyhow::Result;
 +use gartk_core::{Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// A read-only list displaying string items
 +pub struct List {
 +    pub items: Vec<String>,
 +    pub bounds: Rect,
 +    pub scroll_offset: i32,
 +    pub max_visible: usize,
 +}
++
 +impl List {
 +    /// Create a new list
 +    pub fn new() -> Self {
 +        Self {
 +            items: Vec::new(),
 +            bounds: Rect::new(0, 0, 200, 100),
 +            scroll_offset: 0,
 +            max_visible: 5,
 +        }
 +    }
++
 +    /// Set items
 +    pub fn with_items(mut self, items: Vec<String>) -> Self {
 +        self.items = items;
 +        self
 +    }
++
 +    /// Set max visible items
 +    pub fn with_max_visible(mut self, max: usize) -> Self {
 +        self.max_visible = max;
 +        self
 +    }
++
 +    /// Update items
 +    pub fn set_items(&mut self, items: Vec<String>) {
 +        self.items = items;
 +        self.scroll_offset = 0;
 +    }
++
 +    /// Scroll up
 +    pub fn scroll_up(&mut self) {
 +        if self.scroll_offset > 0 {
 +            self.scroll_offset -= 1;
 +        }
 +    }
++
 +    /// Scroll down
 +    pub fn scroll_down(&mut self) {
 +        let max_scroll = (self.items.len() as i32 - self.max_visible as i32).max(0);
 +        if self.scroll_offset < max_scroll {
 +            self.scroll_offset += 1;
 +        }
 +    }
++
 +    /// Render the list
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        let item_height = (theme.font_size + 8.0) as i32;
 +        let mut y = self.bounds.y;
++
 +        // Draw background
 +        renderer.fill_rounded_rect(self.bounds, 4.0, theme.input_background)?;
 +        renderer.stroke_rounded_rect(self.bounds, 4.0, theme.border, 1.0)?;
++
 +        let text_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.9)
 +            .color(theme.foreground)
 +            .ellipsize(true)
 +            .max_width(self.bounds.width as i32 - 16);
++
 +        let start = self.scroll_offset as usize;
 +        let end = (start + self.max_visible).min(self.items.len());
++
 +        for item in self.items.iter().skip(start).take(end - start) {
 +            if y + item_height > self.bounds.y + self.bounds.height as i32 {
 +                break;
 +            }
 +            renderer.text(
 +                item,
 +                (self.bounds.x + 8) as f64,
 +                (y + 4) as f64,
 +                &text_style,
 +            )?;
 +            y += item_height;
 +        }
++
 +        // Draw scroll indicators if needed
 +        if self.items.len() > self.max_visible {
 +            let indicator_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.75)
 +                .color(theme.item_description);
++
 +            if self.scroll_offset > 0 {
 +                renderer.text(
 +                    "▲",
 +                    (self.bounds.x + self.bounds.width as i32 - 16) as f64,
 +                    self.bounds.y as f64,
 +                    &indicator_style,
 +                )?;
 +            }
++
 +            let max_scroll = (self.items.len() as i32 - self.max_visible as i32).max(0);
 +            if self.scroll_offset < max_scroll {
 +                renderer.text(
 +                    "▼",
 +                    (self.bounds.x + self.bounds.width as i32 - 16) as f64,
 +                    (self.bounds.y + self.bounds.height as i32 - 16) as f64,
 +                    &indicator_style,
 +                )?;
 +            }
++
 +            // Show count
 +            let count_text = format!("{}/{}", end, self.items.len());
 +            renderer.text(
 +                &count_text,
 +                (self.bounds.x + self.bounds.width as i32 - 50) as f64,
 +                (self.bounds.y + self.bounds.height as i32 - 16) as f64,
 +                &indicator_style,
 +            )?;
 +        }
++
 +        // Empty state
 +        if self.items.is_empty() {
 +            let empty_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.9)
 +                .color(theme.item_description);
++
 +            renderer.text(
 +                "No items",
 +                (self.bounds.x + 8) as f64,
 +                (self.bounds.y + 4) as f64,
 +                &empty_style,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
 +}
++
 +impl Default for List {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}

gargears/src/ui/widgets/mod.rsadded

 +//! Reusable UI widgets for configuration panels
++
 +mod button;
 +mod color_picker;
 +mod dropdown;
 +mod label;
 +mod list;
 +mod number_input;
 +mod section;
 +mod slider;
 +mod text_input;
 +mod toggle;
++
 +pub use button::Button;
 +pub use color_picker::ColorPicker;
 +pub use dropdown::Dropdown;
 +pub use label::Label;
 +pub use list::List;
 +pub use number_input::NumberInput;
 +pub use section::Section;
 +pub use slider::Slider;
 +pub use text_input::TextInput;
 +pub use toggle::Toggle;
++
 +use gartk_core::Rect;
++
 +/// Common widget state
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum WidgetState {
 +    Normal,
 +    Hovered,
 +    Focused,
 +    Disabled,
 +}
++
 +/// Result of handling an event
 +#[derive(Debug, Clone)]
 +pub enum WidgetEvent {
 +    /// No action needed
 +    None,
 +    /// Value was changed
 +    Changed,
 +    /// Widget was clicked/activated
 +    Clicked,
 +    /// Request focus
 +    Focus,
 +    /// Release focus
 +    Blur,
 +}
++
 +/// Check if a point is within a rect
 +pub fn point_in_rect(x: i32, y: i32, rect: Rect) -> bool {
 +    x >= rect.x
 +        && x < rect.x + rect.width as i32
 +        && y >= rect.y
 +        && y < rect.y + rect.height as i32
 +}

gargears/src/ui/widgets/number_input.rsadded

 +//! Number input widget with increment/decrement buttons
++
 +use super::{point_in_rect, WidgetEvent, WidgetState};
 +use anyhow::Result;
 +use gartk_core::{Color, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Number input with +/- buttons
 +pub struct NumberInput {
 +    pub label: String,
 +    pub value: i32,
 +    pub min: i32,
 +    pub max: i32,
 +    pub step: i32,
 +    pub bounds: Rect,
 +    pub state: WidgetState,
 +    hover_plus: bool,
 +    hover_minus: bool,
 +}
++
 +impl NumberInput {
 +    /// Create a new number input
 +    pub fn new(label: impl Into<String>, value: i32) -> Self {
 +        Self {
 +            label: label.into(),
 +            value,
 +            min: 0,
 +            max: 100,
 +            step: 1,
 +            bounds: Rect::new(0, 0, 250, 28),
 +            state: WidgetState::Normal,
 +            hover_plus: false,
 +            hover_minus: false,
 +        }
 +    }
++
 +    /// Set range
 +    pub fn with_range(mut self, min: i32, max: i32) -> Self {
 +        self.min = min;
 +        self.max = max;
 +        self
 +    }
++
 +    /// Set step
 +    pub fn with_step(mut self, step: i32) -> Self {
 +        self.step = step;
 +        self
 +    }
++
 +    /// Get bounds for minus button
 +    fn minus_bounds(&self) -> Rect {
 +        let btn_size = self.bounds.height;
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 - (btn_size * 2 + 50) as i32,
 +            self.bounds.y,
 +            btn_size,
 +            btn_size,
 +        )
 +    }
++
 +    /// Get bounds for plus button
 +    fn plus_bounds(&self) -> Rect {
 +        let btn_size = self.bounds.height;
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 - btn_size as i32,
 +            self.bounds.y,
 +            btn_size,
 +            btn_size,
 +        )
 +    }
++
 +    /// Get bounds for value display
 +    fn value_bounds(&self) -> Rect {
 +        let btn_size = self.bounds.height;
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 - (btn_size + 50) as i32,
 +            self.bounds.y,
 +            50,
 +            btn_size,
 +        )
 +    }
++
 +    /// Handle mouse move. Returns true if state changed (needs redraw).
 +    pub fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let old_minus = self.hover_minus;
 +        let old_plus = self.hover_plus;
 +        self.hover_minus = point_in_rect(x, y, self.minus_bounds());
 +        self.hover_plus = point_in_rect(x, y, self.plus_bounds());
 +        old_minus != self.hover_minus || old_plus != self.hover_plus
 +    }
++
 +    /// Handle mouse click
 +    pub fn on_click(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if self.state == WidgetState::Disabled {
 +            return WidgetEvent::None;
 +        }
++
 +        if point_in_rect(x, y, self.minus_bounds()) {
 +            let new_value = (self.value - self.step).max(self.min);
 +            if new_value != self.value {
 +                self.value = new_value;
 +                return WidgetEvent::Changed;
 +            }
 +        } else if point_in_rect(x, y, self.plus_bounds()) {
 +            let new_value = (self.value + self.step).min(self.max);
 +            if new_value != self.value {
 +                self.value = new_value;
 +                return WidgetEvent::Changed;
 +            }
 +        }
++
 +        WidgetEvent::None
 +    }
++
 +    /// Render the number input
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        // Draw label
 +        let label_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        let label_y = self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(&self.label, self.bounds.x as f64, label_y as f64, &label_style)?;
++
 +        // Draw minus button
 +        let minus = self.minus_bounds();
 +        let minus_bg = if self.hover_minus {
 +            theme.item_hover_background
 +        } else {
 +            theme.input_background
 +        };
 +        renderer.fill_rounded_rect(minus, 4.0, minus_bg)?;
 +        renderer.stroke_rounded_rect(minus, 4.0, theme.border, 1.0)?;
++
 +        let minus_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(if self.value <= self.min {
 +                theme.item_description
 +            } else {
 +                theme.foreground
 +            });
 +        let minus_x = minus.x + (minus.width as i32 - 8) / 2;
 +        let minus_y = minus.y + (minus.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text("-", minus_x as f64, minus_y as f64, &minus_style)?;
++
 +        // Draw value
 +        let value_rect = self.value_bounds();
 +        renderer.fill_rounded_rect(value_rect, 4.0, theme.input_background)?;
++
 +        let value_text = self.value.to_string();
 +        let value_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
 +        let value_size = renderer.measure_text(&value_text, &value_style)?;
 +        let value_x = value_rect.x + (value_rect.width as i32 - value_size.width as i32) / 2;
 +        let value_y = value_rect.y + (value_rect.height as i32 - value_size.height as i32) / 2;
 +        renderer.text(&value_text, value_x as f64, value_y as f64, &value_style)?;
++
 +        // Draw plus button
 +        let plus = self.plus_bounds();
 +        let plus_bg = if self.hover_plus {
 +            theme.item_hover_background
 +        } else {
 +            theme.input_background
 +        };
 +        renderer.fill_rounded_rect(plus, 4.0, plus_bg)?;
 +        renderer.stroke_rounded_rect(plus, 4.0, theme.border, 1.0)?;
++
 +        let plus_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(if self.value >= self.max {
 +                theme.item_description
 +            } else {
 +                theme.foreground
 +            });
 +        let plus_x = plus.x + (plus.width as i32 - 8) / 2;
 +        let plus_y = plus.y + (plus.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text("+", plus_x as f64, plus_y as f64, &plus_style)?;
++
 +        Ok(())
 +    }
 +}

gargears/src/ui/widgets/section.rsadded

 +//! Section widget for grouping settings
++
 +use super::{point_in_rect, WidgetEvent};
 +use anyhow::Result;
 +use gartk_core::{Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// A collapsible section header
 +pub struct Section {
 +    pub title: String,
 +    pub expanded: bool,
 +    pub bounds: Rect,
 +    hovered: bool,
 +}
++
 +impl Section {
 +    /// Create a new section
 +    pub fn new(title: impl Into<String>) -> Self {
 +        Self {
 +            title: title.into(),
 +            expanded: true,
 +            bounds: Rect::new(0, 0, 200, 32),
 +            hovered: false,
 +        }
 +    }
++
 +    /// Handle mouse move. Returns true if state changed (needs redraw).
 +    pub fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        let was_hovered = self.hovered;
 +        self.hovered = point_in_rect(x, y, self.bounds);
 +        was_hovered != self.hovered
 +    }
++
 +    /// Handle mouse click
 +    pub fn on_click(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if point_in_rect(x, y, self.bounds) {
 +            self.expanded = !self.expanded;
 +            WidgetEvent::Changed
 +        } else {
 +            WidgetEvent::None
 +        }
 +    }
++
 +    /// Render the section header
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        // Draw background on hover
 +        if self.hovered {
 +            renderer.fill_rounded_rect(self.bounds, 4.0, theme.item_hover_background)?;
 +        }
++
 +        // Draw expand/collapse indicator
 +        let indicator = if self.expanded { "▼" } else { "▶" };
 +        let indicator_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size * 0.75)
 +            .color(theme.item_description);
++
 +        let indicator_y = self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(
 +            indicator,
 +            (self.bounds.x + 4) as f64,
 +            indicator_y as f64,
 +            &indicator_style,
 +        )?;
++
 +        // Draw title
 +        let title_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        renderer.text(
 +            &self.title,
 +            (self.bounds.x + 20) as f64,
 +            indicator_y as f64,
 +            &title_style,
 +        )?;
++
 +        // Draw separator line
 +        let line_y = self.bounds.y + self.bounds.height as i32 - 1;
 +        renderer.fill_rect(
 +            Rect::new(self.bounds.x, line_y, self.bounds.width, 1),
 +            theme.border,
 +        )?;
++
 +        Ok(())
 +    }
 +}

gargears/src/ui/widgets/slider.rsadded

 +//! Slider widget for numeric value selection
++
 +use super::{point_in_rect, WidgetEvent, WidgetState};
 +use anyhow::Result;
 +use gartk_core::{Color, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Slider track height
 +const TRACK_HEIGHT: u32 = 6;
 +/// Slider knob radius
 +const KNOB_RADIUS: f64 = 8.0;
 +/// Widget height
 +const SLIDER_HEIGHT: u32 = 32;
++
 +/// A slider widget for selecting numeric values
 +pub struct Slider {
 +    pub label: String,
 +    pub value: f64,
 +    pub min: f64,
 +    pub max: f64,
 +    pub step: f64,
 +    pub bounds: Rect,
 +    pub state: WidgetState,
 +    pub show_value: bool,
 +    dragging: bool,
 +}
++
 +impl Slider {
 +    /// Create a new slider
 +    pub fn new(label: impl Into<String>, min: f64, max: f64) -> Self {
 +        Self {
 +            label: label.into(),
 +            value: min,
 +            min,
 +            max,
 +            step: 1.0,
 +            bounds: Rect::new(0, 0, 300, SLIDER_HEIGHT),
 +            state: WidgetState::Normal,
 +            show_value: true,
 +            dragging: false,
 +        }
 +    }
++
 +    /// Set initial value
 +    pub fn with_value(mut self, value: f64) -> Self {
 +        self.value = value.clamp(self.min, self.max);
 +        self
 +    }
++
 +    /// Set step size
 +    pub fn with_step(mut self, step: f64) -> Self {
 +        self.step = step;
 +        self
 +    }
++
 +    /// Enable/disable value display
 +    pub fn with_show_value(mut self, show: bool) -> Self {
 +        self.show_value = show;
 +        self
 +    }
++
 +    /// Set the value
 +    pub fn set_value(&mut self, value: f64) {
 +        self.value = value.clamp(self.min, self.max);
 +    }
++
 +    /// Get value as integer
 +    pub fn value_i32(&self) -> i32 {
 +        self.value.round() as i32
 +    }
++
 +    /// Get track bounds (the slidable area)
 +    fn track_bounds(&self) -> Rect {
 +        let label_width = self.bounds.width / 3;
 +        let value_width = if self.show_value { 50 } else { 0 };
 +        let track_width = self.bounds.width - label_width - value_width - 20;
++
 +        let track_y = self.bounds.y + (SLIDER_HEIGHT as i32 - TRACK_HEIGHT as i32) / 2;
 +        Rect::new(
 +            self.bounds.x + label_width as i32,
 +            track_y,
 +            track_width,
 +            TRACK_HEIGHT,
 +        )
 +    }
++
 +    /// Get knob position (x coordinate)
 +    fn knob_x(&self) -> f64 {
 +        let track = self.track_bounds();
 +        let ratio = (self.value - self.min) / (self.max - self.min);
 +        track.x as f64 + (ratio * (track.width as f64 - KNOB_RADIUS * 2.0)) + KNOB_RADIUS
 +    }
++
 +    /// Get knob y coordinate
 +    fn knob_y(&self) -> f64 {
 +        let track = self.track_bounds();
 +        track.y as f64 + TRACK_HEIGHT as f64 / 2.0
 +    }
++
 +    /// Check if point is on/near the knob
 +    fn point_on_knob(&self, x: i32, y: i32) -> bool {
 +        let knob_x = self.knob_x();
 +        let knob_y = self.knob_y();
 +        let dx = x as f64 - knob_x;
 +        let dy = y as f64 - knob_y;
 +        (dx * dx + dy * dy).sqrt() <= KNOB_RADIUS + 4.0
 +    }
++
 +    /// Convert x position to value
 +    fn x_to_value(&self, x: i32) -> f64 {
 +        let track = self.track_bounds();
 +        let track_start = track.x as f64 + KNOB_RADIUS;
 +        let track_end = track.x as f64 + track.width as f64 - KNOB_RADIUS;
 +        let ratio = ((x as f64 - track_start) / (track_end - track_start)).clamp(0.0, 1.0);
 +        let raw_value = self.min + ratio * (self.max - self.min);
++
 +        // Snap to step
 +        if self.step > 0.0 {
 +            let steps = ((raw_value - self.min) / self.step).round();
 +            (self.min + steps * self.step).clamp(self.min, self.max)
 +        } else {
 +            raw_value.clamp(self.min, self.max)
 +        }
 +    }
++
 +    /// Handle mouse move
 +    pub fn on_mouse_move(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if self.state == WidgetState::Disabled {
 +            return WidgetEvent::None;
 +        }
++
 +        if self.dragging {
 +            let new_value = self.x_to_value(x);
 +            if (new_value - self.value).abs() > f64::EPSILON {
 +                self.value = new_value;
 +                return WidgetEvent::Changed;
 +            }
 +        } else {
 +            let track = self.track_bounds();
 +            if self.point_on_knob(x, y) || point_in_rect(x, y, track) {
 +                self.state = WidgetState::Hovered;
 +            } else {
 +                self.state = WidgetState::Normal;
 +            }
 +        }
++
 +        WidgetEvent::None
 +    }
++
 +    /// Handle mouse down
 +    pub fn on_mouse_down(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if self.state == WidgetState::Disabled {
 +            return WidgetEvent::None;
 +        }
++
 +        let track = self.track_bounds();
 +        if self.point_on_knob(x, y) {
 +            self.dragging = true;
 +            self.state = WidgetState::Focused;
 +            return WidgetEvent::Focus;
 +        } else if point_in_rect(x, y, track) {
 +            // Click on track moves knob to that position
 +            self.dragging = true;
 +            self.state = WidgetState::Focused;
 +            let new_value = self.x_to_value(x);
 +            if (new_value - self.value).abs() > f64::EPSILON {
 +                self.value = new_value;
 +                return WidgetEvent::Changed;
 +            }
 +            return WidgetEvent::Focus;
 +        }
++
 +        WidgetEvent::None
 +    }
++
 +    /// Handle mouse up
 +    pub fn on_mouse_up(&mut self) -> WidgetEvent {
 +        if self.dragging {
 +            self.dragging = false;
 +            self.state = WidgetState::Normal;
 +            return WidgetEvent::Blur;
 +        }
 +        WidgetEvent::None
 +    }
++
 +    /// Check if currently dragging
 +    pub fn is_dragging(&self) -> bool {
 +        self.dragging
 +    }
++
 +    /// Render the slider
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        // Draw label
 +        let label_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        let label_y = self.bounds.y + (SLIDER_HEIGHT as i32 - theme.font_size as i32) / 2;
 +        renderer.text(&self.label, self.bounds.x as f64, label_y as f64, &label_style)?;
++
 +        // Draw track
 +        let track = self.track_bounds();
++
 +        // Track background
 +        let track_bg = Rect::new(
 +            track.x,
 +            track.y,
 +            track.width,
 +            TRACK_HEIGHT,
 +        );
 +        renderer.fill_rounded_rect(track_bg, TRACK_HEIGHT as f64 / 2.0, theme.input_background)?;
++
 +        // Filled portion
 +        let knob_x = self.knob_x();
 +        let filled_width = (knob_x - track.x as f64) as u32;
 +        if filled_width > 0 {
 +            let filled = Rect::new(track.x, track.y, filled_width.min(track.width), TRACK_HEIGHT);
 +            renderer.fill_rounded_rect(filled, TRACK_HEIGHT as f64 / 2.0, theme.item_selected_background)?;
 +        }
++
 +        // Draw knob
 +        let knob_color = match self.state {
 +            WidgetState::Hovered | WidgetState::Focused => Color::from_u8(0xff, 0xff, 0xff, 0xff),
 +            _ => Color::from_u8(0xea, 0xea, 0xea, 0xff),
 +        };
++
 +        renderer.fill_circle(knob_x, self.knob_y(), KNOB_RADIUS, knob_color)?;
++
 +        // Draw subtle shadow around knob using a slightly larger semi-transparent circle
 +        renderer.fill_circle(
 +            knob_x,
 +            self.knob_y(),
 +            KNOB_RADIUS + 1.0,
 +            Color::from_u8(0x00, 0x00, 0x00, 0x20),
 +        )?;
 +        // Redraw knob on top
 +        renderer.fill_circle(knob_x, self.knob_y(), KNOB_RADIUS, knob_color)?;
++
 +        // Draw value
 +        if self.show_value {
 +            let value_text = if self.step >= 1.0 {
 +                format!("{}", self.value as i32)
 +            } else {
 +                format!("{:.1}", self.value)
 +            };
++
 +            let value_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size * 0.9)
 +                .color(theme.foreground);
++
 +            let value_x = track.x + track.width as i32 + 10;
 +            renderer.text(&value_text, value_x as f64, label_y as f64, &value_style)?;
 +        }
++
 +        Ok(())
 +    }
 +}

gargears/src/ui/widgets/text_input.rsadded

 +//! Text input widget
++
 +use super::{point_in_rect, WidgetEvent, WidgetState};
 +use anyhow::Result;
 +use gartk_core::{Key, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// A text input field
 +pub struct TextInput {
 +    pub label: String,
 +    pub value: String,
 +    pub placeholder: String,
 +    pub bounds: Rect,
 +    pub state: WidgetState,
 +    pub cursor: usize,
 +}
++
 +impl TextInput {
 +    /// Create a new text input
 +    pub fn new(label: impl Into<String>, value: impl Into<String>) -> Self {
 +        let value = value.into();
 +        let cursor = value.len();
 +        Self {
 +            label: label.into(),
 +            value,
 +            placeholder: String::new(),
 +            bounds: Rect::new(0, 0, 250, 28),
 +            state: WidgetState::Normal,
 +            cursor,
 +        }
 +    }
++
 +    /// Set placeholder text
 +    pub fn with_placeholder(mut self, placeholder: impl Into<String>) -> Self {
 +        self.placeholder = placeholder.into();
 +        self
 +    }
++
 +    /// Get input field bounds
 +    fn input_bounds(&self) -> Rect {
 +        let input_width = 150;
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 - input_width,
 +            self.bounds.y,
 +            input_width as u32,
 +            self.bounds.height,
 +        )
 +    }
++
 +    /// Handle mouse move. Returns true if state changed (needs redraw).
 +    pub fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        if self.state == WidgetState::Disabled || self.state == WidgetState::Focused {
 +            return false;
 +        }
 +        let old_state = self.state;
 +        if point_in_rect(x, y, self.input_bounds()) {
 +            self.state = WidgetState::Hovered;
 +        } else {
 +            self.state = WidgetState::Normal;
 +        }
 +        old_state != self.state
 +    }
++
 +    /// Handle mouse click
 +    pub fn on_click(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if self.state != WidgetState::Disabled && point_in_rect(x, y, self.input_bounds()) {
 +            self.state = WidgetState::Focused;
 +            WidgetEvent::Focus
 +        } else if self.state == WidgetState::Focused {
 +            self.state = WidgetState::Normal;
 +            WidgetEvent::Blur
 +        } else {
 +            WidgetEvent::None
 +        }
 +    }
++
 +    /// Handle key press (only when focused)
 +    pub fn on_key(&mut self, key: &Key) -> WidgetEvent {
 +        if self.state != WidgetState::Focused {
 +            return WidgetEvent::None;
 +        }
++
 +        match key {
 +            Key::Char(c) => {
 +                self.value.insert(self.cursor, *c);
 +                self.cursor += 1;
 +                WidgetEvent::Changed
 +            }
 +            Key::Space => {
 +                self.value.insert(self.cursor, ' ');
 +                self.cursor += 1;
 +                WidgetEvent::Changed
 +            }
 +            Key::Backspace => {
 +                if self.cursor > 0 {
 +                    self.value.remove(self.cursor - 1);
 +                    self.cursor -= 1;
 +                    WidgetEvent::Changed
 +                } else {
 +                    WidgetEvent::None
 +                }
 +            }
 +            Key::Delete => {
 +                if self.cursor < self.value.len() {
 +                    self.value.remove(self.cursor);
 +                    WidgetEvent::Changed
 +                } else {
 +                    WidgetEvent::None
 +                }
 +            }
 +            Key::Left => {
 +                if self.cursor > 0 {
 +                    self.cursor -= 1;
 +                }
 +                WidgetEvent::None
 +            }
 +            Key::Right => {
 +                if self.cursor < self.value.len() {
 +                    self.cursor += 1;
 +                }
 +                WidgetEvent::None
 +            }
 +            Key::Home => {
 +                self.cursor = 0;
 +                WidgetEvent::None
 +            }
 +            Key::End => {
 +                self.cursor = self.value.len();
 +                WidgetEvent::None
 +            }
 +            Key::Escape | Key::Return => {
 +                self.state = WidgetState::Normal;
 +                WidgetEvent::Blur
 +            }
 +            _ => WidgetEvent::None,
 +        }
 +    }
++
 +    /// Render the text input
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        // Draw label
 +        let label_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        let label_y = self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(&self.label, self.bounds.x as f64, label_y as f64, &label_style)?;
++
 +        // Draw input field
 +        let input = self.input_bounds();
++
 +        let bg_color = match self.state {
 +            WidgetState::Focused => theme.input_background,
 +            WidgetState::Hovered => theme.item_hover_background,
 +            _ => theme.input_background,
 +        };
++
 +        renderer.fill_rounded_rect(input, 4.0, bg_color)?;
++
 +        let border_color = if self.state == WidgetState::Focused {
 +            theme.input_cursor
 +        } else {
 +            theme.border
 +        };
 +        renderer.stroke_rounded_rect(input, 4.0, border_color, 1.0)?;
++
 +        // Draw value or placeholder
 +        let display_text = if self.value.is_empty() {
 +            &self.placeholder
 +        } else {
 +            &self.value
 +        };
++
 +        let text_color = if self.value.is_empty() {
 +            theme.input_placeholder
 +        } else {
 +            theme.input_foreground
 +        };
++
 +        let text_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(text_color)
 +            .ellipsize(true)
 +            .max_width(input.width as i32 - 12);
++
 +        let text_x = input.x + 6;
 +        let text_y = input.y + (input.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(display_text, text_x as f64, text_y as f64, &text_style)?;
++
 +        // Draw cursor if focused
 +        if self.state == WidgetState::Focused {
 +            let cursor_text = &self.value[..self.cursor];
 +            let cursor_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size);
 +            let cursor_size = renderer.measure_text(cursor_text, &cursor_style)?;
 +            let cursor_x = text_x + cursor_size.width as i32;
++
 +            renderer.fill_rect(
 +                Rect::new(cursor_x, input.y + 4, 2, input.height - 8),
 +                theme.input_cursor,
 +            )?;
 +        }
++
 +        Ok(())
 +    }
 +}

gargears/src/ui/widgets/toggle.rsadded

 +//! Toggle switch widget
++
 +use super::{point_in_rect, WidgetEvent, WidgetState};
 +use anyhow::Result;
 +use gartk_core::{Color, Rect, Theme};
 +use gartk_render::{Renderer, TextStyle};
++
 +/// Toggle width and height
 +const TOGGLE_WIDTH: u32 = 44;
 +const TOGGLE_HEIGHT: u32 = 24;
++
 +/// A toggle switch with label
 +pub struct Toggle {
 +    pub label: String,
 +    pub value: bool,
 +    pub bounds: Rect,
 +    pub state: WidgetState,
 +}
++
 +impl Toggle {
 +    /// Create a new toggle
 +    pub fn new(label: impl Into<String>, value: bool) -> Self {
 +        Self {
 +            label: label.into(),
 +            value,
 +            bounds: Rect::new(0, 0, 200, TOGGLE_HEIGHT),
 +            state: WidgetState::Normal,
 +        }
 +    }
++
 +    /// Get toggle switch bounds (the clickable part)
 +    fn switch_bounds(&self) -> Rect {
 +        Rect::new(
 +            self.bounds.x + self.bounds.width as i32 - TOGGLE_WIDTH as i32,
 +            self.bounds.y,
 +            TOGGLE_WIDTH,
 +            TOGGLE_HEIGHT,
 +        )
 +    }
++
 +    /// Handle mouse move. Returns true if state changed (needs redraw).
 +    pub fn on_mouse_move(&mut self, x: i32, y: i32) -> bool {
 +        if self.state == WidgetState::Disabled {
 +            return false;
 +        }
 +        let old_state = self.state;
 +        if point_in_rect(x, y, self.switch_bounds()) {
 +            self.state = WidgetState::Hovered;
 +        } else {
 +            self.state = WidgetState::Normal;
 +        }
 +        old_state != self.state
 +    }
++
 +    /// Handle mouse click
 +    pub fn on_click(&mut self, x: i32, y: i32) -> WidgetEvent {
 +        if self.state != WidgetState::Disabled && point_in_rect(x, y, self.switch_bounds()) {
 +            self.value = !self.value;
 +            WidgetEvent::Changed
 +        } else {
 +            WidgetEvent::None
 +        }
 +    }
++
 +    /// Render the toggle
 +    pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> Result<()> {
 +        // Draw label
 +        let label_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        let label_y = self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(&self.label, self.bounds.x as f64, label_y as f64, &label_style)?;
++
 +        // Draw toggle switch
 +        let switch = self.switch_bounds();
++
 +        // Track background
 +        let track_color = if self.value {
 +            Color::from_u8(0x50, 0xfa, 0x7b, 0xff) // Green when on
 +        } else {
 +            Color::from_u8(0x44, 0x47, 0x5a, 0xff) // Gray when off
 +        };
++
 +        renderer.fill_rounded_rect(switch, TOGGLE_HEIGHT as f64 / 2.0, track_color)?;
++
 +        // Knob
 +        let knob_padding = 2;
 +        let knob_size = TOGGLE_HEIGHT - (knob_padding * 2) as u32;
 +        let knob_x = if self.value {
 +            switch.x + switch.width as i32 - knob_size as i32 - knob_padding
 +        } else {
 +            switch.x + knob_padding
 +        };
++
 +        let knob_color = if self.state == WidgetState::Hovered {
 +            Color::from_u8(0xff, 0xff, 0xff, 0xff)
 +        } else {
 +            Color::from_u8(0xea, 0xea, 0xea, 0xff)
 +        };
++
 +        renderer.fill_circle(
 +            (knob_x + knob_size as i32 / 2) as f64,
 +            (switch.y + TOGGLE_HEIGHT as i32 / 2) as f64,
 +            knob_size as f64 / 2.0,
 +            knob_color,
 +        )?;
++
 +        Ok(())
 +    }
 +}

gargearsctl/Cargo.tomladded

 +[package]
 +name = "gargearsctl"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
 +authors.workspace = true
 +description = "CLI control utility for gargears"
++
 +[[bin]]
 +name = "gargearsctl"
 +path = "src/main.rs"
++
 +[dependencies]
 +gargears-ipc.workspace = true
++
 +clap.workspace = true
 +serde.workspace = true
 +serde_json.workspace = true
 +anyhow.workspace = true

gargearsctl/src/main.rsadded

 +//! CLI control utility for gargears daemon
++
 +use anyhow::{Context, Result};
 +use clap::{Parser, Subcommand};
 +use gargears_ipc::{socket_path, Command, Response};
 +use std::io::{BufRead, BufReader, Write};
 +use std::os::unix::net::UnixStream;
++
 +#[derive(Parser, Debug)]
 +#[command(name = "gargearsctl")]
 +#[command(about = "Control the gargears daemon")]
 +struct Args {
 +    #[command(subcommand)]
 +    command: CtlCommand,
 +}
++
 +#[derive(Subcommand, Debug)]
 +enum CtlCommand {
 +    /// Show the gargears window
 +    Show,
 +    /// Hide the gargears window
 +    Hide,
 +    /// Toggle gargears window visibility
 +    Toggle,
 +    /// Get daemon status
 +    Status,
 +    /// Quit the daemon
 +    Quit,
 +}
++
 +fn main() -> Result<()> {
 +    let args = Args::parse();
++
 +    let command = match args.command {
 +        CtlCommand::Show => Command::Show,
 +        CtlCommand::Hide => Command::Hide,
 +        CtlCommand::Toggle => Command::Toggle,
 +        CtlCommand::Status => Command::Status,
 +        CtlCommand::Quit => Command::Quit,
 +    };
++
 +    let response = send_command(&command)?;
++
 +    if response.success {
 +        if let Some(data) = response.data {
 +            println!("{}", serde_json::to_string_pretty(&data)?);
 +        } else {
 +            println!("OK");
 +        }
 +    } else {
 +        eprintln!("Error: {}", response.error.unwrap_or_else(|| "Unknown error".into()));
 +        std::process::exit(1);
 +    }
++
 +    Ok(())
 +}
++
 +fn send_command(command: &Command) -> Result<Response> {
 +    let path = socket_path();
++
 +    let mut stream = UnixStream::connect(&path)
 +        .with_context(|| format!("Failed to connect to gargears daemon at {:?}", path))?;
++
 +    // Send command
 +    let json = serde_json::to_string(command)?;
 +    writeln!(stream, "{}", json)?;
 +    stream.flush()?;
++
 +    // Read response
 +    let mut reader = BufReader::new(stream);
 +    let mut line = String::new();
 +    reader.read_line(&mut line)?;
++
 +    let response: Response = serde_json::from_str(&line)
 +        .with_context(|| "Failed to parse daemon response")?;
++
 +    Ok(response)
 +}