functora-egui 0.2.0

shadcn/ui-inspired widget library for egui - buttons, inputs, selects, dialogs, and 70+ more components with light/dark theming
Documentation
//! Show method for Table — renders a styled data table.

#[derive(Clone, Copy)]
struct RowStyle {
    bg: egui::Color32,
    fg: egui::Color32,
    corners: egui::CornerRadius,
}

impl super::widget::Table {
    /// Shows the table. Returns the response for the outer frame.
    pub fn show(self, ui: &mut egui::Ui) -> egui::Response {
        let theme = crate::theme::shadcn_theme_ext::ShadcnThemeExt::shadcn_theme(ui.ctx());
        let cr = crate::utils::f32_to_u8_clamped(theme.radius);
        let inner = cr.saturating_sub(1);
        let top = egui::CornerRadius {
            nw: inner,
            ne: inner,
            sw: 0,
            se: 0,
        };
        let bottom = egui::CornerRadius {
            nw: 0,
            ne: 0,
            sw: inner,
            se: inner,
        };

        let frame = egui::Frame::NONE
            .fill(theme.card)
            .corner_radius(egui::CornerRadius::same(cr))
            .stroke(egui::Stroke::new(1.0, theme.border));

        frame
            .show(ui, |inner_ui| {
                // Remove default spacing so rows pack tightly against dividers
                inner_ui.spacing_mut().item_spacing = egui::vec2(0.0, 0.0);

                let col_count = self.headers.len();
                if col_count == 0 {
                    return;
                }

                let available = inner_ui.available_width();
                let col_widths =
                    compute_col_widths(available, col_count, self.col_weights.as_ref());

                // Header row
                Self::render_row(
                    inner_ui,
                    &self.headers,
                    &col_widths,
                    available,
                    true,
                    RowStyle {
                        bg: theme.muted,
                        fg: theme.muted_foreground,
                        corners: if self.rows.is_empty() {
                            egui::CornerRadius::same(inner)
                        } else {
                            top
                        },
                    },
                );

                // Divider after header
                Self::draw_hline(inner_ui, available, &theme);

                // Data rows
                for (row_idx, row) in self.rows.iter().enumerate() {
                    let bg = if self.striped && row_idx % 2 == 1 {
                        theme.muted
                    } else {
                        egui::Color32::TRANSPARENT
                    };

                    Self::render_row(
                        inner_ui,
                        row,
                        &col_widths,
                        available,
                        false,
                        RowStyle {
                            bg,
                            fg: theme.foreground,
                            corners: if row_idx + 1 == self.rows.len() {
                                bottom
                            } else {
                                egui::CornerRadius::ZERO
                            },
                        },
                    );

                    // Row divider (not after last)
                    if row_idx < self.rows.len() - 1 {
                        Self::draw_hline(inner_ui, available, &theme);
                    }
                }
            })
            .response
    }

    fn draw_hline(ui: &mut egui::Ui, width: f32, theme: &crate::theme::shadcn_theme::ShadcnTheme) {
        let (line_rect, _) = ui.allocate_exact_size(egui::vec2(width, 1.0), egui::Sense::hover());
        let _ = ui.painter().hline(
            line_rect.x_range(),
            line_rect.center().y,
            egui::Stroke::new(1.0, theme.border),
        );
    }

    fn render_row(
        ui: &mut egui::Ui,
        cells: &[String],
        col_widths: &[f32],
        total_width: f32,
        is_header: bool,
        style: RowStyle,
    ) {
        let theme = crate::theme::shadcn_theme_ext::ShadcnThemeExt::shadcn_theme(ui.ctx());
        let base_height: f32 = if is_header { 40.0 } else { 44.0 };
        let font_size: f32 = if is_header { 13.0 } else { 14.0 };

        let galleys: Vec<_> = cells
            .iter()
            .enumerate()
            .map(|(idx, cell)| {
                let col_w = col_widths.get(idx).copied().unwrap_or(100.0);
                let wrap_w = (col_w - 24.0).max(40.0);
                ui.painter().layout(
                    cell.clone(),
                    egui::FontId::proportional(font_size),
                    style.fg,
                    wrap_w,
                )
            })
            .collect();
        let content_h = galleys.iter().map(|g| g.size().y).fold(0.0_f32, f32::max);
        let height = base_height.max(content_h + 16.0);

        let (row_rect, response) =
            ui.allocate_exact_size(egui::vec2(total_width, height), egui::Sense::hover());

        let actual_bg = if !is_header && response.hovered() {
            theme.accent
        } else {
            style.bg
        };

        if actual_bg != egui::Color32::TRANSPARENT {
            let _ = ui.painter().rect_filled(row_rect, style.corners, actual_bg);
        }

        let mut x_offset = 0.0;
        for (col_idx, galley) in galleys.into_iter().enumerate() {
            let col_w = col_widths.get(col_idx).copied().unwrap_or(100.0);
            let text_pos = egui::pos2(
                row_rect.min.x + x_offset + 12.0,
                row_rect.center().y - galley.size().y / 2.0,
            );
            ui.painter().galley(text_pos, galley, style.fg);

            x_offset += col_w;
        }
    }
}

fn compute_col_widths(total: f32, col_count: usize, weights: Option<&Vec<f32>>) -> Vec<f32> {
    match weights {
        Some(w) if w.len() == col_count => {
            let sum: f32 = w.iter().sum();
            if sum > 0.0 {
                w.iter().map(|&wt| total * wt / sum).collect()
            } else {
                vec![total / crate::utils::usize_to_f32(col_count); col_count]
            }
        }
        _ => vec![total / crate::utils::usize_to_f32(col_count); col_count],
    }
}