guise/chart/

bar.rs

//! `BarChart` — vertical bars over a value series, with optional category
//! labels below the bars.
//!
//! ```ignore
//! use guise::chart::BarChart;
//!
//! BarChart::entries([("Mon", 12.0), ("Tue", 9.0), ("Wed", 15.0)]).gap(0.3)
//! ```

use gpui::prelude::*;
use gpui::{
    canvas, div, fill, point, px, size, App, Bounds, Hsla, IntoElement, SharedString, Window,
};

use crate::style::ColorValue;
use crate::theme::theme;

use super::axis::nice_ticks;
use super::frame::{hover_slots, x_label_row, y_axis_column};
use super::{bar_heights, bar_slot, series_color, tick_label};
use crate::devtools::Probed;

/// A vertical bar chart. Bars scale against the largest value with the
/// baseline at zero; negative values clamp to zero (no downward bars in v1).
/// Bar colors rotate through the theme palette by default.
#[derive(IntoElement)]
pub struct BarChart {
    values: Vec<f32>,
    labels: Vec<SharedString>,
    colors: Vec<ColorValue>,
    gap: f32,
    axis: bool,
    hover: bool,
    width: Option<f32>,
    height: f32,
}

impl BarChart {
    pub fn new(values: impl IntoIterator<Item = f32>) -> Self {
        BarChart {
            values: values.into_iter().collect(),
            labels: Vec::new(),
            colors: Vec::new(),
            gap: 0.2,
            axis: false,
            hover: false,
            width: None,
            height: 140.0,
        }
    }

    /// Build from `(label, value)` pairs; labels render below the bars.
    pub fn entries(entries: impl IntoIterator<Item = (impl Into<SharedString>, f32)>) -> Self {
        let (labels, values): (Vec<SharedString>, Vec<f32>) = entries
            .into_iter()
            .map(|(label, value)| (label.into(), value))
            .unzip();
        BarChart {
            labels,
            ..BarChart::new(values)
        }
    }

    /// One color for every bar (disables the palette rotation).
    pub fn color(mut self, color: impl Into<ColorValue>) -> Self {
        self.colors = vec![color.into()];
        self
    }

    /// Per-bar colors, cycled when shorter than the series.
    pub fn colors(mut self, colors: impl IntoIterator<Item = impl Into<ColorValue>>) -> Self {
        self.colors = colors.into_iter().map(Into::into).collect();
        self
    }

    /// Fraction of each bar slot left empty, `0.0..=0.9` (default 0.2).
    pub fn gap(mut self, gap: f32) -> Self {
        self.gap = gap.clamp(0.0, 0.9);
        self
    }

    /// Show a y-axis: nice-number ticks from zero, gridlines aligned to
    /// them, bars scaled against the top tick.
    pub fn axis(mut self) -> Self {
        self.axis = true;
        self
    }

    /// Show each bar's value in a tooltip on hover.
    pub fn hover(mut self) -> Self {
        self.hover = true;
        self
    }

    /// Fixed width in px. Defaults to the parent's full width.
    pub fn width(mut self, width: f32) -> Self {
        self.width = Some(width);
        self
    }

    /// Plot height in px (default 140), excluding the label row.
    pub fn height(mut self, height: f32) -> Self {
        self.height = height;
        self
    }
}

impl RenderOnce for BarChart {
    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
        let t = theme(cx);
        let n = self.values.len();
        let bar_colors: Vec<Hsla> = (0..n).map(|i| series_color(t, &self.colors, i)).collect();
        let grid = t.border().alpha(0.5);
        let gap = self.gap;

        // Axis mode scales bars against the top nice tick (so the tallest
        // bar lines up with a labeled gridline); otherwise against the max.
        let ticks = if self.axis {
            let max = self.values.iter().copied().fold(0.0_f32, f32::max);
            nice_ticks(0.0, max.max(1.0), 4)
        } else {
            Vec::new()
        };
        let fracs: Vec<f32> = match ticks.last() {
            Some(&top) if top > 0.0 => self
                .values
                .iter()
                .map(|&v| {
                    if v.is_finite() {
                        (v.max(0.0) / top).min(1.0)
                    } else {
                        0.0
                    }
                })
                .collect(),
            _ => bar_heights(&self.values),
        };
        let gridline_count = ticks.len();

        let plot = canvas(
            |_, _, _| (),
            move |bounds, _, window, _cx| {
                let w = f32::from(bounds.size.width);
                let h = f32::from(bounds.size.height);
                if w <= 0.0 || h <= 0.0 {
                    return;
                }
                for i in 0..gridline_count {
                    let y = (h - 1.0) * (i as f32 / (gridline_count - 1).max(1) as f32);
                    window.paint_quad(fill(
                        Bounds::new(bounds.origin + point(px(0.0), px(y)), size(px(w), px(1.0))),
                        grid,
                    ));
                }
                for (i, frac) in fracs.iter().enumerate() {
                    let bh = h * frac;
                    if bh <= 0.0 {
                        continue;
                    }
                    let (x, bw) = bar_slot(i, fracs.len(), w, gap);
                    window.paint_quad(fill(
                        Bounds::new(
                            bounds.origin + point(px(x), px(h - bh)),
                            size(px(bw), px(bh)),
                        ),
                        bar_colors[i],
                    ));
                }
            },
        )
        .w_full()
        .h(px(self.height));

        // Per-bar hover readouts layered over the plot.
        let mut plot_wrap = div().relative().w_full().child(plot);
        if self.hover && n > 0 {
            let texts: Vec<SharedString> = (0..n)
                .map(|i| {
                    let value = tick_label(self.values[i]);
                    match self.labels.get(i) {
                        Some(label) => format!("{label}: {value}").into(),
                        None => value.into(),
                    }
                })
                .collect();
            plot_wrap = plot_wrap.child(hover_slots("guise-barchart-hover".into(), texts));
        }

        let mut plot_column = div()
            .flex_1()
            .flex()
            .flex_col()
            .gap(px(4.0))
            .child(plot_wrap);
        // Category labels: one equal-width cell per bar slot, so the row lines
        // up with the bars painted above. Plain divs — no canvas text in v1.
        if !self.labels.is_empty() && n > 0 {
            plot_column = plot_column.child(x_label_row(t, &self.labels));
        }

        let mut body = div().flex().flex_row();
        body = match self.width {
            Some(w) => body.w(px(w)),
            None => body.w_full(),
        };
        if self.axis {
            body = body.child(y_axis_column(t, &ticks, self.height));
        }
        body.child(plot_column).probe("BarChart")
    }
}