gardesk/garshot / f669e50

+//! Eyedropper for sampling colors from the screen.

+

+use anyhow::{Context, Result};

+use gartk_core::{Color, Point};

+use gartk_x11::{Connection, CursorManager, CursorShape, Window, WindowConfig};

+use x11rb::connection::Connection as X11Connection;

+use x11rb::protocol::xproto::{self, ConnectionExt, ImageFormat};

+use x11rb::wrapper::ConnectionExt as WrapperConnectionExt;

+

+/// Eyedropper result.

+#[derive(Debug)]

+pub enum EyedropperResult {

+    /// User selected a color.

+    Color(Color),

+    /// User cancelled.

+    Cancel,

+}

+

+/// Eyedropper state for color sampling.

+pub struct Eyedropper {

+    /// X11 connection.

+    conn: Connection,

+    /// Overlay window (transparent, for capturing input).

+    window: Window,

+    /// Cursor manager.

+    cursor_manager: CursorManager,

+    /// Root window ID.

+    root: u32,

+    /// Current mouse position.

+    mouse_pos: Point,

+    /// Current sampled color.

+    current_color: Color,

+}

+

+impl Eyedropper {

+    /// Create a new eyedropper.

+    pub fn new() -> Result<Self> {

+        let conn = Connection::connect(None).context("Failed to connect to X11")?;

+

+        let screen_width = conn.screen_width() as u32;

+        let screen_height = conn.screen_height() as u32;

+        let root = conn.inner().setup().roots[conn.screen_num()].root;

+

+        // Create fullscreen transparent overlay to grab input

+        let config = WindowConfig::new()

+            .override_redirect(true)

+            .size(screen_width, screen_height)

+            .position(0, 0)

+            .map_on_create(false);

+

+        let window = Window::create(conn.clone(), config).context("Failed to create window")?;

+

+        // Make window transparent (input only)

+        // We'll set _NET_WM_WINDOW_OPACITY to 0

+        let opacity_atom = conn.inner()

+            .intern_atom(false, b"_NET_WM_WINDOW_OPACITY")?

+            .reply()

+            .context("Failed to intern opacity atom")?

+            .atom;

+

+        conn.inner().change_property32(

+            xproto::PropMode::REPLACE,

+            window.id(),

+            opacity_atom,

+            xproto::AtomEnum::CARDINAL,

+            &[0], // Fully transparent

+        )?;

+

+        let cursor_manager = CursorManager::new(conn.clone())

+            .context("Failed to create cursor manager")?;

+

+        Ok(Self {

+            conn,

+            window,

+            cursor_manager,

+            root,

+            mouse_pos: Point::new(0, 0),

+            current_color: Color::BLACK,

+        })

+    }

+

+    /// Run the eyedropper and return the selected color.

+    pub fn run(mut self) -> Result<EyedropperResult> {

+        // Map window and grab pointer

+        self.window.map()?;

+        self.conn.inner().flush()?;

+

+        // Set crosshair cursor

+        self.cursor_manager.set_window_cursor(self.window.id(), CursorShape::Crosshair)?;

+

+        // Grab pointer

+        self.window.grab_pointer()?;

+        self.window.grab_keyboard_with_retry(10, 50)?;

+

+        // Event loop

+        loop {

+            let event = self.conn.inner().wait_for_event()?;

+

+            match event {

+                x11rb::protocol::Event::ButtonPress(e) => {

+                    if e.detail == 1 {

+                        // Left click - sample color and confirm

+                        let color = self.sample_color(e.root_x as i32, e.root_y as i32)?;

+                        self.cleanup()?;

+                        return Ok(EyedropperResult::Color(color));

+                    } else if e.detail == 3 {

+                        // Right click - cancel

+                        self.cleanup()?;

+                        return Ok(EyedropperResult::Cancel);

+                    }

+                }

+                x11rb::protocol::Event::MotionNotify(e) => {

+                    self.mouse_pos = Point::new(e.root_x as i32, e.root_y as i32);

+                    // Sample color at current position (for preview if we add one)

+                    self.current_color = self.sample_color(e.root_x as i32, e.root_y as i32)?;

+                }

+                x11rb::protocol::Event::KeyPress(e) => {

+                    // Escape to cancel

+                    if e.detail == 9 {

+                        self.cleanup()?;

+                        return Ok(EyedropperResult::Cancel);

+                    }

+                    // Enter to confirm current color

+                    if e.detail == 36 || e.detail == 104 {

+                        self.cleanup()?;

+                        return Ok(EyedropperResult::Color(self.current_color));

+                    }

+                }

+                _ => {}

+            }

+        }

+    }

+

+    /// Sample the color at the given screen coordinates.

+    fn sample_color(&self, x: i32, y: i32) -> Result<Color> {

+        // Get 1x1 pixel from root window

+        let reply = self.conn.inner()

+            .get_image(

+                ImageFormat::Z_PIXMAP,

+                self.root,

+                x as i16,

+                y as i16,

+                1,

+                1,

+                !0, // All planes

+            )?

+            .reply()

+            .context("Failed to get image")?;

+

+        // Parse the pixel data (format depends on depth, assume 24/32 bit)

+        let data = reply.data;

+        if data.len() >= 3 {

+            // Assume BGRA or BGR format (X11 native)

+            let b = data[0];

+            let g = data[1];

+            let r = data[2];

+            let a = if data.len() >= 4 { data[3] } else { 255 };

+

+            Ok(Color::from_u8(r, g, b, a))

+        } else {

+            Ok(Color::BLACK)

+        }

+    }

+

+    /// Cleanup resources.

+    fn cleanup(&mut self) -> Result<()> {

+        self.window.ungrab_keyboard()?;

+        self.window.ungrab_pointer()?;

+        Ok(())

+    }

+}

+//! HSV color wheel tab.

+

+use std::f64::consts::PI;

+

+use gartk_core::{Color, Point, Rect};

+use gartk_render::set_color;

+

+use super::DragTarget;

+

+/// Outer radius of the hue ring.

+const HUE_RING_OUTER: f64 = 100.0;

+

+/// Inner radius of the hue ring (SV square fits inside).

+const HUE_RING_INNER: f64 = 70.0;

+

+/// SV square size (fits inside the hue ring).

+const SV_SQUARE_SIZE: f64 = 90.0;

