free_launch/

ui.rs

use gdk4::Display;
use gtk4::prelude::*;
use gtk4::{
    Application, ApplicationWindow, Box, Entry, Image, Label as GtkLabel, ListBox, ListBoxRow,
    ScrolledWindow, glib,
};
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

use crate::item_list::load_all_items;
use crate::launch_item::LaunchItem;

// Custom ListBoxRow that holds a LaunchItem
#[derive(Debug)]
pub struct LaunchItemRow {
    row: ListBoxRow,
    item: LaunchItem,
}

impl LaunchItemRow {
    pub fn new(item: LaunchItem) -> Self {
        let row = ListBoxRow::new();
        let hbox = Box::new(gtk4::Orientation::Horizontal, 12);
        hbox.set_margin_top(8);
        hbox.set_margin_bottom(8);
        hbox.set_margin_start(12);
        hbox.set_margin_end(12);

        // Create icon
        let icon = if let Some(icon_name) = &item.icon_name {
            Image::from_icon_name(icon_name)
        } else {
            Image::from_icon_name("application-x-executable")
        };
        icon.set_pixel_size(32);

        // Create text container
        let vbox = Box::new(gtk4::Orientation::Vertical, 2);

        let name_label = GtkLabel::new(Some(&item.name));
        name_label.set_halign(gtk4::Align::Start);
        name_label.set_markup(&format!("<b>{}</b>", glib::markup_escape_text(&item.name)));

        let desc_label = GtkLabel::new(Some(&item.description));
        desc_label.set_halign(gtk4::Align::Start);
        desc_label.add_css_class("dim-label");
        desc_label.set_ellipsize(gtk4::pango::EllipsizeMode::End);

        vbox.append(&name_label);
        vbox.append(&desc_label);

        hbox.append(&icon);
        hbox.append(&vbox);

        row.set_child(Some(&hbox));

        Self { row, item }
    }

    pub fn list_box_row(&self) -> &ListBoxRow {
        &self.row
    }

    pub fn launch_item(&self) -> &LaunchItem {
        &self.item
    }
}

pub fn build_ui(app: &Application) {
    // Create a window and set the application
    let window = ApplicationWindow::builder()
        .application(app)
        .title("Free Launch")
        .default_width(600)
        .default_height(400)
        .resizable(true)
        .build();

    // Center the window on the primary display
    center_window(&window);

    // Create main container
    let content_box = Box::new(gtk4::Orientation::Vertical, 12);
    content_box.set_margin_top(20);
    content_box.set_margin_bottom(20);
    content_box.set_margin_start(20);
    content_box.set_margin_end(20);

    // Create search entry
    let search_entry = Entry::builder()
        .placeholder_text("Type to search applications...")
        .build();

    // Create scrolled window for the list
    let scrolled_window = ScrolledWindow::builder()
        .hscrollbar_policy(gtk4::PolicyType::Never)
        .vscrollbar_policy(gtk4::PolicyType::Automatic)
        .vexpand(true)
        .build();

    // Create list box for items
    let list_box = ListBox::new();
    list_box.set_selection_mode(gtk4::SelectionMode::Single);
    scrolled_window.set_child(Some(&list_box));

    // Load all available items
    let items = Rc::new(RefCell::new(load_all_items()));
    let filtered_items = Rc::new(RefCell::new(Vec::new()));
    let launch_rows = Rc::new(RefCell::new(HashMap::<u64, LaunchItemRow>::new()));

    // Populate initial list
    populate_list(
        &list_box,
        &items.borrow(),
        &mut filtered_items.borrow_mut(),
        &mut launch_rows.borrow_mut(),
    );

    // Select first item by default
    if let Some(first_row) = list_box.first_child() {
        if let Ok(row) = first_row.downcast::<ListBoxRow>() {
            list_box.select_row(Some(&row));
        }
    }

    // Set up search functionality
    let list_box_clone = list_box.clone();
    let items_clone = items.clone();
    let filtered_items_clone = filtered_items.clone();
    let launch_rows_clone = launch_rows.clone();

    search_entry.connect_changed(move |entry| {
        let query = entry.text().to_lowercase();
        filter_and_update_list(
            &list_box_clone,
            &items_clone.borrow(),
            &mut filtered_items_clone.borrow_mut(),
            &mut launch_rows_clone.borrow_mut(),
            &query,
        );
    });

    // Add widgets to container
    content_box.append(&search_entry);
    content_box.append(&scrolled_window);
    window.set_child(Some(&content_box));

    // Set up click handler for list box
    setup_list_box_click_handler(&list_box, &window, launch_rows.clone());

    // Set up keyboard shortcuts
    setup_keyboard_shortcuts(&window, &search_entry, &list_box, launch_rows.clone());
    setup_search_entry_shortcuts(&search_entry, &list_box, &window, launch_rows.clone());
    setup_search_entry_activate(&search_entry, &list_box, &window, launch_rows);

    // Focus the search entry
    search_entry.grab_focus();

    // Present window
    window.present();
}

