gartk

pub struct Color {
    pub r: f64,
    pub g: f64,
    pub b: f64,
    pub a: f64,
}

pub enum InputEvent {
    Key(KeyEvent),
    MousePress(MouseEvent),
    MouseRelease(MouseEvent),
    MouseMove(MouseEvent),
    MouseEnter(Point),
    MouseLeave,
    Scroll(ScrollEvent),
    Expose,
    Resize { width: u32, height: u32 },
    FocusIn,
    FocusOut,
    CloseRequested,  // WM_DELETE_WINDOW
    Idle,            // No pending events (v0.3.0)
    SelectionRequest(SelectionRequestEvent),
    SelectionNotify(SelectionNotifyEvent),
    SelectionClear,
    FileDrop(Vec<PathBuf>),  // XDND file drop
}

pub struct KeyEvent {
    pub key: Key,
    pub keycode: u8,
    pub modifiers: Modifiers,
    pub pressed: bool,
}

// Key enum
pub enum Key {
    Escape, Return, Tab, Backspace, Delete,
    Home, End, PageUp, PageDown, Insert,
    Left, Right, Up, Down,
    F1..F12,
    Space,
    Char(char),  // Printable characters
    Unknown(u8),
}

key_event.is_printable()  // true for Char(c) and Space
key_event.char()          // Some('a') for printable keys

pub struct Modifiers {
    pub shift: bool,
    pub ctrl: bool,
    pub alt: bool,
    pub super_key: bool,
    pub caps_lock: bool,
    pub num_lock: bool,
}

pub struct Theme {
    // Window
    pub background: Color,
    pub foreground: Color,
    pub border: Color,
    pub border_width: u32,
    pub border_radius: f64,

    // Text
    pub font_family: String,
    pub font_size: f64,

    // Selection
    pub selection_background: Color,
    pub selection_foreground: Color,

    // Input field
    pub input_background: Color,
    pub input_foreground: Color,
    pub input_border: Color,
    pub input_placeholder: Color,
    pub input_cursor: Color,

    // Items/list
    pub item_background: Color,
    pub item_foreground: Color,
    pub item_hover_background: Color,
    pub item_hover_foreground: Color,
    pub item_selected_background: Color,
    pub item_selected_foreground: Color,
    pub item_description: Color,

    // Scrollbar
    pub scrollbar_track: Color,
    pub scrollbar_thumb: Color,
    pub scrollbar_width: u32,

    // Spacing
    pub padding: u32,
    pub item_spacing: u32,
    pub item_padding: u32,
}

let conn = Connection::connect(None)?;  // Connect to $DISPLAY
let conn = Connection::connect(Some(":1"))?;  // Specific display

// Screen queries
let root = conn.root();
let width = conn.screen_width();
let height = conn.screen_height();
let visual = conn.default_visual();
let colormap = conn.default_colormap();

// ARGB visual for transparency
if let Some(argb_visual) = conn.find_argb_visual() {
    let colormap = conn.create_colormap(argb_visual)?;
}

// Atom interning
let atom = conn.intern_atom("_NET_WM_NAME", false)?;

// ID generation
let window_id = conn.generate_id()?;

// Access underlying x11rb connection
conn.inner().map_window(window_id)?;
conn.flush()?;  // Flush requests
conn.sync()?;   // Flush and wait for reply

// Query pointer position
let (x, y) = conn.query_pointer()?;

// Non-blocking event polling
let event = conn.poll_event()?;  // Returns None if no events

let window = Window::create(conn.clone(), config)?;

// Window is automatically destroyed on Drop
// Manual cleanup:
window.destroy()?;

window.map()?;    // Show
window.unmap()?;  // Hide

window.move_to(100, 100)?;
window.resize(800, 600)?;
window.set_geometry(Rect::new(100, 100, 800, 600))?;

let rect = window.rect();
let size = window.size();

window.raise()?;   // Raise to top
window.focus()?;   // Request input focus

window.set_title("New Title")?;

let id = window.id();          // X11 Window ID
let visual = window.visual();  // Visual ID
let depth = window.depth();    // Depth (24 or 32)
let colormap = window.colormap();  // Colormap ID

// For screen lockers or modal dialogs
window.grab_keyboard()?;
window.grab_keyboard_with_retry(5)?;  // Retry up to 5 times
window.grab_pointer()?;

// Release grabs
window.ungrab_keyboard()?;
window.ungrab_pointer()?;

// Create a dialog window that belongs to a parent
let config = WindowConfig::dialog()
    .title("Save changes?")
    .size(400, 200);

let dialog = Window::create(conn.clone(), config)?;

// Set transient relationship (dialog belongs to parent)
dialog.set_transient_for(parent.id())?;

// Make it modal (blocks interaction with parent)
dialog.add_state(atoms.net_wm_state_modal)?;

// Clear modal state when done
dialog.clear_state(atoms.net_wm_state_modal)?;

// Request window activation via _NET_ACTIVE_WINDOW
// Proper way for applications to request focus
window.activate()?;

// Resize window
window.set_size(800, 600)?;

let mut event_loop = EventLoop::new(&window, config)?;

