`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)
++}