+

+/// Handle mouse press in HSV tab.

+pub fn handle_press(local_pos: Point, hsv: &mut (f64, f64, f64)) -> Option<DragTarget> {

+    let center = content_center();

+    let dx = local_pos.x as f64 - center.0;

+    let dy = local_pos.y as f64 - center.1;

+    let dist = (dx * dx + dy * dy).sqrt();

+

+    // Check if in hue ring

+    if dist >= HUE_RING_INNER && dist <= HUE_RING_OUTER {

+        // Update hue based on angle

+        let angle = dy.atan2(dx);

+        let hue = ((angle * 180.0 / PI) + 90.0 + 360.0) % 360.0;

+        hsv.0 = hue;

+        return Some(DragTarget::HueRing);

+    }

+

+    // Check if in SV square

+    let sv_rect = sv_square_rect();

+    if sv_rect.contains_point(local_pos) {

+        let s = ((local_pos.x - sv_rect.x) as f64 / sv_rect.width as f64).clamp(0.0, 1.0);

+        let v = 1.0 - ((local_pos.y - sv_rect.y) as f64 / sv_rect.height as f64).clamp(0.0, 1.0);

+        hsv.1 = s;

+        hsv.2 = v;

+        return Some(DragTarget::SvSquare);

+    }

+

+    None

+}

+

+/// Handle mouse drag in HSV tab.

+pub fn handle_drag(local_pos: Point, target: DragTarget, hsv: &mut (f64, f64, f64)) {

+    match target {

+        DragTarget::HueRing => {

+            let center = content_center();

+            let dx = local_pos.x as f64 - center.0;

+            let dy = local_pos.y as f64 - center.1;

+            let angle = dy.atan2(dx);

+            let hue = ((angle * 180.0 / PI) + 90.0 + 360.0) % 360.0;

+            hsv.0 = hue;

+        }

+        DragTarget::SvSquare => {

+            let sv_rect = sv_square_rect();

+            let s = ((local_pos.x - sv_rect.x) as f64 / sv_rect.width as f64).clamp(0.0, 1.0);

+            let v = 1.0 - ((local_pos.y - sv_rect.y) as f64 / sv_rect.height as f64).clamp(0.0, 1.0);

+            hsv.1 = s;

+            hsv.2 = v;

+        }

+        _ => {}

+    }

+}

+

+/// Get the center point for the color wheel.

+fn content_center() -> (f64, f64) {

+    // Content area starts at y=48 (TAB_HEIGHT + PADDING) and we center in available space

+    let cx = super::PICKER_WIDTH as f64 / 2.0;

+    let cy = 48.0 + 110.0; // Approximate center in content area

+    (cx, cy)

+}

+

+/// Get the SV square rect.

+fn sv_square_rect() -> Rect {

+    let (cx, cy) = content_center();

+    let half = SV_SQUARE_SIZE / 2.0;

+    Rect::new(

+        (cx - half) as i32,

+        (cy - half) as i32,

+        SV_SQUARE_SIZE as u32,

+        SV_SQUARE_SIZE as u32,

+    )

+}

+

+/// Draw the HSV tab content.

+pub fn draw(ctx: &cairo::Context, _content_rect: Rect, hsv: (f64, f64, f64)) -> anyhow::Result<()> {

+    let (cx, cy) = content_center();

+

+    // Draw hue ring

+    draw_hue_ring(ctx, cx, cy)?;

+

+    // Draw SV square

+    draw_sv_square(ctx, hsv.0)?;

+

+    // Draw hue indicator (small circle on ring)

+    let hue_angle = (hsv.0 - 90.0) * PI / 180.0;

+    let ring_mid = (HUE_RING_OUTER + HUE_RING_INNER) / 2.0;

+    let hue_x = cx + ring_mid * hue_angle.cos();

+    let hue_y = cy + ring_mid * hue_angle.sin();

+

+    ctx.set_line_width(2.0);

+    set_color(ctx, Color::WHITE);

+    ctx.arc(hue_x, hue_y, 6.0, 0.0, 2.0 * PI);

+    ctx.stroke()?;

+

+    set_color(ctx, Color::BLACK);

+    ctx.arc(hue_x, hue_y, 4.0, 0.0, 2.0 * PI);

+    ctx.stroke()?;

+

+    // Draw SV indicator (small circle in square)

+    let sv_rect = sv_square_rect();

+    let sv_x = sv_rect.x as f64 + hsv.1 * sv_rect.width as f64;

+    let sv_y = sv_rect.y as f64 + (1.0 - hsv.2) * sv_rect.height as f64;

+

+    ctx.set_line_width(2.0);

+    set_color(ctx, Color::WHITE);

+    ctx.arc(sv_x, sv_y, 6.0, 0.0, 2.0 * PI);

+    ctx.stroke()?;

+

+    set_color(ctx, Color::BLACK);

+    ctx.arc(sv_x, sv_y, 4.0, 0.0, 2.0 * PI);

+    ctx.stroke()?;

+

+    Ok(())

+}

+

+/// Draw the hue ring.

+fn draw_hue_ring(ctx: &cairo::Context, cx: f64, cy: f64) -> anyhow::Result<()> {

+    // Draw the hue ring using filled wedges (pie slices)

+    let segments = 360;

+    let segment_angle = 2.0 * PI / segments as f64;

+

+    for i in 0..segments {

+        let angle_start = (i as f64 * segment_angle) - PI / 2.0;

+        let angle_end = angle_start + segment_angle + 0.005; // Tiny overlap to prevent gaps

+

+        let hue = (i as f64 / segments as f64) * 360.0;

+        let color = Color::from_hsv(hue, 1.0, 1.0);

+        set_color(ctx, color);

+

+        // Draw a filled wedge between inner and outer radius

+        ctx.new_path();

+        ctx.arc(cx, cy, HUE_RING_OUTER, angle_start, angle_end);

+        ctx.arc_negative(cx, cy, HUE_RING_INNER, angle_end, angle_start);

+        ctx.close_path();

+        ctx.fill()?;

+    }

+

+    Ok(())

+}

+

+/// Draw the saturation/value square.