event_loop.run(|el, event| {
    match event {
        InputEvent::Expose => {
            // Redraw window
            el.request_redraw();  // Request another redraw
        }

        InputEvent::Key(key_event) => {
            if key_event.pressed && key_event.key == Key::Escape {
                el.quit();
                return Ok(false);  // Stop loop
            }
        }

        InputEvent::Resize { width, height } => {
            // Handle resize
        }

        InputEvent::CloseRequested => {
            el.quit();
            return Ok(false);
        }

        _ => {}
    }

    Ok(true)  // Continue loop
})?;

// Enable XDND drag-and-drop support
event_loop.enable_xdnd();

// Handle file drops in the event callback
InputEvent::FileDrop(paths) => {
    for path in paths {
        println!("Dropped: {}", path.display());
    }
}

InputEvent::Idle => {
    // Emitted once per frame when there are no pending events
    // Useful for animations, timers, or background tasks
    animation_tick();
}

use gartk_x11::{detect_monitors, primary_monitor, monitor_at_point};

// Detect all monitors
let monitors = detect_monitors(&conn)?;
for monitor in &monitors {
    println!("{}: {}x{} @ {}x{} (DPI: {:.1})",
        monitor.name,
        monitor.rect.width,
        monitor.rect.height,
        monitor.rect.x,
        monitor.rect.y,
        monitor.dpi()
    );
}

// Get primary monitor
let primary = primary_monitor(&conn)?;

// Find monitor at coordinates or at current pointer
let monitor = monitor_at_point(&conn, 1000, 500)?;
let monitor = monitor_at_pointer(&conn)?;

// Monitor properties
let dpi = monitor.dpi();     // Average DPI
let dpi_x = monitor.dpi_x(); // Horizontal DPI
let dpi_y = monitor.dpi_y(); // Vertical DPI
let center = monitor.center();  // Center point

use gartk_x11::{key_from_keycode, modifiers_from_x11, key_event_from_x11};

// Convert X11 keycode to Key enum
let modifiers = Modifiers::NONE;
let key = key_from_keycode(36, &modifiers);  // 36 = Return

// Extract modifiers from X11 state
let mods = modifiers_from_x11(event.state);

// Create KeyEvent from X11 event (used internally by EventLoop)
let key_event = key_event_from_x11(&x11_key_press_event, true);

use gartk_x11::{CursorManager, CursorShape};

let mut cursor_mgr = CursorManager::new(conn.clone())?;

// Get a cursor (cached after first call)
let cursor = cursor_mgr.get(CursorShape::Pointer)?;

// Set window cursor
cursor_mgr.set_window_cursor(window.id(), CursorShape::Text)?;

use gartk_x11::Atoms;

let atoms = Atoms::new(&conn)?;

// WM protocols
atoms.wm_protocols
atoms.wm_delete_window
atoms.wm_take_focus

// EWMH window types
atoms.net_wm_window_type
atoms.net_wm_window_type_normal
atoms.net_wm_window_type_dialog
atoms.net_wm_window_type_utility
atoms.net_wm_window_type_popup_menu

// EWMH state
atoms.net_wm_state
atoms.net_wm_state_above
atoms.net_wm_state_fullscreen

// Clipboard
atoms.clipboard
atoms.primary
atoms.utf8_string
atoms.text_uri_list       // (v0.3.0) file:// URIs
atoms.gnome_copied_files  // (v0.3.0) GNOME format

use gartk_x11::ClipboardManager;

let mut clipboard = ClipboardManager::new(conn.clone(), atoms.clone())?;

// Copy file paths (for file managers)
clipboard.copy_files(&["/home/user/file.txt"], false)?; // Copy
clipboard.copy_files(&["/home/user/file.txt"], true)?;  // Cut

// Handle clipboard events in event loop
InputEvent::SelectionRequest(req) => {
    clipboard.handle_selection_request(&req)?;
}
InputEvent::SelectionClear => {
    clipboard.handle_selection_clear();
}

let surface = Surface::new(800, 600)?;

let ctx = surface.context()?;  // Get Cairo context
surface.clear(Color::BLACK)?;  // Clear to color
surface.flush();               // Flush Cairo operations

// Resize (creates new surface)
surface.resize(1024, 768)?;

// Access raw data
let data = surface.data()?;    // Vec<u8> of ARGB pixels
let stride = surface.stride(); // Bytes per row
let w = surface.width();       // Width
let h = surface.height();      // Height

// Create from/export to RGBA pixel data
let surface = Surface::from_rgba(&rgba_bytes, width, height)?;
let rgba_bytes = surface.to_rgba()?;

let mut db_surface = DoubleBufferedSurface::new(800, 600)?;

// Draw to back buffer
let back = db_surface.back();
let ctx = back.context()?;
// ... render ...

// Swap buffers (copies back to front)
db_surface.swap()?;

// Display front buffer
let front = db_surface.front();
copy_surface_to_window(front, &window, gc, 0, 0)?;

let renderer = Renderer::new(800, 600)?;
let renderer = Renderer::with_theme(800, 600, Theme::dark())?;