fn center_window(window: &ApplicationWindow) {
    // Get the default display
    if let Some(display) = Display::default() {
        // Get the primary monitor
        if let Some(monitor) = display.monitors().item(0) {
            if let Some(monitor) = monitor.downcast_ref::<gdk4::Monitor>() {
                let geometry = monitor.geometry();
                let window_width = geometry.width() / 2;
                let window_height = geometry.height() / 2;

                // Note: GTK4 doesn't allow direct positioning, but we can suggest
                // the window manager to center it by setting the default size
                window.set_default_size(window_width, window_height);
            }
        }
    }
}

fn populate_list(
    list_box: &ListBox,
    items: &[LaunchItem],
    filtered_items: &mut Vec<LaunchItem>,
    launch_rows: &mut HashMap<u64, LaunchItemRow>,
) {
    // Clear existing items
    while let Some(child) = list_box.first_child() {
        list_box.remove(&child);
    }

    filtered_items.clear();
    filtered_items.extend_from_slice(items);
    launch_rows.clear();

    // Add items to list
    for item in items {
        let launch_row = LaunchItemRow::new(item.clone());
        let row_ptr = launch_row.list_box_row().as_ptr() as u64;
        list_box.append(launch_row.list_box_row());
        launch_rows.insert(row_ptr, launch_row);
    }
}

fn filter_and_update_list(
    list_box: &ListBox,
    items: &[LaunchItem],
    filtered_items: &mut Vec<LaunchItem>,
    launch_rows: &mut HashMap<u64, LaunchItemRow>,
    query: &str,
) {
    // Clear existing items
    while let Some(child) = list_box.first_child() {
        list_box.remove(&child);
    }

    filtered_items.clear();
    launch_rows.clear();

    // Filter items based on query
    for item in items {
        if query.is_empty()
            || item.name.to_lowercase().contains(query)
            || item.description.to_lowercase().contains(query)
        {
            filtered_items.push(item.clone());
        }
    }

    // Add filtered items to list
    for item in filtered_items.iter() {
        let launch_row = LaunchItemRow::new(item.clone());
        let row_ptr = launch_row.list_box_row().as_ptr() as u64;
        list_box.append(launch_row.list_box_row());
        launch_rows.insert(row_ptr, launch_row);
    }

    // Select first item if available
    if let Some(first_row) = list_box.first_child() {
        if let Ok(row) = first_row.downcast::<ListBoxRow>() {
            list_box.select_row(Some(&row));
        }
    }
}