+fn draw_sv_square(ctx: &cairo::Context, hue: f64) -> anyhow::Result<()> {

+    let sv_rect = sv_square_rect();

+    let size = sv_rect.width as i32;

+

+    // Draw pixel by pixel for accurate gradient

+    // This is slow but accurate - could be optimized with gradients

+    for y in 0..size {

+        for x in 0..size {

+            let s = x as f64 / size as f64;

+            let v = 1.0 - (y as f64 / size as f64);

+            let color = Color::from_hsv(hue, s, v);

+            set_color(ctx, color);

+            ctx.rectangle(

+                (sv_rect.x + x) as f64,

+                (sv_rect.y + y) as f64,

+                1.0,

+                1.0,

+            );

+            ctx.fill()?;

+        }

+    }

+

+    // Draw border

+    set_color(ctx, Color::new(0.3, 0.3, 0.3, 1.0));

+    ctx.set_line_width(1.0);

+    ctx.rectangle(

+        sv_rect.x as f64,

+        sv_rect.y as f64,

+        sv_rect.width as f64,

+        sv_rect.height as f64,

+    );

+    ctx.stroke()?;

+

+    Ok(())

+}

+//! Color picker dialog for annotation tool selection.

+

+mod hsv_tab;

+mod palette_tab;

+mod rgb_tab;

+mod tabs;

+

+pub mod eyedropper;

+

+use gartk_core::{Color, InputEvent, Point, Rect};

+use gartk_render::Surface;

+

+pub use tabs::ColorPickerTab;

+

+/// Color picker dialog dimensions.

+pub const PICKER_WIDTH: u32 = 320;

+pub const PICKER_HEIGHT: u32 = 380;

+

+/// Tab bar height.

+const TAB_HEIGHT: u32 = 36;

+

+/// Button height.

+const BUTTON_HEIGHT: u32 = 32;

+

+/// Padding.

+const PADDING: u32 = 12;

+

+/// Result of color picker interaction.

+#[derive(Debug, Clone)]

+pub enum ColorPickerResult {

+    /// User confirmed color selection.

+    Confirm(Color),

+    /// User cancelled.

+    Cancel,

+    /// Start eyedropper mode.

+    StartEyedropper,

+    /// Color changed, needs redraw.

+    Changed,

+    /// No change, no redraw needed.

+    None,

+}

+

+/// What the user is currently dragging.

+#[derive(Debug, Clone, Copy, PartialEq, Eq)]

+enum DragTarget {

+    HueRing,

+    SvSquare,

+    RedSlider,

+    GreenSlider,

+    BlueSlider,

+    AlphaSlider,

+}

+

+/// Color picker dialog.

+pub struct ColorPicker {

+    /// Dialog bounds (position and size).

+    rect: Rect,

+    /// Current tab.

+    tab: ColorPickerTab,

+    /// HSV values (source of truth): hue 0-360, saturation 0-1, value 0-1.

+    hsv: (f64, f64, f64),

+    /// Alpha value 0-1.

+    alpha: f64,

+    /// Currently dragging target.

+    dragging: Option<DragTarget>,

+    /// Recent colors (max 8).

+    recent: Vec<Color>,

+    /// Original color (for cancel).

+    original: Color,

+    /// OK button rect.

+    ok_rect: Rect,

+    /// Cancel button rect.

+    cancel_rect: Rect,

+    /// Eyedropper button rect.

+    eyedropper_rect: Rect,

+}

+

