Trading charts

// crosshair builds the hover behaviour both panes share: crosshair lines
// with value tags on the axes, and a text box only when the user clicks.
crosshair := func(yTag string, text func(i int) string) *component.TooltipConfig {
	return &component.TooltipConfig{
		Trigger:       component.TooltipTriggerAxis,
		Crosshair:     component.CrosshairBoth,
		CrosshairOnly: true, // no text box while hovering; click to pin one
		ShowAxisTags:  true, // value tags where the crosshair meets the axes
		AxisTagFormatter: func(x, y float64) (string, string) {
			i := int(math.Round(x))
			if i < 0 || i >= len(dates) {
				return "", ""
			}
			return dates[i], fmt.Sprintf(yTag, y)
		},
		Formatter: func(hits []interact.HitResult) string {
			return text(hits[0].DataIndex)
		},
	}
}
priceTip := crosshair("%.2f", func(i int) string {
	c := candles[i]
	return fmt.Sprintf("%s\nO %.2f  H %.2f\nL %.2f  C %.2f", dates[i], c.Open, c.High, c.Low, c.Close)
})
volTip := crosshair("%.1fM", func(i int) string {
	return fmt.Sprintf("%s\nVolume %.1fM", dates[i], volume[i])
})
grid := func(top, bottom float32) *chart.Grid {
	// Same left and right margins in every pane, so the plots line up.
	return &chart.Grid{Left: 64, Right: 24, Top: top, Bottom: bottom}
}

// Axis tooltips only find line-like series, not candles or bars, so each
// pane carries an invisible line through the values to hover on.
hidden := series.LineStyle{Color: color.Transparent}
closes := make([]float64, len(candles))
for i, c := range candles {
	closes[i] = c.Close
}

price := chart.New(chart.Option{
	Title:    &chart.Title{Text: "ACME", SubText: "Daily, 10- and 30-day moving averages"},
	Tooltip:  priceTip,
	DataZoom: &interact.ZoomConfig{Enabled: true, MinSpan: 0.1, MaxSpan: 1, ZoomSensitivity: 0.08},
	Grid:     grid(12, 30),
	Color: []color.Color{
		color.NRGBA{R: 120, G: 120, B: 120, A: 255}, // legend swatch for the candles
		color.Transparent,
		color.NRGBA{R: 255, G: 167, B: 38, A: 255}, // MA10
		color.NRGBA{R: 66, G: 165, B: 245, A: 255}, // MA30
	},
	XAxis: []axis.Config{{Type: axis.TypeCategory, Data: make([]string, len(dates))}},
	YAxis: []axis.Config{{Type: axis.TypeValue, SplitCount: 5}},
	Series: []series.Series{
		&series.CandlestickSeries{SeriesName: "ACME", Data: candles, BarWidth: 0.7},
		&series.LineSeries{Data: closes, LineStyle: hidden}, // no name: not in the legend
		&series.LineSeries{SeriesName: "MA10", Data: movingAverage(candles, 10)},
		&series.LineSeries{SeriesName: "MA30", Data: movingAverage(candles, 30)},
	},
})

vol := chart.New(chart.Option{
	Tooltip: volTip,
	// Enabled: false gives the pane a zoom window that follows the group,
	// without its own zoom buttons.
	DataZoom: &interact.ZoomConfig{Enabled: false, MinSpan: 0.1, MaxSpan: 1},
	Grid:     grid(6, 26),
	XAxis:    []axis.Config{{Type: axis.TypeCategory, Data: sparse}},
	YAxis:    []axis.Config{{Type: axis.TypeValue, SplitCount: 2}},
	Series: []series.Series{
		&series.BarSeries{Data: volume, BarWidth: 0.7},
		&series.LineSeries{Data: volume, LineStyle: hidden},
	},
})

group := chart.NewChartGroup(
	chart.Pane{Chart: price, Height: 3},
	chart.Pane{Chart: vol, Height: 1},
)