fn setup_keyboard_shortcuts(
    window: &ApplicationWindow,
    search_entry: &Entry,
    list_box: &ListBox,
    launch_rows: Rc<RefCell<HashMap<u64, LaunchItemRow>>>,
) {
    // Create event controller for key events
    let key_controller = gtk4::EventControllerKey::new();

    // Clone references for the closure
    let window_clone = window.clone();
    let list_box_clone = list_box.clone();
    let launch_rows_clone = launch_rows.clone();

    key_controller.connect_key_pressed(move |_controller, key, _code, modifier| {
        // Check for Ctrl+Q or Ctrl+W to quit
        if modifier.contains(gdk4::ModifierType::CONTROL_MASK) {
            match key {
                gdk4::Key::q | gdk4::Key::Q | gdk4::Key::w | gdk4::Key::W => {
                    window_clone.close();
                    return glib::Propagation::Stop;
                }
                _ => {}
            }
        }

        // Handle navigation keys
        match key {
            gdk4::Key::Down => {
                if let Some(selected) = list_box_clone.selected_row() {
                    if let Some(next) = selected.next_sibling() {
                        if let Ok(next_row) = next.downcast::<ListBoxRow>() {
                            list_box_clone.select_row(Some(&next_row));
                        }
                    }
                }
                return glib::Propagation::Stop;
            }
            gdk4::Key::Up => {
                if let Some(selected) = list_box_clone.selected_row() {
                    if let Some(prev) = selected.prev_sibling() {
                        if let Ok(prev_row) = prev.downcast::<ListBoxRow>() {
                            list_box_clone.select_row(Some(&prev_row));
                        }
                    }
                }
                return glib::Propagation::Stop;
            }
            gdk4::Key::Page_Up => {
                handle_page_up(&list_box_clone);
                return glib::Propagation::Stop;
            }
            gdk4::Key::Page_Down => {
                handle_page_down(&list_box_clone);
                return glib::Propagation::Stop;
            }
            gdk4::Key::Return | gdk4::Key::KP_Enter => {
                // Launch selected item
                eprintln!("Launching item...");
                if let Some(selected) = list_box_clone.selected_row() {
                    eprintln!("Found a selected item...");
                    let row_ptr = selected.as_ptr() as u64;
                    if let Some(launch_row) = launch_rows_clone.borrow().get(&row_ptr) {
                        eprintln!("Calling launch on item...");
                        launch_row.launch_item().launch();
                        std::process::exit(0);
                    }
                }
                window_clone.close();
                return glib::Propagation::Stop;
            }
            gdk4::Key::Escape => {
                window_clone.close();
                return glib::Propagation::Stop;
            }
            _ => {}
        }

        glib::Propagation::Proceed
    });

    window.add_controller(key_controller);
}

fn setup_search_entry_shortcuts(
    search_entry: &Entry,
    list_box: &ListBox,
    window: &ApplicationWindow,
    launch_rows: Rc<RefCell<HashMap<u64, LaunchItemRow>>>,
) {
    let key_controller = gtk4::EventControllerKey::new();

    let list_box_clone = list_box.clone();
    let window_clone = window.clone();
    let launch_rows_clone = launch_rows.clone();

    key_controller.connect_key_pressed(move |_controller, key, _code, _modifier| {
        match key {
            gdk4::Key::Return | gdk4::Key::KP_Enter => {
                // Launch selected item
                if let Some(selected) = list_box_clone.selected_row() {
                    let row_ptr = selected.as_ptr() as u64;
                    if let Some(launch_row) = launch_rows_clone.borrow().get(&row_ptr) {
                        launch_row.launch_item().launch();
                        std::process::exit(0);
                    }
                }
                return glib::Propagation::Stop;
            }
            gdk4::Key::Down => {
                if let Some(selected) = list_box_clone.selected_row() {
                    if let Some(next) = selected.next_sibling() {
                        if let Ok(next_row) = next.downcast::<ListBoxRow>() {
                            list_box_clone.select_row(Some(&next_row));
                        }
                    }
                }
                return glib::Propagation::Stop;
            }
            gdk4::Key::Up => {
                if let Some(selected) = list_box_clone.selected_row() {
                    if let Some(prev) = selected.prev_sibling() {
                        if let Ok(prev_row) = prev.downcast::<ListBoxRow>() {
                            list_box_clone.select_row(Some(&prev_row));
                        }
                    }
                }
                return glib::Propagation::Stop;
            }
            gdk4::Key::Page_Up => {
                handle_page_up(&list_box_clone);
                return glib::Propagation::Stop;
            }
            gdk4::Key::Page_Down => {
                handle_page_down(&list_box_clone);
                return glib::Propagation::Stop;
            }
            gdk4::Key::Escape => {
                window_clone.close();
                return glib::Propagation::Stop;
            }
            _ => {}
        }

        glib::Propagation::Proceed
    });

    search_entry.add_controller(key_controller);
}

