atmos/kernel/

dialog.rs

// src/dialog.rs
#![allow(dead_code)]
extern crate alloc;
use alloc::string::String;
use alloc::vec::Vec;

use crate::kernel::draw::{Color, Screen};

#[derive(Debug, Clone, PartialEq)]
pub enum DialogMode {
    Open,
    Save,
}

pub struct FileDialog {
    pub mode: DialogMode,
    pub title: String,
    pub files: Vec<String>,
    pub selected_idx: Option<usize>,
    pub filename_input: String,
    pub is_open: bool,
    pub result: Option<String>,
    pub offset_y: usize,
}

impl Default for FileDialog {
    fn default() -> Self {
        Self::new()
    }
}

impl FileDialog {
    pub fn new() -> Self {
        Self {
            mode: DialogMode::Open,
            title: String::new(),
            files: Vec::new(),
            selected_idx: None,
            filename_input: String::new(),
            is_open: false,
            result: None,
            offset_y: 0,
        }
    }

    pub fn open(&mut self, mode: DialogMode, default_filename: &str) {
        self.mode = mode.clone();
        self.title = if mode == DialogMode::Open {
            String::from("Open File")
        } else {
            String::from("Save File")
        };
        self.filename_input = String::from(default_filename);
        self.is_open = true;
        self.result = None;
        self.selected_idx = None;
        self.offset_y = 0;
        self.refresh_files();
    }

    pub fn refresh_files(&mut self) {
        self.files.clear();
        let fs = crate::kernel::fs::get_fs();
        for meta in fs.list_files() {
            self.files.push(String::from(meta.get_filename()));
        }
    }

    pub fn close(&mut self) {
        self.is_open = false;
    }

    pub fn handle_mouse(
        &mut self,
        mx: i32,
        my: i32,
        left_click: bool,
        screen_width: u32,
        screen_height: u32,
    ) -> bool {
        if !self.is_open {
            return false;
        }

        let cx = screen_width as i32 / 2;
        let cy = screen_height as i32 / 2;
        let w = 600;
        let h = 400;
        let x = cx - w / 2;
        let y = cy - h / 2;

        if left_click {
            // Check if clicked outside
            if mx < x || mx > x + w || my < y || my > y + h {
                // Ignore or close? Let's just ignore.
            } else {
                // Clicked inside
                // Check close button
                if mx >= x + w - 30 && mx <= x + w - 10 && my >= y + 10 && my <= y + 30 {
                    self.close();
                    return true;
                }

                // Check file list
                let list_x = x + 20;
                let list_y = y + 50;
                let list_w = w - 40;
                let list_h = 240;

                if mx >= list_x && mx <= list_x + list_w && my >= list_y && my <= list_y + list_h {
                    let rel_y = my - list_y;
                    let item_idx = (rel_y / 30) as usize + self.offset_y;
                    if item_idx < self.files.len() {
                        self.selected_idx = Some(item_idx);
                        self.filename_input = self.files[item_idx].clone();
                    }
                }

                // Check buttons
                let btn_y = y + h - 40;
                let cancel_x = x + w - 200;
                let action_x = x + w - 90;

                if mx >= cancel_x && mx <= cancel_x + 80 && my >= btn_y && my <= btn_y + 30 {
                    self.close();
                } else if mx >= action_x
                    && mx <= action_x + 80
                    && my >= btn_y
                    && my <= btn_y + 30
                    && !self.filename_input.is_empty()
                {
                    self.result = Some(self.filename_input.clone());
                    self.close();
                }
            }
        } else {
            // Check wheel scroll (pseudo, using left/right for now since wheel isn't passed here easily unless modified)
        }

        true // Consume event
    }

    pub fn handle_key(&mut self, keycode: u8, c: Option<char>) -> bool {
        if !self.is_open {
            return false;
        }

        if keycode == 0x01 {
            // ESC
            self.close();
            return true;
        }

        if keycode == 0x1C {
            // Enter
            if !self.filename_input.is_empty() {
                self.result = Some(self.filename_input.clone());
                self.close();
            }
            return true;
        }

        if keycode == 0x0E {
            // Backspace
            if !self.filename_input.is_empty() {
                self.filename_input.pop();
            }
            return true;
        }

        if let Some(ch) = c {
            if ch.is_ascii_alphanumeric() || ch == '.' || ch == '_' || ch == '-' {
                self.filename_input.push(ch);
            }
        }

        true // Consume event
    }

    pub fn draw(&self, screen: &mut Screen) {
        if !self.is_open {
            return;
        }

        let t = &crate::kernel::config::get_config().theme;

        let cx = screen.width / 2;
        let cy = screen.height / 2;
        let w = 600;
        let h = 400;
        let x = cx - w / 2;
        let y = cy - h / 2;

        // Shadow
        screen.boxfill(x + 5, y + 5, x + w + 5, y + h + 5, Color(0x80000000));

        // Background
        screen.boxfill(x, y, x + w, y + h, Color(t.login_dialog_bg));

        // Title bar
        screen.boxfill(x, y, x + w, y + 40, Color(t.window_title_bar));
        screen.draw_string_vector(x + 20, y + 10, &self.title, Color(t.window_title_fg), 20);

        // Close button
        screen.draw_string_vector(x + w - 30, y + 10, "X", Color(t.win_btn_close), 20);

        // File list background
        let list_x = x + 20;
        let list_y = y + 50;
        let list_w = w - 40;
        screen.boxfill(x + 20, y + 50, x + w - 20, y + 50 + 240, Color(t.terminal_bg));

        // Files
        for (i, file) in self.files.iter().skip(self.offset_y).take(8).enumerate() {
            let item_y = list_y + (i as u32) * 30;
            if Some(i + self.offset_y) == self.selected_idx {
                screen.boxfill(
                    list_x,
                    item_y,
                    list_x + list_w,
                    item_y + 30,
                    Color(t.focus_highlight),
                );
            }
            screen.draw_string_vector(list_x + 10, item_y + 6, file, Color(t.terminal_fg), 16);
        }

        // Input box
        let input_y = y + 310;
        screen.draw_string_vector(x + 20, input_y + 5, "Filename:", Color(t.window_title_fg), 16);
        screen.boxfill(
            x + 110,
            input_y,
            x + w - 20,
            input_y + 30,
            Color(t.button_bg),
        );
        screen.draw_string_vector(
            x + 115,
            input_y + 6,
            &self.filename_input,
            Color(t.app_fg),
            16,
        );

        // Buttons
        let btn_y = y + h - 40;
        let cancel_x = x + w - 200;
        let action_x = x + w - 90;

        screen.boxfill(
            cancel_x,
            btn_y,
            cancel_x + 80,
            btn_y + 30,
            Color(t.button_bg),
        );
        screen.draw_string_vector(cancel_x + 10, btn_y + 6, "Cancel", Color(t.button_fg), 16);

        screen.boxfill(action_x, btn_y, action_x + 80, btn_y + 30, Color(t.button_active_bg));
        screen.draw_string_vector(
            action_x + 20,
            btn_y + 6,
            if self.mode == DialogMode::Open {
                "Open"
            } else {
                "Save"
            },
            Color(t.button_active_fg),
            16,
        );
    }
}

pub static mut GLOBAL_FILE_DIALOG: Option<FileDialog> = None;