// movingAverage returns the simple moving average of the closes over n days.
// The first n-1 values are NaN, which a line series leaves undrawn.
func movingAverage(candles []series.CandlestickData, n int) []float64 {
	out := make([]float64, len(candles))
	sum := 0.0
	for i, c := range candles {
		sum += c.Close
		if i >= n {
			sum -= candles[i-n].Close
		}
		if i < n-1 {
			out[i] = math.NaN()
		} else {
			out[i] = sum / float64(n)
		}
	}
	return out
}

// setTooltip swaps the price pane's tooltip, keeping the rest of its option.
setTooltip := func(cfg *component.TooltipConfig) {
	opt := price.Option()
	opt.Tooltip = cfg
	price.SetOption(opt)
}
noTooltip := &component.TooltipConfig{Trigger: component.TooltipTriggerNone}

// Crosshair: plain viewing. Select: click a drawing to select it, drag it
// to move it, press Delete to remove it. A click on a chart that shows a
// tooltip pins the tooltip instead of selecting, so Select turns it off.
crosshairMode := func() {
	price.SetDrawingTool(interact.DrawingToolNone)
	setTooltip(priceTip)
	status.SetText("Crosshair")
}
selectMode := func() {
	price.SetDrawingTool(interact.DrawingToolNone)
	setTooltip(noTooltip)
	status.SetText("Select: click a drawing, drag to move, Delete to remove")
}
bar := container.NewHBox(
	widget.NewButton("Crosshair", crosshairMode),
	widget.NewButton("Select", selectMode),
)
tools := []struct {
	label string
	tool  interact.DrawingToolMode
}{
	{"H-line", interact.DrawingToolHLine},
	{"V-line", interact.DrawingToolVLine},
	{"Trend", interact.DrawingToolTrendLine},
	{"Ray", interact.DrawingToolRay},
	{"Rect", interact.DrawingToolRectangle},
	{"Channel", interact.DrawingToolChannel},
	{"Fib", interact.DrawingToolFibRetracement},
	{"Text", interact.DrawingToolTextLabel},
	{"Measure", interact.DrawingToolMeasure},
}
for _, t := range tools {
	bar.Add(widget.NewButton(t.label, func() {
		setTooltip(priceTip)
		price.SetDrawingTool(t.tool)
		status.SetText("Tool: " + t.label)
	}))
}
bar.Add(widget.NewButton("Clear", price.ClearDrawings))

price.Events.On(interact.EventDrawingCreated, func(evt interface{}) {
	e := evt.(interact.DrawingEvent)
	// Tools stay active after a drawing. The new drawing is selected,
	// so switch to Select mode to let the user move or delete it.
	selectMode()
	status.SetText(fmt.Sprintf("Created %s at %v", e.DrawingID, e.Drawing.DataPoints()))
})
price.Events.On(interact.EventDrawingSelected, func(evt interface{}) {
	status.SetText(fmt.Sprintf("Selected %s", evt.(interact.DrawingEvent).DrawingID))
})
price.Events.On(interact.EventDrawingDeleted, func(evt interface{}) {
	status.SetText(fmt.Sprintf("Deleted %s", evt.(interact.DrawingEvent).DrawingID))
})

// X is the category index (0 is the first candle), Y is the price.
high1, high2 := extreme(data, 0, 40, true), extreme(data, 70, 100, true)
low1, low2 := extreme(data, 40, 70, false), extreme(data, 100, 120, false)
orange := color.NRGBA{R: 255, G: 152, B: 0, A: 230}
blue := color.NRGBA{R: 66, G: 165, B: 245, A: 230}