fn setup_list_box_click_handler(
    list_box: &ListBox,
    window: &ApplicationWindow,
    launch_rows: Rc<RefCell<HashMap<u64, LaunchItemRow>>>,
) {
    let window_clone = window.clone();
    let launch_rows_clone = launch_rows.clone();

    list_box.connect_row_activated(move |_list_box, row| {
        let row_ptr = row.as_ptr() as u64;
        if let Some(launch_row) = launch_rows_clone.borrow().get(&row_ptr) {
            launch_row.launch_item().launch();
            std::process::exit(0);
        }
    });
}

fn setup_search_entry_activate(
    search_entry: &Entry,
    list_box: &ListBox,
    window: &ApplicationWindow,
    launch_rows: Rc<RefCell<HashMap<u64, LaunchItemRow>>>,
) {
    let list_box_clone = list_box.clone();
    let window_clone = window.clone();
    let launch_rows_clone = launch_rows.clone();

    search_entry.connect_activate(move |_entry| {
        // Launch selected item when Enter is pressed in search entry
        if let Some(selected) = list_box_clone.selected_row() {
            let row_ptr = selected.as_ptr() as u64;
            if let Some(launch_row) = launch_rows_clone.borrow().get(&row_ptr) {
                launch_row.launch_item().launch();
                std::process::exit(0);
            }
        }
    });
}

fn handle_page_up(list_box: &ListBox) {
    // Get the first and last visible rows
    let (first_visible, last_visible) = get_visible_row_range(list_box);

    if first_visible.is_none() || last_visible.is_none() {
        return; // No items visible
    }

    let selected = list_box.selected_row();
    let first_child = list_box.first_child();

    // If no selection or already at first item, try to scroll up
    let first_child_as_row = first_child.and_then(|w| w.downcast::<ListBoxRow>().ok());
    if selected.is_none() || (selected == first_child_as_row) {
        // Calculate how many items to scroll by (one page worth)
        let visible_count = count_visible_rows(list_box);
        if visible_count > 0 {
            scroll_up_by_page(list_box, visible_count);
        }
    } else {
        // Move selection to first visible item
        if let Some(first_visible_row) = first_visible {
            list_box.select_row(Some(&first_visible_row));
        }
    }
}

fn handle_page_down(list_box: &ListBox) {
    // Get the first and last visible rows
    let (first_visible, last_visible) = get_visible_row_range(list_box);

    if first_visible.is_none() || last_visible.is_none() {
        return; // No items visible
    }

    let selected = list_box.selected_row();
    let last_child = get_last_child(list_box);

    // If no selection or already at last item, try to scroll down
    if selected.is_none() || (selected == last_child) {
        // Calculate how many items to scroll by (one page worth)
        let visible_count = count_visible_rows(list_box);
        if visible_count > 0 {
            scroll_down_by_page(list_box, visible_count);
        }
    } else {
        // Move selection to last visible item
        if let Some(last_visible_row) = last_visible {
            list_box.select_row(Some(&last_visible_row));
        }
    }
}

