DSA/emulator/dsa_gui/src/ui/ui_helpers/mod.rs

pub mod text;

use eframe::emath::Vec2;
use egui::{Color32};
use dsa_emulator::processor::RunningState;

pub struct PaddedWidget {
    text: String,
    color: Option<Color32>,
    padding: Option<Vec2>,
    widget_type: WidgetType
}

enum WidgetType {
    Button,
    Indicator,
    Label
}

impl PaddedWidget {
    pub fn button(text: impl Into<String>) -> Self {
        Self {
            text: text.into(),
            color: None,
            padding: None,
            widget_type: WidgetType::Button
        }
    }

    pub fn indicator(i: impl StatusIndicator) -> Self {
        Self {
            text: i.label().to_string(),
            color: Some(i.color()),
            padding: None,
            widget_type: WidgetType::Indicator
        }
    }

    pub fn label(text: impl Into<String>) -> Self {
        Self {
            text: text.into(),
            color: None,
            padding: None,
            widget_type: WidgetType::Label
        }
    }

    pub fn color(&mut self, color: Color32) -> &mut Self {
        self.color = Some(color);
        self
    }

    pub fn padding(&mut self, padding: Vec2) -> &mut Self {
        self.padding = Some(padding);
        self
    }

    pub fn ui(&mut self, ui: &mut egui::Ui) -> egui::Response {
        let text: egui::WidgetText = self.text.clone().into();
        let galley = text.into_galley(ui, None, f32::INFINITY, egui::TextStyle::Button);

        let desired_size = if let WidgetType::Indicator = self.widget_type {
            galley.size() + egui::vec2(12.0, 0.0) + self.padding.unwrap_or(Vec2::new(14.0, 8.0)) * 2.0
        } else {
            galley.size() + self.padding.unwrap_or(Vec2::new(14.0, 8.0)) * 2.0
        };

        let (rect, response) = ui.allocate_exact_size(desired_size, egui::Sense::click());

        if ui.is_rect_visible(rect) {
            // picks noninteractive/inactive/hovered/active automatically based on `response`

            let visuals = match self.widget_type {
                WidgetType::Button => ui.style().interact(&response),
                _ => &ui.visuals().widgets.inactive,
            };

            ui.painter().rect(
                rect,
                visuals.corner_radius,
                visuals.bg_fill,
                visuals.bg_stroke,
                egui::StrokeKind::Inside,
            );

            if let WidgetType::Indicator = self.widget_type {
                let size = egui::vec2(galley.size().clone().x + 6.0, 0.0);
                let text_pos = rect.center() - galley.size() / 2.0 + egui::vec2(8.0, 0.0);
                ui.painter().galley(text_pos, galley, self.color.unwrap_or(visuals.fg_stroke.color));
                ui.painter().circle_filled(rect.center() - size / 2.0, 8.0 / 2.0, self.color.unwrap());
            }

            else {
                let text_pos = rect.center() - galley.size() / 2.0;
                ui.painter().galley(text_pos, galley, self.color.unwrap_or(visuals.fg_stroke.color));
            }
        }

        response
    }
}


pub trait StatusIndicator {
    fn color(&self) -> egui::Color32;

    fn label(&self) -> String;
}

impl StatusIndicator for RunningState {
    fn color(&self) -> egui::Color32 {
        match self {
            RunningState::Running => egui::Color32::GREEN,
            RunningState::Paused => egui::Color32::YELLOW,
            RunningState::Halted => egui::Color32::ORANGE,
            RunningState::Breakpoint(_) => egui::Color32::RED,
            RunningState::Shutdown => egui::Color32::BLUE,
        }
    }

    fn label(&self) -> String {
        match self {
            RunningState::Running => "Running".into(),
            RunningState::Paused => "Paused".into(),
            RunningState::Halted => "Halted".into(),
            RunningState::Breakpoint(addr) => format!("Breakpoint @ {addr:#06x}"),
            RunningState::Shutdown => "Shutdown".into(),
        }
    }
}