+impl ColorPicker {

+    /// Create a new color picker dialog.

+    ///

+    /// # Arguments

+    /// * `initial_color` - The initial color to display

+    /// * `screen_width` - Screen width for centering

+    /// * `screen_height` - Screen height for centering

+    pub fn new(initial_color: Color, screen_width: u32, screen_height: u32) -> Self {

+        // Center the dialog on screen

+        let x = (screen_width as i32 - PICKER_WIDTH as i32) / 2;

+        let y = (screen_height as i32 - PICKER_HEIGHT as i32) / 2;

+

+        let rect = Rect::new(x, y, PICKER_WIDTH, PICKER_HEIGHT);

+

+        // Convert initial color to HSV

+        let hsv = initial_color.to_hsv();

+

+        // Calculate button positions (at bottom of dialog)

+        let button_y = PICKER_HEIGHT as i32 - BUTTON_HEIGHT as i32 - PADDING as i32;

+        let button_width = 80u32;

+        let cancel_x = PADDING as i32;

+        let ok_x = PICKER_WIDTH as i32 - button_width as i32 - PADDING as i32;

+

+        Self {

+            rect,

+            tab: ColorPickerTab::default(),

+            hsv,

+            alpha: initial_color.a,

+            dragging: None,

+            recent: Vec::new(),

+            original: initial_color,

+            ok_rect: Rect::new(ok_x, button_y, button_width, BUTTON_HEIGHT),

+            cancel_rect: Rect::new(cancel_x, button_y, button_width, BUTTON_HEIGHT),

+            eyedropper_rect: Rect::new(

+                (PICKER_WIDTH as i32 - 32) / 2,

+                button_y - 40,

+                32,

+                32,

+            ),

+        }

+    }

+

+    /// Get the current color.

+    pub fn current_color(&self) -> Color {

+        Color::from_hsva(self.hsv.0, self.hsv.1, self.hsv.2, self.alpha)

+    }

+

+    /// Set color from RGB.

+    pub fn set_color(&mut self, color: Color) {

+        self.hsv = color.to_hsv();

+        self.alpha = color.a;

+    }

+

+    /// Add a color to the recent colors list.

+    pub fn add_recent(&mut self, color: Color) {

+        // Remove if already present

+        self.recent.retain(|c| c != &color);

+        // Add to front

+        self.recent.insert(0, color);

+        // Keep only 8 recent colors

+        self.recent.truncate(8);

+    }

+

+    /// Get the dialog bounds.

+    pub fn rect(&self) -> Rect {

+        self.rect

+    }

+

+    /// Handle input event.

+    ///

+    /// Returns a result if the interaction is complete.

+    pub fn handle_event(&mut self, event: &InputEvent) -> ColorPickerResult {

+        match event {

+            InputEvent::MousePress(e) => {

+                let local = self.to_local(e.position);

+

+                // Check tab bar

+                if let Some(new_tab) = tabs::handle_click(local) {

+                    if new_tab != self.tab {

+                        self.tab = new_tab;

+                        return ColorPickerResult::Changed;

+                    }

+                    return ColorPickerResult::None;

+                }

+

+                // Check OK button

+                if self.ok_rect.contains_point(local) {

+                    let color = self.current_color();

+                    self.add_recent(color);

+                    return ColorPickerResult::Confirm(color);

+                }

+

+                // Check Cancel button

+                if self.cancel_rect.contains_point(local) {

+                    return ColorPickerResult::Cancel;

+                }

+

+                // Check eyedropper button

+                if self.eyedropper_rect.contains_point(local) {

+                    return ColorPickerResult::StartEyedropper;

+                }

+

+                // Handle tab-specific interactions

+                match self.tab {

+                    ColorPickerTab::Hsv => {

+                        if let Some(target) = hsv_tab::handle_press(local, &mut self.hsv) {

+                            self.dragging = Some(target);

+                            return ColorPickerResult::Changed;

+                        }

+                    }

+                    ColorPickerTab::Rgb => {

+                        if let Some(target) = rgb_tab::handle_press(local, &mut self.hsv, &mut self.alpha) {

+                            self.dragging = Some(target);

+                            return ColorPickerResult::Changed;

+                        }

+                    }

+                    ColorPickerTab::Palette => {

+                        if let Some(color) = palette_tab::handle_click(local, &self.recent) {

+                            self.set_color(color);

+                            return ColorPickerResult::Changed;

+                        }

+                    }

+                }

+            }

+

+            InputEvent::MouseRelease(_) => {

+                if self.dragging.is_some() {

+                    self.dragging = None;

+                    // No redraw needed on release

+                }

+            }

+

+            InputEvent::MouseMove(e) => {

+                if let Some(target) = self.dragging {

+                    let local = self.to_local(e.position);

+                    match target {

+                        DragTarget::HueRing | DragTarget::SvSquare => {

+                            hsv_tab::handle_drag(local, target, &mut self.hsv);

+                            return ColorPickerResult::Changed;

+                        }

+                        DragTarget::RedSlider

+                        | DragTarget::GreenSlider

+                        | DragTarget::BlueSlider

+                        | DragTarget::AlphaSlider => {

+                            rgb_tab::handle_drag(local, target, &mut self.hsv, &mut self.alpha);

+                            return ColorPickerResult::Changed;

+                        }

+                    }

+                }

+            }

+

+            InputEvent::Key(e) if e.pressed => {

+                use gartk_core::Key;

+                match e.key {

+                    Key::Return => {

+                        let color = self.current_color();

+                        self.add_recent(color);

+                        return ColorPickerResult::Confirm(color);

+                    }

+                    Key::Escape => {

+                        return ColorPickerResult::Cancel;

+                    }

+                    _ => {}

+                }

+            }

+

+            _ => {}

+        }

+

+        ColorPickerResult::None

+    }

+

+    /// Draw the color picker to a surface.

+    pub fn draw(&self, surface: &Surface) -> anyhow::Result<()> {

+        use gartk_render::{fill_rounded_rect, set_color, stroke_rounded_rect};

+

+        let ctx = surface.context()?;

+

+        // Draw background

+        let bg = Color::new(0.15, 0.15, 0.15, 1.0);

+        fill_rounded_rect(&ctx, Rect::new(0, 0, PICKER_WIDTH, PICKER_HEIGHT), 8.0, bg);

+

+        // Draw tabs

+        tabs::draw(&ctx, self.tab)?;

+

+        // Draw tab content

+        let content_rect = Rect::new(

+            PADDING as i32,

+            (TAB_HEIGHT + PADDING) as i32,

+            PICKER_WIDTH - PADDING * 2,

+            PICKER_HEIGHT - TAB_HEIGHT - BUTTON_HEIGHT - PADDING * 4 - 40,

+        );

+

+        match self.tab {

+            ColorPickerTab::Hsv => hsv_tab::draw(&ctx, content_rect, self.hsv)?,

+            ColorPickerTab::Rgb => rgb_tab::draw(&ctx, content_rect, self.hsv, self.alpha)?,

+            ColorPickerTab::Palette => palette_tab::draw(&ctx, content_rect, &self.recent)?,

+        }

+

+        // Draw color preview

+        let preview_rect = Rect::new(

+            PADDING as i32,

+            self.eyedropper_rect.y,

+            80,

+            32,

+        );

+        fill_rounded_rect(&ctx, preview_rect, 4.0, self.current_color());

+        stroke_rounded_rect(&ctx, preview_rect, 4.0, Color::WHITE, 1.0);

+

+        // Draw hex value

+        let hex = self.current_color().to_hex();

+        set_color(&ctx, Color::WHITE);

+        ctx.select_font_face("monospace", cairo::FontSlant::Normal, cairo::FontWeight::Normal);

+        ctx.set_font_size(12.0);

+        ctx.move_to(

+            (preview_rect.x + preview_rect.width as i32 + 8) as f64,

+            (preview_rect.y + 20) as f64,

+        );

+        ctx.show_text(&hex)?;

+

+        // Draw eyedropper button

+        fill_rounded_rect(&ctx, self.eyedropper_rect, 4.0, Color::new(0.25, 0.25, 0.25, 1.0));

+        stroke_rounded_rect(&ctx, self.eyedropper_rect, 4.0, Color::new(0.4, 0.4, 0.4, 1.0), 1.0);

+        // Draw eyedropper icon (simple crosshair)

+        set_color(&ctx, Color::WHITE);

+        let cx = self.eyedropper_rect.x as f64 + self.eyedropper_rect.width as f64 / 2.0;

+        let cy = self.eyedropper_rect.y as f64 + self.eyedropper_rect.height as f64 / 2.0;

+        ctx.set_line_width(2.0);

+        ctx.move_to(cx - 6.0, cy);

+        ctx.line_to(cx + 6.0, cy);

+        ctx.move_to(cx, cy - 6.0);

+        ctx.line_to(cx, cy + 6.0);

+        ctx.stroke()?;

+

+        // Draw buttons

+        self.draw_button(&ctx, self.cancel_rect, "Cancel", false)?;

+        self.draw_button(&ctx, self.ok_rect, "OK", true)?;

+

+        Ok(())

+    }

+

+    /// Draw a button.

+    fn draw_button(

+        &self,

+        ctx: &cairo::Context,

+        rect: Rect,

+        label: &str,

+        primary: bool,

+    ) -> anyhow::Result<()> {

+        use gartk_render::{fill_rounded_rect, set_color, stroke_rounded_rect};

+

+        let bg = if primary {

+            Color::new(0.2, 0.5, 0.9, 1.0)

+        } else {

+            Color::new(0.3, 0.3, 0.3, 1.0)

+        };

+

+        fill_rounded_rect(ctx, rect, 4.0, bg);

+        stroke_rounded_rect(ctx, rect, 4.0, bg.lighten(0.2), 1.0);

+

+        set_color(ctx, Color::WHITE);

+        ctx.select_font_face("sans-serif", cairo::FontSlant::Normal, cairo::FontWeight::Bold);

+        ctx.set_font_size(13.0);

+

+        let extents = ctx.text_extents(label)?;

+        let text_x = rect.x as f64 + (rect.width as f64 - extents.width()) / 2.0;

+        let text_y = rect.y as f64 + (rect.height as f64 + extents.height()) / 2.0;

+

+        ctx.move_to(text_x, text_y);

+        ctx.show_text(label)?;

+

+        Ok(())

+    }

+

+    /// Convert screen position to local position within dialog.

+    fn to_local(&self, pos: Point) -> Point {

+        Point::new(pos.x - self.rect.x, pos.y - self.rect.y)

+    }

+}

