functora-egui 0.4.2

shadcn/ui-inspired widget library for egui - buttons, inputs, selects, dialogs, and 70+ more components with light/dark theming
Documentation
use egui::{CornerRadius, CursorIcon, Painter, Rect, Sense, Stroke, Ui, pos2, vec2};
use functora_core::i18n::Language;

use crate::icons::lucide_icon::LucideIcon;
use crate::icons::paint_icon::paint_icon;
use crate::nav::NavHistory;
use crate::route::{RouteMetadata, breadcrumbs_for};
use crate::theme::shadcn_theme_ext::ShadcnThemeExt;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NavAction<R> {
    Back,
    Forward,
    Route(R),
}

#[must_use]
pub struct Breadcrumb<'a, R: RouteMetadata> {
    route: &'a R,
    history: &'a NavHistory<R>,
    separator: String,
}

impl<'a, R: RouteMetadata> Breadcrumb<'a, R> {
    pub fn new(route: &'a R, history: &'a NavHistory<R>) -> Self {
        Self {
            route,
            history,
            separator: "/".into(),
        }
    }

    pub fn separator(mut self, s: impl Into<String>) -> Self {
        self.separator = s.into();
        self
    }

    pub fn show(&self, ui: &mut Ui, lang: Language) -> Option<NavAction<R>> {
        let theme = ShadcnThemeExt::shadcn_theme(ui.ctx());
        let mut action = None;

        let font_id = egui::FontId::proportional(14.0);
        let sample_galley = crate::text::layout(
            ui,
            "A".to_owned(),
            font_id.clone(),
            theme.foreground,
            ui.available_width(),
            None,
        );
        let pill_height = sample_galley.size().y + 8.0;
        let btn_side = pill_height;
        let icon_side = btn_side * 0.6;

        let _ = ui.horizontal_wrapped(|ui_inner| {
            ui_inner.spacing_mut().item_spacing.x = 4.0;
            // Breadcrumb segments should stay single-line with truncation
            // for consistent row height when wrapping on narrow screens.
            ui_inner.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);

            if self.history.can_go_back() {
                let (rect, mut response) =
                    ui_inner.allocate_exact_size(vec2(btn_side, btn_side), Sense::click());
                response = response.on_hover_cursor(CursorIcon::PointingHand);
                if response.clicked() {
                    action = Some(NavAction::Back);
                }
                if response.hovered() {
                    paint_hover_bg(ui_inner.painter(), &rect, theme.accent);
                }
                let icon_rect = Rect::from_center_size(rect.center(), vec2(icon_side, icon_side));
                paint_icon(
                    ui_inner.painter(),
                    icon_rect,
                    &LucideIcon::ArrowLeft,
                    theme.foreground,
                );
            }

            let segments = breadcrumbs_for(self.route, lang);
            for (idx, seg) in segments.iter().enumerate() {
                let is_last = idx == segments.len() - 1;
                let sense = if is_last {
                    Sense::hover()
                } else {
                    Sense::click()
                };

                let padding = vec2(8.0, 4.0);
                let galley = crate::text::layout(
                    ui_inner,
                    seg.name.clone(),
                    font_id.clone(),
                    theme.foreground,
                    (ui_inner.available_width() - padding.x * 2.0).max(0.0),
                    None,
                );
                let desired = galley.size() + padding * 2.0;

                let (rect, response) = ui_inner.allocate_at_least(desired, sense);

                if is_last {
                    let base_color = theme.foreground;
                    let text_pos = pos2(
                        rect.min.x + padding.x,
                        rect.center().y - galley.size().y / 2.0,
                    );
                    ui_inner.painter().galley(text_pos, galley, base_color);
                } else {
                    if response.hovered() {
                        ui_inner.ctx().set_cursor_icon(CursorIcon::PointingHand);
                    }
                    if response.clicked() {
                        action = Some(NavAction::Route(seg.route.clone()));
                    }
                    let hovered = response.hovered();
                    let pressed = response.is_pointer_button_down_on();
                    let color = if pressed {
                        theme.foreground
                    } else if hovered {
                        theme.accent_foreground
                    } else {
                        theme.foreground
                    };

                    if hovered || pressed {
                        let bg = if pressed {
                            crate::paint::interpolate_color::interpolate_color(
                                theme.accent,
                                theme.primary,
                                0.12,
                            )
                        } else {
                            theme.accent
                        };
                        paint_hover_bg(ui_inner.painter(), &rect, bg);
                    }

                    let galley_for_text = galley.clone();
                    let text_pos = pos2(
                        rect.min.x + padding.x,
                        rect.center().y - galley_for_text.size().y / 2.0,
                    );
                    ui_inner.painter().galley(text_pos, galley, color);

                    if hovered {
                        let underline_y = text_pos.y + galley_for_text.size().y;
                        let _ = ui_inner.painter().hline(
                            text_pos.x..=text_pos.x + rect.width() - padding.x * 2.0,
                            underline_y,
                            Stroke::new(1.0, color),
                        );
                    }
                }

                if !is_last {
                    let _ = ui_inner.label(
                        egui::RichText::new(&self.separator)
                            .color(theme.muted_foreground)
                            .size(14.0),
                    );
                }
            }

            if self.history.can_go_forward() {
                let (rect, mut response) =
                    ui_inner.allocate_exact_size(vec2(btn_side, btn_side), Sense::click());
                response = response.on_hover_cursor(CursorIcon::PointingHand);
                if response.clicked() {
                    action = Some(NavAction::Forward);
                }
                if response.hovered() {
                    paint_hover_bg(ui_inner.painter(), &rect, theme.accent);
                }
                let icon_rect = Rect::from_center_size(rect.center(), vec2(icon_side, icon_side));
                paint_icon(
                    ui_inner.painter(),
                    icon_rect,
                    &LucideIcon::ArrowRight,
                    theme.foreground,
                );
            }
        });

        action
    }
}

fn paint_hover_bg(painter: &Painter, rect: &Rect, color: egui::Color32) {
    let _ = painter.rect_filled(*rect, CornerRadius::same(4), color);
}