fn get_visible_row_range(list_box: &ListBox) -> (Option<ListBoxRow>, Option<ListBoxRow>) {
    // Get the scrolled window parent to check visibility
    let mut parent = list_box.parent();
    let scrolled_window = loop {
        match parent {
            Some(ref p) if p.type_().name() == "GtkScrolledWindow" => {
                break p.clone();
            }
            Some(p) => {
                parent = p.parent();
            }
            None => return (None, None),
        }
    };

    let allocation = scrolled_window.allocation();
    let scroll_height = allocation.height();

    let mut first_visible = None;
    let mut last_visible = None;
    let mut current_child = list_box.first_child();

    while let Some(child) = current_child {
        if let Some(row) = child.downcast_ref::<ListBoxRow>() {
            let row_allocation = row.allocation();
            let row_y = row_allocation.y();
            let row_height = row_allocation.height();

            // Check if row is visible (intersects with scrolled window viewport)
            if row_y + row_height > 0 && row_y < scroll_height {
                if first_visible.is_none() {
                    first_visible = Some(row.clone());
                }
                last_visible = Some(row.clone());
            }
        }
        current_child = child.next_sibling();
    }

    (first_visible, last_visible)
}

fn count_visible_rows(list_box: &ListBox) -> i32 {
    let (first_visible, _) = get_visible_row_range(list_box);
    if first_visible.is_none() {
        return 0;
    }

    // Get the scrolled window parent to check visibility
    let mut parent = list_box.parent();
    let scrolled_window = loop {
        match parent {
            Some(ref p) if p.type_().name() == "GtkScrolledWindow" => {
                break p.clone();
            }
            Some(p) => {
                parent = p.parent();
            }
            None => return 0,
        }
    };

    let allocation = scrolled_window.allocation();
    let scroll_height = allocation.height();

    let mut count = 0;
    let mut current_child = list_box.first_child();

    while let Some(child) = current_child {
        if let Some(row) = child.downcast_ref::<ListBoxRow>() {
            let row_allocation = row.allocation();
            let row_y = row_allocation.y();
            let row_height = row_allocation.height();

            // Check if row is visible
            if row_y + row_height > 0 && row_y < scroll_height {
                count += 1;
            }
        }
        current_child = child.next_sibling();
    }

    count
}

fn scroll_up_by_page(list_box: &ListBox, page_size: i32) {
    let selected = list_box.selected_row();
    let mut target_row = None;
    let mut steps = 0;

    if let Some(current) = selected {
        let mut current_row = Some(current);

        // Move up by page_size steps or until we reach the first item
        while steps < page_size && current_row.is_some() {
            if let Some(prev) = current_row.as_ref().and_then(|r| r.prev_sibling()) {
                if let Ok(prev_row) = prev.downcast::<ListBoxRow>() {
                    current_row = Some(prev_row);
                    steps += 1;
                } else {
                    break;
                }
            } else {
                break;
            }
        }

        target_row = current_row;
    } else {
        // No selection, select first item
        if let Some(first) = list_box.first_child() {
            if let Ok(first_row) = first.downcast::<ListBoxRow>() {
                target_row = Some(first_row);
            }
        }
    }

    if let Some(row) = target_row {
        list_box.select_row(Some(&row));
    }
}

fn scroll_down_by_page(list_box: &ListBox, page_size: i32) {
    let selected = list_box.selected_row();
    let mut target_row = None;
    let mut steps = 0;

    if let Some(current) = selected {
        let mut current_row = Some(current);

        // Move down by page_size steps or until we reach the last item
        while steps < page_size && current_row.is_some() {
            if let Some(next) = current_row.as_ref().and_then(|r| r.next_sibling()) {
                if let Ok(next_row) = next.downcast::<ListBoxRow>() {
                    current_row = Some(next_row);
                    steps += 1;
                } else {
                    break;
                }
            } else {
                break;
            }
        }

        target_row = current_row;
    } else {
        // No selection, select last item
        target_row = get_last_child(list_box);
    }

    if let Some(row) = target_row {
        list_box.select_row(Some(&row));
    }
}

fn get_last_child(list_box: &ListBox) -> Option<ListBoxRow> {
    let mut current = list_box.first_child();
    let mut last_row = None;

    while let Some(child) = current {
        let next_sibling = child.next_sibling();
        if let Ok(row) = child.downcast::<ListBoxRow>() {
            last_row = Some(row);
        }
        current = next_sibling;
    }

    last_row
}