+//! Color palette tab.

+

+use gartk_core::{Color, Point, Rect};

+use gartk_render::{fill_rounded_rect, set_color, stroke_rounded_rect};

+

+use super::{PADDING, PICKER_WIDTH};

+

+/// Color swatch size.

+const SWATCH_SIZE: u32 = 28;

+

+/// Swatch spacing.

+const SWATCH_SPACING: u32 = 4;

+

+/// Number of columns in the palette grid.

+const COLUMNS: usize = 9;

+

+/// Preset colors (matching the 1-9 keyboard shortcuts).

+const PRESET_COLORS: [Color; 9] = [

+    Color::new(1.0, 0.4, 0.0, 1.0),   // 1: Orange (default)

+    Color::new(1.0, 0.0, 0.0, 1.0),   // 2: Red

+    Color::new(0.0, 1.0, 0.0, 1.0),   // 3: Green

+    Color::new(0.0, 0.5, 1.0, 1.0),   // 4: Blue

+    Color::new(1.0, 1.0, 0.0, 1.0),   // 5: Yellow

+    Color::new(1.0, 0.0, 1.0, 1.0),   // 6: Magenta

+    Color::new(0.0, 1.0, 1.0, 1.0),   // 7: Cyan

+    Color::new(1.0, 1.0, 1.0, 1.0),   // 8: White

+    Color::new(0.0, 0.0, 0.0, 1.0),   // 9: Black

+];

+

+/// Extended palette colors.

+const EXTENDED_PALETTE: [Color; 36] = [

+    // Row 1: Reds

+    Color::new(1.0, 0.8, 0.8, 1.0),

+    Color::new(1.0, 0.6, 0.6, 1.0),

+    Color::new(1.0, 0.4, 0.4, 1.0),

+    Color::new(1.0, 0.2, 0.2, 1.0),

+    Color::new(0.8, 0.0, 0.0, 1.0),

+    Color::new(0.6, 0.0, 0.0, 1.0),

+    Color::new(0.4, 0.0, 0.0, 1.0),

+    Color::new(0.3, 0.0, 0.0, 1.0),

+    Color::new(0.2, 0.0, 0.0, 1.0),

+    // Row 2: Oranges/Yellows

+    Color::new(1.0, 0.9, 0.7, 1.0),

+    Color::new(1.0, 0.8, 0.4, 1.0),

+    Color::new(1.0, 0.6, 0.2, 1.0),

+    Color::new(1.0, 0.5, 0.0, 1.0),

+    Color::new(0.9, 0.7, 0.0, 1.0),

+    Color::new(0.8, 0.8, 0.0, 1.0),

+    Color::new(0.6, 0.6, 0.0, 1.0),

+    Color::new(0.4, 0.4, 0.0, 1.0),

+    Color::new(0.3, 0.3, 0.0, 1.0),

+    // Row 3: Greens

+    Color::new(0.8, 1.0, 0.8, 1.0),

+    Color::new(0.6, 1.0, 0.6, 1.0),

+    Color::new(0.4, 1.0, 0.4, 1.0),

+    Color::new(0.0, 0.9, 0.0, 1.0),

+    Color::new(0.0, 0.7, 0.0, 1.0),

+    Color::new(0.0, 0.5, 0.0, 1.0),

+    Color::new(0.0, 0.4, 0.0, 1.0),

+    Color::new(0.0, 0.3, 0.0, 1.0),

+    Color::new(0.0, 0.2, 0.0, 1.0),

+    // Row 4: Blues/Purples

+    Color::new(0.8, 0.8, 1.0, 1.0),

+    Color::new(0.6, 0.6, 1.0, 1.0),

+    Color::new(0.4, 0.4, 1.0, 1.0),

+    Color::new(0.2, 0.2, 1.0, 1.0),

+    Color::new(0.0, 0.0, 0.8, 1.0),

+    Color::new(0.4, 0.0, 0.8, 1.0),

+    Color::new(0.6, 0.0, 0.8, 1.0),

+    Color::new(0.8, 0.0, 0.8, 1.0),

+    Color::new(0.4, 0.0, 0.4, 1.0),

+];

+

+/// Get the content rect for the palette tab.

+fn content_rect() -> Rect {

+    Rect::new(

+        PADDING as i32,

+        60, // After tab bar

+        PICKER_WIDTH - PADDING * 2,

+        250,

+    )

+}

+

+/// Get rect for a swatch at given row and column.

+fn swatch_rect(row: usize, col: usize, content: Rect) -> Rect {

+    Rect::new(

+        content.x + (col as i32 * (SWATCH_SIZE as i32 + SWATCH_SPACING as i32)),

+        content.y + (row as i32 * (SWATCH_SIZE as i32 + SWATCH_SPACING as i32)),

+        SWATCH_SIZE,

+        SWATCH_SIZE,

+    )

+}

+

+/// Handle click in palette tab.