// Clear
renderer.clear()?;  // Uses theme background
renderer.clear_color(Color::from_hex("#1e1e2e")?)?;

// Shapes
renderer.fill_rect(Rect::new(10, 10, 100, 50), Color::RED)?;
renderer.fill_rounded_rect(
    Rect::new(10, 70, 100, 50),
    8.0,  // radius
    Color::BLUE,
)?;
renderer.stroke_rect(
    Rect::new(10, 130, 100, 50),
    Color::GREEN,
    2.0,  // line width
)?;
renderer.fill_circle(200.0, 100.0, 30.0, Color::YELLOW)?;
renderer.line(50.0, 200.0, 150.0, 250.0, Color::CYAN, 1.0)?;

// Text
let style = TextStyle::new()
    .font_size(16.0)
    .color(Color::WHITE);

renderer.text("Hello", 10.0, 300.0, &style)?;
renderer.text_centered("Centered", Point::new(400, 400), &style)?;
renderer.text_in_rect("In Rect", Rect::new(10, 450, 200, 50), &style)?;

// Measure text
let size = renderer.measure_text("Test", &style)?;

// Access internals
let ctx = renderer.context()?;  // Cairo context
let surface = renderer.surface();
let theme = renderer.theme();

renderer.flush();

let text_renderer = TextRenderer::new();
let text_renderer = TextRenderer::with_style(default_style);

let ctx = surface.context()?;

// Draw text
text_renderer.draw(&ctx, "Text", 10.0, 10.0, &style);

// Draw in rectangle (vertical centering)
text_renderer.draw_in_rect(&ctx, "Text", rect, &style);

// Draw centered at point
text_renderer.draw_centered(&ctx, "Text", center_point, &style);

// Measure
let size = text_renderer.measure(&ctx, "Text", &style);

// Create Pango layout directly
let layout = text_renderer.create_layout(&ctx, "Text", &style);

use gartk_render::{fill_rect, fill_rounded_rect, fill_circle};
use gartk_render::{stroke_rect, stroke_rounded_rect, stroke_circle};
use gartk_render::{line, hline, vline, set_color};

let ctx = surface.context()?;

// Filled shapes
fill_rect(&ctx, rect, color);
fill_rounded_rect(&ctx, rect, radius, color);
fill_circle(&ctx, cx, cy, radius, color);

// Stroked shapes
stroke_rect(&ctx, rect, color, line_width);
stroke_rounded_rect(&ctx, rect, radius, color, line_width);
stroke_circle(&ctx, cx, cy, radius, color, line_width);

// Lines
line(&ctx, x1, y1, x2, y2, color, line_width);
hline(&ctx, y, x1, x2, color, line_width);
vline(&ctx, x, y1, y2, color, line_width);

// Path creation (no fill/stroke)
rect_path(&ctx, rect);
rounded_rect_path(&ctx, rect, radius);
circle_path(&ctx, cx, cy, radius);

// Set color
set_color(&ctx, color);
ctx.fill()?;

use gartk_core::{Color, InputEvent, Key, Theme};
use gartk_render::Renderer;
use gartk_x11::{Connection, EventLoop, EventLoopConfig, Window, WindowConfig};

fn main() -> anyhow::Result<()> {
    // Setup
    let conn = Connection::connect(None)?;
    let window = Window::create(conn.clone(), WindowConfig::new()
        .title("App")
        .size(800, 600))?;

    let theme = Theme::dark();
    let mut renderer = Renderer::with_theme(800, 600, theme)?;

    // Graphics context for copying
    let gc = conn.generate_id()?;
    conn.inner().create_gc(gc, window.id(), &Default::default())?;

    // Event loop
    let mut event_loop = EventLoop::new(&window, EventLoopConfig::default())?;

    event_loop.run(|el, event| {
        match event {
            InputEvent::Expose => {
                renderer.clear()?;
                // ... draw ...
                renderer.flush();
                copy_surface_to_window(
                    &mut renderer.surface().clone(),
                    &window,
                    gc,
                    0, 0
                )?;
            }
            InputEvent::Key(k) if k.key == Key::Escape => {
                el.quit();
                return Ok(false);
            }
            _ => {}
        }
        Ok(true)
    })?;

    Ok(())
}

// Override-redirect window for menus/launchers
let window = Window::create(conn.clone(), WindowConfig::popup()
    .position(100, 100)
    .size(400, 300)
    .transparent(true))?;

window.raise()?;  // Ensure on top
window.focus()?;  // Grab focus

// Request ARGB visual
let window = Window::create(conn.clone(), WindowConfig::popup()
    .transparent(true)  // Finds 32-bit ARGB visual
    .size(400, 300))?;

// Window will have depth 32 if ARGB visual found
if window.depth() == 32 {
    println!("Transparency supported");
}

// Render with alpha channel
let renderer = Renderer::new(400, 300)?;
renderer.clear_color(Color::from_hex("#1e1e2e80")?)?;  // 50% transparent
renderer.fill_rounded_rect(
    Rect::new(10, 10, 380, 280),
    8.0,
    Color::from_hex("#313244e0")?,  // Semi-transparent
)?;