/// Shared paint logic — draws the crossed lines, using whatever
/// interact-state visuals (hover/press color, expansion) egui's style
/// would normally pick for this response.
fn paint_close_x(ui: &egui::Ui, rect: egui::Rect, response: &egui::Response) {
    if !ui.is_rect_visible(rect) {
        return;
    }
    let visuals = ui.style().interact(response);
    let inner = rect.shrink(4.0).expand(visuals.expansion);
    let stroke = visuals.fg_stroke;
    ui.painter().line_segment([inner.left_top(), inner.right_bottom()], stroke);
    ui.painter().line_segment([inner.right_top(), inner.left_bottom()], stroke);
}

/// Standalone close button — allocates its own space in the current
/// layout, like a normal widget. Use this in a `ui.horizontal(...)` row,
/// e.g. next to a label in a flat list (process manager tabs, a file
/// list with per-row close, etc).
pub fn close_button(ui: &mut egui::Ui, size: f32) -> egui::Response {
    let (rect, response) = ui.allocate_exact_size(egui::vec2(size, size), egui::Sense::click());
    let response = response.on_hover_cursor(egui::CursorIcon::Default);

    response.widget_info(|| {
        egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), "Close")
    });

    paint_close_x(ui, rect, &response);
    response
}

/// Close button at an explicit rect you've already computed — for
/// cases like tab_ui, where the button needs to sit inside a larger
/// region you're laying out manually rather than in normal flow.
pub fn close_button_at(ui: &mut egui::Ui, rect: egui::Rect, id: egui::Id) -> egui::Response {
    let response = ui
        .interact(rect, id, egui::Sense::click_and_drag())
        .on_hover_cursor(egui::CursorIcon::Default);

    response.widget_info(|| {
        egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), "Close")
    });

    paint_close_x(ui, rect, &response);
    response
}

pub struct TabResponse {
    pub response: egui::Response,
    pub close_clicked: bool,
}

pub fn painted_tab(
    ui: &mut egui::Ui,
    id: egui::Id,
    title: impl Into<egui::WidgetText>,
    selected: bool,
    closable: bool,
    draggable: bool,
) -> TabResponse {
    let padding = egui::vec2(14.0, 8.0);
    let close_size = 14.0;
    let close_gap = 6.0;

    let font_id = egui::TextStyle::Button.resolve(ui.style());
    let galley = title.into().into_galley(ui, Some(egui::TextWrapMode::Extend), f32::INFINITY, font_id);

    let extra_width = if closable { close_size + close_gap } else { 0.0 };
    let desired = egui::vec2(
        galley.size().x + padding.x * 2.0 + extra_width,
        ui.available_height().max(galley.size().y + padding.y * 2.0),
    );

    let (_, rect) = ui.allocate_space(desired);

    let sense = if draggable { egui::Sense::click_and_drag() } else { egui::Sense::click() };
    let response = ui.interact(rect, id, sense);
    let response = if draggable {
        response.on_hover_cursor(egui::CursorIcon::Grab)
    } else {
        response
    };

    response.widget_info(|| {
        egui::WidgetInfo::selected(egui::WidgetType::Button, ui.is_enabled(), selected, galley.text())
    });

    let mut close_clicked = false;

    if ui.is_rect_visible(rect) {
        let visuals = ui.style().interact(&response);

        ui.painter().rect(rect, 4.0, visuals.bg_fill, visuals.bg_stroke, egui::StrokeKind::Inside);

        let text_color = if selected {
            egui::Color32::WHITE
        } else {
            egui::Color32::DARK_GRAY
        };

        let text_pos = egui::pos2(rect.min.x + padding.x, rect.center().y - galley.size().y / 2.0);
        ui.painter().galley(text_pos, galley, text_color);

        if closable {
            let close_rect = egui::Rect::from_min_size(
                egui::pos2(rect.max.x - padding.x - close_size, rect.center().y - close_size / 2.0),
                egui::vec2(close_size, close_size),
            );
            let close_id = id.with("close");
            let close_response = close_button_at(ui, close_rect, close_id);

            close_clicked = close_response.clicked() || response.clicked_by(egui::PointerButton::Middle);
        }
    }

    TabResponse { response, close_clicked }
}