+pub fn handle_click(local_pos: Point, recent: &[Color]) -> Option<Color> {

+    let content = content_rect();

+

+    // Check preset colors (row 0)

+    for (col, color) in PRESET_COLORS.iter().enumerate() {

+        let rect = swatch_rect(0, col, content);

+        if rect.contains_point(local_pos) {

+            return Some(*color);

+        }

+    }

+

+    // Check extended palette (rows 1-4)

+    for (i, color) in EXTENDED_PALETTE.iter().enumerate() {

+        let row = 2 + (i / COLUMNS);

+        let col = i % COLUMNS;

+        let rect = swatch_rect(row, col, content);

+        if rect.contains_point(local_pos) {

+            return Some(*color);

+        }

+    }

+

+    // Check recent colors (last row)

+    let recent_row = 7;

+    for (col, color) in recent.iter().enumerate().take(8) {

+        let rect = swatch_rect(recent_row, col, content);

+        if rect.contains_point(local_pos) {

+            return Some(*color);

+        }

+    }

+

+    None

+}

+

+/// Draw the palette tab content.

+pub fn draw(ctx: &cairo::Context, _content_rect: Rect, recent: &[Color]) -> anyhow::Result<()> {

+    let content = content_rect();

+

+    // Draw section label for presets

+    set_color(ctx, Color::new(0.7, 0.7, 0.7, 1.0));

+    ctx.select_font_face("sans-serif", cairo::FontSlant::Normal, cairo::FontWeight::Normal);

+    ctx.set_font_size(11.0);

+    ctx.move_to(content.x as f64, (content.y - 4) as f64);

+    ctx.show_text("Presets (1-9)")?;

+

+    // Draw preset colors

+    for (col, color) in PRESET_COLORS.iter().enumerate() {

+        let rect = swatch_rect(0, col, content);

+        draw_swatch(ctx, rect, *color)?;

+

+        // Draw key number

+        set_color(ctx, Color::WHITE);

+        ctx.set_font_size(10.0);

+        ctx.move_to((rect.x + 2) as f64, (rect.y + rect.height as i32 - 3) as f64);

+        ctx.show_text(&format!("{}", col + 1))?;

+    }

+

+    // Draw section label for extended palette

+    let extended_y = content.y + (SWATCH_SIZE as i32 + SWATCH_SPACING as i32) + 8;

+    set_color(ctx, Color::new(0.7, 0.7, 0.7, 1.0));

+    ctx.set_font_size(11.0);

+    ctx.move_to(content.x as f64, extended_y as f64);

+    ctx.show_text("Extended")?;

+

+    // Draw extended palette

+    for (i, color) in EXTENDED_PALETTE.iter().enumerate() {

+        let row = 2 + (i / COLUMNS);

+        let col = i % COLUMNS;

+        let rect = swatch_rect(row, col, content);

+        draw_swatch(ctx, rect, *color)?;

+    }

+

+    // Draw section label for recent colors

+    let recent_y = swatch_rect(6, 0, content).y + SWATCH_SIZE as i32 + 8;

+    set_color(ctx, Color::new(0.7, 0.7, 0.7, 1.0));

+    ctx.set_font_size(11.0);

+    ctx.move_to(content.x as f64, recent_y as f64);

+    ctx.show_text("Recent")?;

+

+    // Draw recent colors

+    let recent_row = 7;

+    for col in 0..8 {

+        let rect = swatch_rect(recent_row, col, content);

+        if col < recent.len() {

+            draw_swatch(ctx, rect, recent[col])?;

+        } else {

+            // Draw empty swatch placeholder

+            fill_rounded_rect(ctx, rect, 4.0, Color::new(0.2, 0.2, 0.2, 1.0));

+            stroke_rounded_rect(ctx, rect, 4.0, Color::new(0.3, 0.3, 0.3, 1.0), 1.0);

+        }

+    }

+

+    Ok(())

+}

+

+/// Draw a color swatch.

+fn draw_swatch(ctx: &cairo::Context, rect: Rect, color: Color) -> anyhow::Result<()> {

+    // Draw checkerboard for alpha

+    if color.a < 1.0 {

+        let check_size = 4.0;

+        for y in 0..((rect.height as f64 / check_size) as i32) {

+            for x in 0..((rect.width as f64 / check_size) as i32) {

+                let is_light = (x + y) % 2 == 0;

+                set_color(

+                    ctx,

+                    if is_light {

+                        Color::new(0.6, 0.6, 0.6, 1.0)

+                    } else {

+                        Color::new(0.4, 0.4, 0.4, 1.0)

+                    },

+                );

+                ctx.rectangle(

+                    rect.x as f64 + x as f64 * check_size,

+                    rect.y as f64 + y as f64 * check_size,

+                    check_size,

+                    check_size,

+                );

+                ctx.fill()?;

+            }

+        }

+    }

+

+    fill_rounded_rect(ctx, rect, 4.0, color);

+    stroke_rounded_rect(ctx, rect, 4.0, Color::new(0.4, 0.4, 0.4, 1.0), 1.0);

+

+    Ok(())

+}

+//! RGB sliders tab.

+

+use gartk_core::{Color, Point, Rect};

+use gartk_render::set_color;

+

+use super::{DragTarget, PADDING, PICKER_WIDTH};

+

+/// Slider height.

+const SLIDER_HEIGHT: u32 = 24;

+

+/// Slider spacing.

+const SLIDER_SPACING: u32 = 40;

+

+/// Label width.

+const LABEL_WIDTH: u32 = 30;

+

+/// Get the rect for a slider at given index.

+fn slider_rect(index: usize, content_rect: Rect) -> Rect {

+    let y = content_rect.y + (index as i32 * SLIDER_SPACING as i32);

+    Rect::new(

+        content_rect.x + LABEL_WIDTH as i32,

+        y,

+        content_rect.width - LABEL_WIDTH - 50, // Leave room for value text

+        SLIDER_HEIGHT,

+    )

+}

+

+/// Get the content rect for the RGB tab.

+fn content_rect() -> Rect {

+    Rect::new(

+        PADDING as i32,

+        60, // After tab bar

+        PICKER_WIDTH - PADDING * 2,

+        200,

+    )

+}

+

+/// Handle mouse press in RGB tab.

