T14a Tables core: DataTable, Table, HeatmapTable, cells, Sparkline (review pending: codex 401)

src/data_display/mod.rs

@@ -9,6 +9,7 @@ mod feed;
 mod gallery;
 mod measures;
 mod records;
+mod spark;
 mod stars;
 mod stat;
 #[cfg(test)]
@@ -27,6 +28,7 @@ pub use feed::{Activity, ActivityFeed};
 pub use gallery::Gallery;
 pub use measures::{Gauge, Meter, UsageBar};
 pub use records::{DescriptionList, PropertyGrid, PropertyGroup};
+pub use spark::Sparkline;
 pub use stars::Stars;
 pub(crate) use stars::star;
 pub use stat::{KpiCard, Statistic, TrendIndicator};

src/data_display/spark.rs

@@ -0,0 +1,163 @@
+use gpui::{
+    App, Bounds, Div, Hsla, IntoElement, ParentElement, PathBuilder, Pixels, Refineable,
+    RenderOnce, StyleRefinement, Styled, Window, canvas, div, fill, point, size,
+};
+
+use crate::theme::ActiveTheme;
+
+/// How a sparkline draws its series.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Spark {
+    Line,
+    Area,
+    Bars,
+}
+
+/// Each value's height as a share of the series' own range; a flat series sits in the middle.
+fn shares(values: &[f32]) -> Vec<f32> {
+    let (low, high) = values.iter().fold((f32::MAX, f32::MIN), |(low, high), v| {
+        (low.min(*v), high.max(*v))
+    });
+    let span = high - low;
+    values
+        .iter()
+        .map(|value| {
+            if span > 0.0 {
+                (value - low) / span
+            } else {
+                0.5
+            }
+        })
+        .collect()
+}
+
+/// A word-sized chart of a series, scaled to its own range: a line, a filled area, or bars.
+#[derive(IntoElement)]
+pub struct Sparkline {
+    base: Div,
+    values: Vec<f32>,
+    spark: Spark,
+    color: Option<Hsla>,
+}
+
+impl Sparkline {
+    pub fn new(values: impl IntoIterator<Item = f32>) -> Self {
+        let values: Vec<f32> = values.into_iter().collect();
+        assert!(values.len() >= 2, "a sparkline needs two values");
+        assert!(
+            values.iter().all(|value| value.is_finite()),
+            "a sparkline needs finite values"
+        );
+        Self {
+            base: div(),
+            values,
+            spark: Spark::Line,
+            color: None,
+        }
+    }
+
+    /// The line with the area under it lightly filled.
+    pub fn area(mut self) -> Self {
+        self.spark = Spark::Area;
+        self
+    }
+
+    pub fn bars(mut self) -> Self {
+        self.spark = Spark::Bars;
+        self
+    }
+
+    /// Its ink; the foreground unless set.
+    pub fn color(mut self, color: Hsla) -> Self {
+        self.color = Some(color);
+        self
+    }
+}
+
+impl Styled for Sparkline {
+    fn style(&mut self) -> &mut StyleRefinement {
+        self.base.style()
+    }
+}
+
+impl RenderOnce for Sparkline {
+    fn render(mut self, _: &mut Window, cx: &mut App) -> impl IntoElement {
+        let theme = cx.theme();
+        let ink = self.color.unwrap_or(theme.colors.fg_muted);
+        let (heights, spark) = (shares(&self.values), self.spark);
+        let mut frame = div()
+            .flex_none()
+            .w(theme.spark_size().width)
+            .h(theme.spark_size().height);
+        frame.style().refine(self.base.style());
+        frame.child(
+            canvas(
+                |_, _, _| {},
+                move |bounds: Bounds<Pixels>, _, window, _| {
+                    let stroke = bounds.size.height / 12.0;
+                    let inner = bounds.size.height - stroke * 2.0;
+                    let count = heights.len() as f32;
+                    if spark == Spark::Bars {
+                        let slot = bounds.size.width / count;
+                        for (ix, share) in heights.iter().enumerate() {
+                            let tall = (inner * *share).max(stroke);
+                            let corner = point(
+                                bounds.left() + slot * ix as f32 + slot * 0.15,
+                                bounds.bottom() - tall,
+                            );
+                            window
+                                .paint_quad(fill(Bounds::new(corner, size(slot * 0.7, tall)), ink));
+                        }
+                        return;
+                    }
+                    let at = |ix: usize, share: f32| {
+                        point(
+                            bounds.left() + bounds.size.width * ix as f32 / (count - 1.0),
+                            bounds.top() + stroke + inner * (1.0 - share),
+                        )
+                    };
+                    if spark == Spark::Area {
+                        let mut area = PathBuilder::fill();
+                        area.move_to(point(bounds.left(), bounds.bottom()));
+                        for (ix, share) in heights.iter().enumerate() {
+                            area.line_to(at(ix, *share));
+                        }
+                        area.line_to(point(bounds.right(), bounds.bottom()));
+                        area.close();
+                        if let Ok(area) = area.build() {
+                            window.paint_path(area, ink.opacity(0.16));
+                        }
+                    }
+                    let mut line = PathBuilder::stroke(stroke);
+                    for (ix, share) in heights.iter().enumerate() {
+                        if ix == 0 {
+                            line.move_to(at(ix, *share));
+                        } else {
+                            line.line_to(at(ix, *share));
+                        }
+                    }
+                    match line.build() {
+                        Ok(line) => window.paint_path(line, ink),
+                        Err(error) => log::error!("sparkline: the line failed to build: {error:#}"),
+                    }
+                },
+            )
+            .size_full(),
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::shares;
+
+    #[test]
+    fn values_scale_to_their_own_range() {
+        assert_eq!(shares(&[2.0, 4.0, 3.0]), [0.0, 1.0, 0.5]);
+        assert_eq!(
+            shares(&[7.0, 7.0]),
+            [0.5, 0.5],
+            "a flat series sits in the middle"
+        );
+    }
+}