c.AddDrawing(&interact.HLineDrawing{
	DrawingBase: interact.DrawingBase{ID_: "resistance", Label_: "Resistance"},
	Y:           high1.Y,
})
c.AddDrawing(&interact.TrendLineDrawing{
	DrawingBase: interact.DrawingBase{ID_: "highs", Color_: orange},
	Start:       high1,
	End:         high2,
})
c.AddDrawing(&interact.RayDrawing{
	DrawingBase: interact.DrawingBase{ID_: "lows", Color_: blue},
	Start:       low1,
	Direction:   low2, // the ray runs from Start through this point
})
c.AddDrawing(&interact.RectangleDrawing{
	DrawingBase: interact.DrawingBase{ID_: "base", Color_: blue},
	Corner1:     interact.DataPoint{X: 45, Y: extreme(data, 45, 65, true).Y},
	Corner2:     interact.DataPoint{X: 65, Y: extreme(data, 45, 65, false).Y},
})
c.AddDrawing(&interact.FibRetracementDrawing{
	DrawingBase: interact.DrawingBase{ID_: "fib"},
	HighY:       high2.Y,
	LowY:        low2.Y,
	X:           high2.X,
})
c.AddDrawing(&interact.TextLabelDrawing{
	DrawingBase: interact.DrawingBase{ID_: "note", Color_: orange},
	Pos:         interact.DataPoint{X: high2.X - 6, Y: high2.Y + 1.5},
	Text:        "Lower high",
})

// saved is one drawing in a form that encoding/json can write and read.
type saved struct {
	Tool   interact.DrawingToolMode
	Points []interact.DataPoint
	Label  string      `json:",omitempty"`
	Text   string      `json:",omitempty"` // text labels only
	Color  *color.NRGBA `json:",omitempty"`
}

func save(drawings []interact.Drawing) ([]byte, error) {
	out := make([]saved, 0, len(drawings))
	for _, d := range drawings {
		s := saved{Tool: d.Type(), Points: d.DataPoints(), Label: d.DrawingLabel()}
		if t, ok := d.(*interact.TextLabelDrawing); ok {
			s.Text = t.Text
		}
		if c := d.DrawingColor(); c != nil {
			n := color.NRGBAModel.Convert(c).(color.NRGBA)
			s.Color = &n
		}
		out = append(out, s)
	}
	return json.Marshal(out)
}

func restore(data []byte) ([]interact.Drawing, error) {
	var in []saved
	if err := json.Unmarshal(data, &in); err != nil {
		return nil, err
	}
	var out []interact.Drawing
	for i, s := range in {
		// Use IDs of your own: the chart numbers the drawings the user makes
		// "drawing-1", "drawing-2"... and does not skip IDs already in use.
		base := interact.DrawingBase{ID_: interact.DrawingID(fmt.Sprintf("saved-%d", i+1)), Label_: s.Label}
		if s.Color != nil {
			base.Color_ = *s.Color
		}
		var d interact.Drawing
		switch s.Tool {
		case interact.DrawingToolHLine:
			d = &interact.HLineDrawing{DrawingBase: base}
		case interact.DrawingToolVLine:
			d = &interact.VLineDrawing{DrawingBase: base}
		case interact.DrawingToolTrendLine:
			d = &interact.TrendLineDrawing{DrawingBase: base}
		case interact.DrawingToolRay:
			d = &interact.RayDrawing{DrawingBase: base}
		case interact.DrawingToolRectangle:
			d = &interact.RectangleDrawing{DrawingBase: base}
		case interact.DrawingToolChannel:
			d = &interact.ChannelDrawing{DrawingBase: base}
		case interact.DrawingToolFibRetracement:
			d = &interact.FibRetracementDrawing{DrawingBase: base}
		case interact.DrawingToolTextLabel:
			d = &interact.TextLabelDrawing{DrawingBase: base, Text: s.Text}
		default:
			continue
		}
		d.SetDataPoints(s.Points)
		out = append(out, d)
	}
	return out, nil
}

saveBtn := widget.NewButton("Save", func() {
	b, err := save(c.Drawings())
	if err != nil {
		status.SetText(err.Error())
		return
	}
	stored = b // a real app writes this to a file or to preferences
	status.SetText(fmt.Sprintf("Saved %d drawings, %d bytes of JSON", len(c.Drawings()), len(b)))
})
clearBtn := widget.NewButton("Clear", func() {
	c.ClearDrawings()
	status.SetText("Cleared")
})
restoreBtn := widget.NewButton("Restore", func() {
	ds, err := restore(stored)
	if err != nil {
		status.SetText(err.Error())
		return
	}
	c.ClearDrawings()
	for _, d := range ds {
		c.AddDrawing(d)
	}
	status.SetText(fmt.Sprintf("Restored %d drawings", len(ds)))
})