+pub fn handle_press(

+    local_pos: Point,

+    hsv: &mut (f64, f64, f64),

+    alpha: &mut f64,

+) -> Option<DragTarget> {

+    let content = content_rect();

+

+    // Check each slider

+    let sliders = [

+        DragTarget::RedSlider,

+        DragTarget::GreenSlider,

+        DragTarget::BlueSlider,

+        DragTarget::AlphaSlider,

+    ];

+

+    for (i, target) in sliders.iter().enumerate() {

+        let rect = slider_rect(i, content);

+        if rect.contains_point(local_pos) {

+            update_from_slider(local_pos, *target, rect, hsv, alpha);

+            return Some(*target);

+        }

+    }

+

+    None

+}

+

+/// Handle mouse drag in RGB tab.

+pub fn handle_drag(

+    local_pos: Point,

+    target: DragTarget,

+    hsv: &mut (f64, f64, f64),

+    alpha: &mut f64,

+) {

+    let content = content_rect();

+    let index = match target {

+        DragTarget::RedSlider => 0,

+        DragTarget::GreenSlider => 1,

+        DragTarget::BlueSlider => 2,

+        DragTarget::AlphaSlider => 3,

+        _ => return,

+    };

+    let rect = slider_rect(index, content);

+    update_from_slider(local_pos, target, rect, hsv, alpha);

+}

+

+/// Update color from slider position.

+fn update_from_slider(

+    local_pos: Point,

+    target: DragTarget,

+    rect: Rect,

+    hsv: &mut (f64, f64, f64),

+    alpha: &mut f64,

+) {

+    let value = ((local_pos.x - rect.x) as f64 / rect.width as f64).clamp(0.0, 1.0);

+

+    // Convert current HSV to RGB

+    let current = Color::from_hsva(hsv.0, hsv.1, hsv.2, *alpha);

+    let mut r = current.r;

+    let mut g = current.g;

+    let mut b = current.b;

+

+    match target {

+        DragTarget::RedSlider => r = value,

+        DragTarget::GreenSlider => g = value,

+        DragTarget::BlueSlider => b = value,

+        DragTarget::AlphaSlider => {

+            *alpha = value;

+            return;

+        }

+        _ => return,

+    }

+

+    // Convert back to HSV

+    let new_color = Color::new(r, g, b, *alpha);

+    *hsv = new_color.to_hsv();

+}

+

+/// Draw the RGB tab content.

+pub fn draw(

+    ctx: &cairo::Context,

+    _content_rect: Rect,

+    hsv: (f64, f64, f64),

+    alpha: f64,

+) -> anyhow::Result<()> {

+    let content = content_rect();

+    let current = Color::from_hsva(hsv.0, hsv.1, hsv.2, alpha);

+

+    let labels = ["R", "G", "B", "A"];

+    let values = [current.r, current.g, current.b, alpha];

+    let colors = [

+        (Color::RED, Color::new(0.2, 0.0, 0.0, 1.0)),

+        (Color::GREEN, Color::new(0.0, 0.2, 0.0, 1.0)),

+        (Color::BLUE, Color::new(0.0, 0.0, 0.2, 1.0)),

+        (Color::WHITE, Color::new(0.2, 0.2, 0.2, 1.0)),

+    ];

+

+    for (i, (label, value)) in labels.iter().zip(values.iter()).enumerate() {

+        let rect = slider_rect(i, content);

+        let (high_color, low_color) = colors[i];

+

+        // Draw label

+        set_color(ctx, Color::WHITE);

+        ctx.select_font_face("monospace", cairo::FontSlant::Normal, cairo::FontWeight::Bold);

+        ctx.set_font_size(14.0);

+        ctx.move_to(

+            (content.x + 4) as f64,

+            (rect.y + rect.height as i32 - 6) as f64,

+        );

+        ctx.show_text(label)?;

+

+        // Draw slider track with gradient

+        draw_slider_gradient(ctx, rect, low_color, high_color)?;

+

+        // Draw slider handle

+        let handle_x = rect.x as f64 + value * rect.width as f64;

+        draw_slider_handle(ctx, handle_x, rect.y as f64 + rect.height as f64 / 2.0)?;

+

+        // Draw value text

+        let value_text = format!("{}", (value * 255.0).round() as u8);

+        set_color(ctx, Color::new(0.8, 0.8, 0.8, 1.0));

+        ctx.set_font_size(12.0);

+        ctx.move_to(

+            (rect.x + rect.width as i32 + 8) as f64,

+            (rect.y + rect.height as i32 - 6) as f64,

+        );

+        ctx.show_text(&value_text)?;

+    }

+

+    Ok(())

+}

+

+/// Draw a slider gradient background.

+fn draw_slider_gradient(

+    ctx: &cairo::Context,

+    rect: Rect,

+    from: Color,

+    to: Color,

+) -> anyhow::Result<()> {

+    // Create horizontal linear gradient

+    let gradient = cairo::LinearGradient::new(

+        rect.x as f64,

+        rect.y as f64,

+        (rect.x + rect.width as i32) as f64,

+        rect.y as f64,

+    );

+    gradient.add_color_stop_rgba(0.0, from.r, from.g, from.b, from.a);

+    gradient.add_color_stop_rgba(1.0, to.r, to.g, to.b, to.a);

+

+    // Draw rounded rect with gradient

+    let radius = 4.0;

+    ctx.new_sub_path();

+    ctx.arc(

+        rect.x as f64 + rect.width as f64 - radius,

+        rect.y as f64 + radius,

+        radius,

+        -0.5 * std::f64::consts::PI,

+        0.0,

+    );

+    ctx.arc(

+        rect.x as f64 + rect.width as f64 - radius,

+        rect.y as f64 + rect.height as f64 - radius,

+        radius,

+        0.0,

+        0.5 * std::f64::consts::PI,

+    );

+    ctx.arc(

+        rect.x as f64 + radius,

+        rect.y as f64 + rect.height as f64 - radius,

+        radius,

+        0.5 * std::f64::consts::PI,

+        std::f64::consts::PI,

+    );

+    ctx.arc(

+        rect.x as f64 + radius,

+        rect.y as f64 + radius,

+        radius,

+        std::f64::consts::PI,

+        1.5 * std::f64::consts::PI,

+    );

+    ctx.close_path();

+

+    ctx.set_source(&gradient)?;

+    ctx.fill()?;

+

+    // Draw border

+    set_color(ctx, Color::new(0.4, 0.4, 0.4, 1.0));

+    ctx.set_line_width(1.0);

+    ctx.new_sub_path();

+    ctx.arc(

+        rect.x as f64 + rect.width as f64 - radius,

+        rect.y as f64 + radius,

+        radius,

+        -0.5 * std::f64::consts::PI,

+        0.0,

+    );

+    ctx.arc(

+        rect.x as f64 + rect.width as f64 - radius,

+        rect.y as f64 + rect.height as f64 - radius,

+        radius,

+        0.0,

+        0.5 * std::f64::consts::PI,

+    );

+    ctx.arc(

+        rect.x as f64 + radius,

+        rect.y as f64 + rect.height as f64 - radius,

+        radius,

+        0.5 * std::f64::consts::PI,

+        std::f64::consts::PI,

+    );

+    ctx.arc(

+        rect.x as f64 + radius,

+        rect.y as f64 + radius,

+        radius,

+        std::f64::consts::PI,

+        1.5 * std::f64::consts::PI,

+    );

+    ctx.close_path();

+    ctx.stroke()?;

+

+    Ok(())

+}

