ntcharts 0.1.0-x86_64-linux-gnu

data/go/linechart.go

@@ -0,0 +1,441 @@
+package main
+
+/*
+#include <stdlib.h>
+*/
+import "C"
+
+import (
+	"github.com/NimbleMarkets/ntcharts/canvas"
+	"github.com/NimbleMarkets/ntcharts/canvas/runes"
+	"github.com/NimbleMarkets/ntcharts/linechart"
+)
+
+//export ntcharts_linechart_new
+func ntcharts_linechart_new(width C.int, height C.int, minX C.double, maxX C.double, minY C.double, maxY C.double) C.ulonglong {
+	m := linechart.New(int(width), int(height), float64(minX), float64(maxX), float64(minY), float64(maxY))
+	return C.ulonglong(allocLinechart(&m))
+}
+
+//export ntcharts_linechart_new_with_auto_range
+func ntcharts_linechart_new_with_auto_range(width C.int, height C.int) C.ulonglong {
+	m := linechart.New(int(width), int(height), 0, 1, 0, 1, linechart.WithAutoXYRange())
+	return C.ulonglong(allocLinechart(&m))
+}
+
+//export ntcharts_linechart_free
+func ntcharts_linechart_free(id C.ulonglong) {
+	freeLinechart(uint64(id))
+}
+
+//export ntcharts_linechart_width
+func ntcharts_linechart_width(id C.ulonglong) C.int {
+	l := getLinechart(uint64(id))
+	if l == nil {
+		return 0
+	}
+	return C.int(l.Width())
+}
+
+//export ntcharts_linechart_height
+func ntcharts_linechart_height(id C.ulonglong) C.int {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.int(l.Height())
+}
+
+//export ntcharts_linechart_graph_width
+func ntcharts_linechart_graph_width(id C.ulonglong) C.int {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.int(l.GraphWidth())
+}
+
+//export ntcharts_linechart_graph_height
+func ntcharts_linechart_graph_height(id C.ulonglong) C.int {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.int(l.GraphHeight())
+}
+
+//export ntcharts_linechart_min_x
+func ntcharts_linechart_min_x(id C.ulonglong) C.double {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.double(l.MinX())
+}
+
+//export ntcharts_linechart_max_x
+func ntcharts_linechart_max_x(id C.ulonglong) C.double {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.double(l.MaxX())
+}
+
+//export ntcharts_linechart_min_y
+func ntcharts_linechart_min_y(id C.ulonglong) C.double {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.double(l.MinY())
+}
+
+//export ntcharts_linechart_max_y
+func ntcharts_linechart_max_y(id C.ulonglong) C.double {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.double(l.MaxY())
+}
+
+//export ntcharts_linechart_view_min_x
+func ntcharts_linechart_view_min_x(id C.ulonglong) C.double {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.double(l.ViewMinX())
+}
+
+//export ntcharts_linechart_view_max_x
+func ntcharts_linechart_view_max_x(id C.ulonglong) C.double {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.double(l.ViewMaxX())
+}
+
+//export ntcharts_linechart_view_min_y
+func ntcharts_linechart_view_min_y(id C.ulonglong) C.double {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.double(l.ViewMinY())
+}
+
+//export ntcharts_linechart_view_max_y
+func ntcharts_linechart_view_max_y(id C.ulonglong) C.double {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.double(l.ViewMaxY())
+}
+
+//export ntcharts_linechart_x_step
+func ntcharts_linechart_x_step(id C.ulonglong) C.int {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.int(l.XStep())
+}
+
+//export ntcharts_linechart_y_step
+func ntcharts_linechart_y_step(id C.ulonglong) C.int {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return 0
+	}
+
+	return C.int(l.YStep())
+}
+
+//export ntcharts_linechart_set_x_step
+func ntcharts_linechart_set_x_step(id C.ulonglong, step C.int) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.SetXStep(int(step))
+	}
+}
+
+//export ntcharts_linechart_set_y_step
+func ntcharts_linechart_set_y_step(id C.ulonglong, step C.int) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.SetYStep(int(step))
+	}
+}
+
+//export ntcharts_linechart_set_x_range
+func ntcharts_linechart_set_x_range(id C.ulonglong, minVal C.double, maxVal C.double) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.SetXRange(float64(minVal), float64(maxVal))
+	}
+}
+
+//export ntcharts_linechart_set_y_range
+func ntcharts_linechart_set_y_range(id C.ulonglong, minVal C.double, maxVal C.double) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.SetYRange(float64(minVal), float64(maxVal))
+	}
+}
+
+//export ntcharts_linechart_set_view_x_range
+func ntcharts_linechart_set_view_x_range(id C.ulonglong, minVal C.double, maxVal C.double) C.int {
+	l := getLinechart(uint64(id))
+
+	if l != nil && l.SetViewXRange(float64(minVal), float64(maxVal)) {
+		return 1
+	}
+
+	return 0
+}
+
+//export ntcharts_linechart_set_view_y_range
+func ntcharts_linechart_set_view_y_range(id C.ulonglong, minVal C.double, maxVal C.double) C.int {
+	l := getLinechart(uint64(id))
+
+	if l != nil && l.SetViewYRange(float64(minVal), float64(maxVal)) {
+		return 1
+	}
+
+	return 0
+}
+
+//export ntcharts_linechart_set_auto_x_range
+func ntcharts_linechart_set_auto_x_range(id C.ulonglong, autoMin C.int, autoMax C.int) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.AutoMinX = autoMin != 0
+		l.AutoMaxX = autoMax != 0
+	}
+}
+
+//export ntcharts_linechart_set_auto_y_range
+func ntcharts_linechart_set_auto_y_range(id C.ulonglong, autoMin C.int, autoMax C.int) {
+	l := getLinechart(uint64(id))
+	if l != nil {
+		l.AutoMinY = autoMin != 0
+		l.AutoMaxY = autoMax != 0
+	}
+}
+
+//export ntcharts_linechart_resize
+func ntcharts_linechart_resize(id C.ulonglong, width C.int, height C.int) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.Resize(int(width), int(height))
+	}
+}
+
+//export ntcharts_linechart_clear
+func ntcharts_linechart_clear(id C.ulonglong) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.Clear()
+	}
+}
+
+//export ntcharts_linechart_draw_axes
+func ntcharts_linechart_draw_axes(id C.ulonglong) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.DrawXYAxisAndLabel()
+	}
+}
+
+//export ntcharts_linechart_draw_rune
+func ntcharts_linechart_draw_rune(id C.ulonglong, x C.double, y C.double, r C.int) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.DrawRune(canvas.Float64Point{X: float64(x), Y: float64(y)}, rune(r))
+	}
+}
+
+//export ntcharts_linechart_draw_rune_with_style
+func ntcharts_linechart_draw_rune_with_style(id C.ulonglong, x C.double, y C.double, r C.int, styleID C.ulonglong) {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return
+	}
+
+	s, ok := getStyle(uint64(styleID))
+
+	if !ok {
+		l.DrawRune(canvas.Float64Point{X: float64(x), Y: float64(y)}, rune(r))
+		return
+	}
+
+	l.DrawRuneWithStyle(canvas.Float64Point{X: float64(x), Y: float64(y)}, rune(r), s)
+}
+
+//export ntcharts_linechart_draw_line
+func ntcharts_linechart_draw_line(id C.ulonglong, x1 C.double, y1 C.double, x2 C.double, y2 C.double, lineStyle C.int) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		ls := getLineStyle(int(lineStyle))
+		l.DrawLine(canvas.Float64Point{X: float64(x1), Y: float64(y1)}, canvas.Float64Point{X: float64(x2), Y: float64(y2)}, ls)
+	}
+}
+
+//export ntcharts_linechart_draw_line_with_style
+func ntcharts_linechart_draw_line_with_style(id C.ulonglong, x1 C.double, y1 C.double, x2 C.double, y2 C.double, lineStyle C.int, styleID C.ulonglong) {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return
+	}
+
+	ls := getLineStyle(int(lineStyle))
+
+	s, ok := getStyle(uint64(styleID))
+
+	if !ok {
+		l.DrawLine(canvas.Float64Point{X: float64(x1), Y: float64(y1)}, canvas.Float64Point{X: float64(x2), Y: float64(y2)}, ls)
+		return
+	}
+
+	l.DrawLineWithStyle(canvas.Float64Point{X: float64(x1), Y: float64(y1)}, canvas.Float64Point{X: float64(x2), Y: float64(y2)}, ls, s)
+}
+
+//export ntcharts_linechart_draw_braille_line
+func ntcharts_linechart_draw_braille_line(id C.ulonglong, x1 C.double, y1 C.double, x2 C.double, y2 C.double) {
+	l := getLinechart(uint64(id))
+
+	if l != nil {
+		l.DrawBrailleLine(canvas.Float64Point{X: float64(x1), Y: float64(y1)}, canvas.Float64Point{X: float64(x2), Y: float64(y2)})
+	}
+}
+
+//export ntcharts_linechart_draw_braille_line_with_style
+func ntcharts_linechart_draw_braille_line_with_style(id C.ulonglong, x1 C.double, y1 C.double, x2 C.double, y2 C.double, styleID C.ulonglong) {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return
+	}
+
+	s, ok := getStyle(uint64(styleID))
+
+	if !ok {
+		l.DrawBrailleLine(canvas.Float64Point{X: float64(x1), Y: float64(y1)}, canvas.Float64Point{X: float64(x2), Y: float64(y2)})
+		return
+	}
+
+	l.DrawBrailleLineWithStyle(canvas.Float64Point{X: float64(x1), Y: float64(y1)}, canvas.Float64Point{X: float64(x2), Y: float64(y2)}, s)
+}
+
+//export ntcharts_linechart_set_style
+func ntcharts_linechart_set_style(id C.ulonglong, styleID C.ulonglong) {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return
+	}
+
+	s, ok := getStyle(uint64(styleID))
+
+	if ok {
+		l.Style = s
+	}
+}
+
+//export ntcharts_linechart_set_axis_style
+func ntcharts_linechart_set_axis_style(id C.ulonglong, styleID C.ulonglong) {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return
+	}
+
+	s, ok := getStyle(uint64(styleID))
+
+	if ok {
+		l.AxisStyle = s
+	}
+}
+
+//export ntcharts_linechart_set_label_style
+func ntcharts_linechart_set_label_style(id C.ulonglong, styleID C.ulonglong) {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return
+	}
+
+	s, ok := getStyle(uint64(styleID))
+
+	if ok {
+		l.LabelStyle = s
+	}
+}
+
+//export ntcharts_linechart_view
+func ntcharts_linechart_view(id C.ulonglong) *C.char {
+	l := getLinechart(uint64(id))
+
+	if l == nil {
+		return C.CString("")
+	}
+
+	return C.CString(l.View())
+}
+
+const (
+	LineStyleThin = 0
+	LineStyleArc  = 1
+)
+
+func getLineStyle(style int) runes.LineStyle {
+	switch style {
+	case LineStyleThin:
+		return runes.ThinLineStyle
+	case LineStyleArc:
+		return runes.ArcLineStyle
+	default:
+		return runes.ThinLineStyle
+	}
+}

