Charts I: components 101-120

waterfall_chart.go

@@ -0,0 +1,125 @@
+package mujica
+
+import (
+	"math"
+
+	"github.com/egoist/mygo/ui"
+
+	"mujicaui/internal"
+	"mujicaui/theme"
+)
+
+// WaterfallKind says how a step's bar is drawn.
+type WaterfallKind int
+
+const (
+	// WaterfallDelta adds Value to the running total.
+	WaterfallDelta WaterfallKind = iota
+	// WaterfallSubtotal shows the running total; its Value must be zero.
+	WaterfallSubtotal
+	// WaterfallTotal shows the final total; Value must be zero.
+	WaterfallTotal
+)
+
+// WaterfallStep is one bar of a WaterfallChart.
+type WaterfallStep struct {
+	Label string
+	Value float64
+	Kind  WaterfallKind
+}
+
+// WaterfallChartOptions configure a WaterfallChart.
+type WaterfallChartOptions struct {
+	Frame  ChartFrame
+	Format func(v float64) string
+}
+
+// WaterfallChart builds a total from rises and falls.
+func WaterfallChart(c *ui.Context, steps []WaterfallStep, opts WaterfallChartOptions) ChartResult {
+	from, to := make([]float64, len(steps)), make([]float64, len(steps))
+	run, lo, hi := 0.0, 0.0, 0.0
+	for i, s := range steps {
+		if s.Label == "" || math.IsNaN(s.Value) || math.IsInf(s.Value, 0) || s.Kind != WaterfallDelta && s.Value != 0 || s.Kind > WaterfallTotal {
+			panic("mujica: WaterfallChart steps need a label, a finite value, and zero for totals")
+		}
+		if s.Kind == WaterfallDelta {
+			from[i], to[i], run = run, run+s.Value, run+s.Value
+		} else {
+			from[i], to[i] = 0, run
+		}
+		lo, hi = min(lo, from[i], to[i]), max(hi, from[i], to[i])
+	}
+	ch := newChart(c, opts.Frame)
+	k := Tokens(c)
+	size := FontSize(c, theme.CaptionSize)
+	var step float64
+	if len(steps) > 0 {
+		pad := (hi - lo) * 0.12
+		lo, hi, step = internal.Nice(lo-pad*chartBool(lo < 0), hi+pad, 4)
+	}
+	val := func(v float64) string { return chartValue(c, v, opts.Format) }
+	signed := func(v float64) string {
+		if v >= 0 {
+			return "+" + val(v)
+		}
+		return "−" + val(-v)
+	}
+	geom := func(r ui.Rect) (ui.Rect, internal.Band, internal.Linear) {
+		plot := chartInset(r, 52, 26)
+		return plot, internal.Band{N: len(steps), R0: plot.X, R1: plot.X + plot.W, Pad: 0.3},
+			internal.Linear{D0: lo, D1: hi, R0: float64(plot.Y + plot.H), R1: float64(plot.Y)}
+	}
+	spec := chartSpec{n: len(steps)}
+	spec.readout = func(i int) string {
+		if steps[i].Kind != WaterfallDelta {
+			return steps[i].Label + " · " + val(to[i])
+		}
+		return steps[i].Label + " · " + signed(steps[i].Value) + " · " + msg(c, "waterfall_chart.running") + " " + val(to[i])
+	}
+	spec.pick = func(r ui.Rect, x, y float32) int {
+		plot, band, _ := geom(r)
+		if !plot.Contains(x, y) {
+			return -1
+		}
+		return min(len(steps)-1, int((x-plot.X)/band.Step()))
+	}
+	spec.draw = func(p *ui.Painter, r ui.Rect, active int) {
+		plot, band, ys := geom(r)
+		internal.AxisY(p, plot, ys, internal.Ticks(lo, hi, step), func(v float64) string { return internal.FormatTick(v, step) }, size, k)
+		var xs []float32
+		var names []string
+		for i, s := range steps {
+			xs, names = append(xs, band.Center(i)), append(names, s.Label)
+		}
+		internal.AxisX(p, plot, xs, names, size, k)
+		internal.Rule(p, plot.X, plot.X+plot.W, ys.Map(0), k.ControlBorder)
+		for i, s := range steps {
+			a, b := ys.Map(from[i]), ys.Map(to[i])
+			bar := ui.Rect{X: band.Start(i), Y: min(a, b), W: band.Width(), H: max(abs32(a-b), 1)}
+			col, shape, text := internal.Palette(k)[5], 1, val(to[i])
+			switch {
+			case s.Kind != WaterfallDelta:
+			case s.Value >= 0:
+				col, shape, text = k.Success, 3, signed(s.Value)
+			default:
+				col, shape, text = k.Danger, 4, signed(s.Value)
+			}
+			p.Fill(bar, col, 1)
+			internal.Marker(p, shape, bar.X+bar.W/2, bar.Y-14+(bar.H+28)*float32(chartBool(s.Kind == WaterfallDelta && s.Value < 0)), 8, col)
+			ty, ay := bar.Y-22, float32(1)
+			if s.Kind == WaterfallDelta && s.Value < 0 {
+				ty, ay = bar.Y+bar.H+22, 0
+			}
+			chartText(p, text, bar.X+bar.W/2, ty, size, k.Text, 0.5, ay)
+			if i+1 < len(steps) {
+				y := internal.Snap(p, ys.Map(to[i]))
+				p.Line(bar.X+bar.W, y, band.Start(i+1), y, 1, k.TextMuted)
+			}
+			if i == active {
+				p.Stroke(ui.Rect{X: bar.X - 2, Y: bar.Y - 2, W: bar.W + 4, H: bar.H + 4}, k.Text, 2, 1.5)
+			}
+		}
+	}
+	res, _ := ch.build(spec)
+	return res
+}