+

+/// Draw a slider handle.

+fn draw_slider_handle(ctx: &cairo::Context, x: f64, y: f64) -> anyhow::Result<()> {

+    let radius = 8.0;

+

+    // White fill

+    set_color(ctx, Color::WHITE);

+    ctx.arc(x, y, radius, 0.0, 2.0 * std::f64::consts::PI);

+    ctx.fill()?;

+

+    // Dark border

+    set_color(ctx, Color::new(0.3, 0.3, 0.3, 1.0));

+    ctx.set_line_width(2.0);

+    ctx.arc(x, y, radius, 0.0, 2.0 * std::f64::consts::PI);

+    ctx.stroke()?;

+

+    Ok(())

+}

+//! Tab bar for color picker dialog.

+

+use gartk_core::{Color, Point, Rect};

+use gartk_render::{fill_rounded_rect, set_color};

+

+use super::PADDING;

+

+/// Tab height.

+const TAB_HEIGHT: u32 = 28;

+

+/// Tab width.

+const TAB_WIDTH: u32 = 70;

+

+/// Color picker tab selection.

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]

+pub enum ColorPickerTab {

+    /// HSV color wheel tab.

+    #[default]

+    Hsv,

+    /// RGB sliders tab.

+    Rgb,

+    /// Color palette tab.

+    Palette,

+}

+

+impl ColorPickerTab {

+    /// Get all tabs in order.

+    pub const fn all() -> [Self; 3] {

+        [Self::Hsv, Self::Rgb, Self::Palette]

+    }

+

+    /// Get tab label.

+    pub const fn label(&self) -> &'static str {

+        match self {

+            Self::Hsv => "HSV",

+            Self::Rgb => "RGB",

+            Self::Palette => "Palette",

+        }

+    }

+}

+

+/// Get the rect for a tab at given index.

+fn tab_rect(index: usize) -> Rect {

+    let x = PADDING as i32 + (index as i32 * (TAB_WIDTH as i32 + 4));

+    Rect::new(x, PADDING as i32, TAB_WIDTH, TAB_HEIGHT)

+}

+

+/// Handle click on tab bar, returns new tab if one was clicked.

+pub fn handle_click(local_pos: Point) -> Option<ColorPickerTab> {

+    for (i, tab) in ColorPickerTab::all().iter().enumerate() {

+        if tab_rect(i).contains_point(local_pos) {

+            return Some(*tab);

+        }

+    }

+    None

+}

+

+/// Draw the tab bar.

+pub fn draw(ctx: &cairo::Context, selected: ColorPickerTab) -> anyhow::Result<()> {

+    for (i, tab) in ColorPickerTab::all().iter().enumerate() {

+        let rect = tab_rect(i);

+        let is_selected = *tab == selected;

+

+        // Tab background

+        let bg = if is_selected {

+            Color::new(0.3, 0.3, 0.3, 1.0)

+        } else {

+            Color::new(0.2, 0.2, 0.2, 1.0)

+        };

+        fill_rounded_rect(ctx, rect, 4.0, bg);

+

+        // Tab label

+        set_color(

+            ctx,

+            if is_selected {

+                Color::WHITE

+            } else {

+                Color::new(0.7, 0.7, 0.7, 1.0)

+            },

+        );

+        ctx.select_font_face("sans-serif", cairo::FontSlant::Normal, cairo::FontWeight::Bold);

+        ctx.set_font_size(12.0);

+

+        let label = tab.label();

+        let extents = ctx.text_extents(label)?;

+        let text_x = rect.x as f64 + (rect.width as f64 - extents.width()) / 2.0;

+        let text_y = rect.y as f64 + (rect.height as f64 + extents.height()) / 2.0;

+

+        ctx.move_to(text_x, text_y);

+        ctx.show_text(label)?;

+    }

+

+    Ok(())

+}

+pub mod color_picker;

+pub use color_picker::{ColorPicker, ColorPickerResult, PICKER_HEIGHT, PICKER_WIDTH};

+pub use toolbar::{Toolbar, ToolbarClickResult, TOOLBAR_HEIGHT};

+/// Result of a toolbar click.

+#[derive(Debug, Clone, Copy, PartialEq, Eq)]

+pub enum ToolbarClickResult {

+    /// A tool button was clicked.

+    Tool(ToolType),

+    /// The color preview was clicked (open color picker).

+    ColorPreview,

+    /// Click was in toolbar area but not on any button.

+    None,

+}

+

+    /// Calculate the color preview rect.

+    pub fn color_preview_rect(&self) -> Rect {

+        Rect::new(

+            (ToolType::all().len() as i32 + 1) * (Self::BUTTON_WIDTH as i32 + Self::PADDING as i32),

+            Self::PADDING as i32 + 4,

+            32,

+            32,

+        )

+    }

+

+        let color_rect = self.color_preview_rect();

+    /// Handle click on toolbar, returns the click result.

+    pub fn handle_click(&self, pos: Point) -> ToolbarClickResult {

+            return ToolbarClickResult::None;

+        // Check tool buttons

+                return ToolbarClickResult::Tool(*tool);

+        // Check color preview

+        if self.color_preview_rect().contains_point(pos) {

+            return ToolbarClickResult::ColorPreview;

+        }

+

+        ToolbarClickResult::None