data/go/ntcharts.go

@@ -0,0 +1,279 @@
+package main
+
+/*
+#include <stdlib.h>
+*/
+import "C"
+
+import (
+	"runtime/debug"
+	"sync"
+	"unsafe"
+	"github.com/NimbleMarkets/ntcharts/barchart"
+	"github.com/NimbleMarkets/ntcharts/linechart"
+	"github.com/NimbleMarkets/ntcharts/linechart/streamlinechart"
+	"github.com/NimbleMarkets/ntcharts/linechart/timeserieslinechart"
+	"github.com/NimbleMarkets/ntcharts/linechart/wavelinechart"
+	"github.com/NimbleMarkets/ntcharts/sparkline"
+	"github.com/charmbracelet/lipgloss"
+)
+
+var (
+	nextID   uint64 = 1
+	nextIDMu sync.Mutex
+)
+
+func getNextID() uint64 {
+	nextIDMu.Lock()
+	defer nextIDMu.Unlock()
+	id := nextID
+	nextID++
+	return id
+}
+
+var (
+	sparklines   = make(map[uint64]*sparkline.Model)
+	sparklinesMu sync.RWMutex
+)
+
+func allocSparkline(s *sparkline.Model) uint64 {
+	id := getNextID()
+	sparklinesMu.Lock()
+	sparklines[id] = s
+	sparklinesMu.Unlock()
+	return id
+}
+
+func getSparkline(id uint64) *sparkline.Model {
+	sparklinesMu.RLock()
+	defer sparklinesMu.RUnlock()
+	return sparklines[id]
+}
+
+func freeSparkline(id uint64) {
+	sparklinesMu.Lock()
+	delete(sparklines, id)
+	sparklinesMu.Unlock()
+}
+
+var (
+	barcharts   = make(map[uint64]*barchart.Model)
+	barchartsMu sync.RWMutex
+)
+
+func allocBarchart(b *barchart.Model) uint64 {
+	id := getNextID()
+	barchartsMu.Lock()
+	barcharts[id] = b
+	barchartsMu.Unlock()
+	return id
+}
+
+func getBarchart(id uint64) *barchart.Model {
+	barchartsMu.RLock()
+	defer barchartsMu.RUnlock()
+	return barcharts[id]
+}
+
+func freeBarchart(id uint64) {
+	barchartsMu.Lock()
+	delete(barcharts, id)
+	barchartsMu.Unlock()
+}
+
+var (
+	linecharts   = make(map[uint64]*linechart.Model)
+	linechartsMu sync.RWMutex
+)
+
+func allocLinechart(l *linechart.Model) uint64 {
+	id := getNextID()
+	linechartsMu.Lock()
+	linecharts[id] = l
+	linechartsMu.Unlock()
+	return id
+}
+
+func getLinechart(id uint64) *linechart.Model {
+	linechartsMu.RLock()
+	defer linechartsMu.RUnlock()
+	return linecharts[id]
+}
+
+func freeLinechart(id uint64) {
+	linechartsMu.Lock()
+	delete(linecharts, id)
+	linechartsMu.Unlock()
+}
+
+var (
+	wavelinecharts   = make(map[uint64]*wavelinechart.Model)
+	wavelinechartsMu sync.RWMutex
+)
+
+func allocWavelinechart(w *wavelinechart.Model) uint64 {
+	id := getNextID()
+	wavelinechartsMu.Lock()
+	wavelinecharts[id] = w
+	wavelinechartsMu.Unlock()
+	return id
+}
+
+func getWavelinechart(id uint64) *wavelinechart.Model {
+	wavelinechartsMu.RLock()
+	defer wavelinechartsMu.RUnlock()
+	return wavelinecharts[id]
+}
+
+func freeWavelinechart(id uint64) {
+	wavelinechartsMu.Lock()
+	delete(wavelinecharts, id)
+	wavelinechartsMu.Unlock()
+}
+
+var (
+	streamlinecharts   = make(map[uint64]*streamlinechart.Model)
+	streamlinechartsMu sync.RWMutex
+)
+
+func allocStreamlinechart(s *streamlinechart.Model) uint64 {
+	id := getNextID()
+	streamlinechartsMu.Lock()
+	streamlinecharts[id] = s
+	streamlinechartsMu.Unlock()
+	return id
+}
+
+func getStreamlinechart(id uint64) *streamlinechart.Model {
+	streamlinechartsMu.RLock()
+	defer streamlinechartsMu.RUnlock()
+	return streamlinecharts[id]
+}
+
+func freeStreamlinechart(id uint64) {
+	streamlinechartsMu.Lock()
+	delete(streamlinecharts, id)
+	streamlinechartsMu.Unlock()
+}
+
+var (
+	timeserieslinecharts   = make(map[uint64]*timeserieslinechart.Model)
+	timeserieslinechartsMu sync.RWMutex
+)
+
+func allocTimeserieslinechart(t *timeserieslinechart.Model) uint64 {
+	id := getNextID()
+	timeserieslinechartsMu.Lock()
+	timeserieslinecharts[id] = t
+	timeserieslinechartsMu.Unlock()
+	return id
+}
+
+func getTimeserieslinechart(id uint64) *timeserieslinechart.Model {
+	timeserieslinechartsMu.RLock()
+	defer timeserieslinechartsMu.RUnlock()
+	return timeserieslinecharts[id]
+}
+
+func freeTimeserieslinechart(id uint64) {
+	timeserieslinechartsMu.Lock()
+	delete(timeserieslinecharts, id)
+	timeserieslinechartsMu.Unlock()
+}
+
+var (
+	styles   = make(map[uint64]lipgloss.Style)
+	stylesMu sync.RWMutex
+)
+
+func allocStyle(s lipgloss.Style) uint64 {
+	id := getNextID()
+	stylesMu.Lock()
+	styles[id] = s
+	stylesMu.Unlock()
+	return id
+}
+
+func getStyle(id uint64) (lipgloss.Style, bool) {
+	stylesMu.RLock()
+	defer stylesMu.RUnlock()
+	s, ok := styles[id]
+	return s, ok
+}
+
+func freeStyle(id uint64) {
+	stylesMu.Lock()
+	delete(styles, id)
+	stylesMu.Unlock()
+}
+
+//export ntcharts_free
+func ntcharts_free(pointer *C.char) {
+	C.free(unsafe.Pointer(pointer))
+}
+
+//export ntcharts_upstream_version
+func ntcharts_upstream_version() *C.char {
+	info, ok := debug.ReadBuildInfo()
+
+	if !ok {
+		return C.CString("unknown")
+	}
+
+	for _, dep := range info.Deps {
+		if dep.Path == "github.com/NimbleMarkets/ntcharts" {
+			return C.CString(dep.Version)
+		}
+	}
+
+	return C.CString("unknown")
+}
+
+//export ntcharts_style_new
+func ntcharts_style_new() C.ulonglong {
+	s := lipgloss.NewStyle()
+	return C.ulonglong(allocStyle(s))
+}
+
+//export ntcharts_style_free
+func ntcharts_style_free(id C.ulonglong) {
+	freeStyle(uint64(id))
+}
+
+//export ntcharts_style_foreground
+func ntcharts_style_foreground(id C.ulonglong, color *C.char) C.ulonglong {
+	s, ok := getStyle(uint64(id))
+
+	if !ok {
+		s = lipgloss.NewStyle()
+	}
+
+	newStyle := s.Foreground(lipgloss.Color(C.GoString(color)))
+	return C.ulonglong(allocStyle(newStyle))
+}
+
+//export ntcharts_style_background
+func ntcharts_style_background(id C.ulonglong, color *C.char) C.ulonglong {
+	s, ok := getStyle(uint64(id))
+
+	if !ok {
+		s = lipgloss.NewStyle()
+	}
+
+	newStyle := s.Background(lipgloss.Color(C.GoString(color)))
+	return C.ulonglong(allocStyle(newStyle))
+}
+
+//export ntcharts_style_bold
+func ntcharts_style_bold(id C.ulonglong, bold C.int) C.ulonglong {
+	s, ok := getStyle(uint64(id))
+
+	if !ok {
+		s = lipgloss.NewStyle()
+	}
+
+	newStyle := s.Bold(bold != 0)
+	return C.ulonglong(allocStyle(newStyle))
+}
+
+func main() {}