Skip to content
Permalink
master
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
 
 
Cannot retrieve contributors at this time
package clui
import (
"fmt"
xs "github.com/huandu/xstrings"
term "github.com/nsf/termbox-go"
"sync/atomic"
)
// BarData is info about one bar in the chart. Every
// bar can be customized by setting its own colors and
// rune to draw the bar. Use ColorDefault for Fg and Bg,
// and 0 for Ch to draw with BarChart defaults
type BarData struct {
Value float64
Title string
Fg term.Attribute
Bg term.Attribute
Ch rune
}
// BarDataCell is used in callback to user to draw with
// customized colors and runes
type BarDataCell struct {
// Title of the bar
Item string
// order number of the bar
ID int
// value of the bar that is currently drawn
Value float64
// maximum value of the bar
BarMax float64
// value of the highest bar
TotalMax float64
// Default attributes and rune to draw the bar
Fg term.Attribute
Bg term.Attribute
Ch rune
}
/*
BarChart is a chart that represents grouped data with
rectangular bars. It can be monochrome - defaut behavior.
One can assign individual color to each bar and even use
custom drawn bars to display multicolored bars depending
on bar value.
All bars have the same width: either constant BarSize - in
case of AutoSize is false, or automatically calculated but
cannot be less than BarSize. Bars that do not fit the chart
area are not displayed.
BarChart displays vertical axis with values on the chart left
if ValueWidth greater than 0, horizontal axis with bar titles
if ShowTitles is true (to enable displaying marks on horizontal
axis, set ShowMarks to true), and chart legend on the right if
LegendWidth is greater than 3.
If LegendWidth is greater than half of the chart it is not
displayed. The same is applied to ValueWidth
*/
type BarChart struct {
BaseControl
data []BarData
autosize bool
gap int32
barWidth int32
legendWidth int32
valueWidth int32
showMarks bool
showTitles bool
onDrawCell func(*BarDataCell)
}
/*
CreateBarChart creates a new bar chart.
view - is a View that manages the control
parent - is container that keeps the control. The same View can be a view and a parent at the same time.
w and h - are minimal size of the control.
scale - the way of scaling the control when the parent is resized. Use DoNotScale constant if the
control should keep its original size.
*/
func CreateBarChart(parent Control, w, h int, scale int) *BarChart {
c := new(BarChart)
c.BaseControl = NewBaseControl()
if w == AutoSize {
w = 10
}
if h == AutoSize {
h = 5
}
c.parent = parent
c.SetSize(w, h)
c.SetConstraints(w, h)
c.tabSkip = true
c.showTitles = true
c.barWidth = 3
c.data = make([]BarData, 0)
c.SetScale(scale)
if parent != nil {
parent.AddChild(c)
}
return c
}
// Draw repaints the control on its View surface
func (b *BarChart) Draw() {
if b.hidden {
return
}
b.mtx.RLock()
defer b.mtx.RUnlock()
PushAttributes()
defer PopAttributes()
fg, bg := RealColor(b.fg, b.Style(), ColorBarChartText), RealColor(b.bg, b.Style(), ColorBarChartBack)
SetTextColor(fg)
SetBackColor(bg)
FillRect(b.x, b.y, b.width, b.height, ' ')
if len(b.data) == 0 {
return
}
b.drawRulers()
b.drawValues()
b.drawLegend()
b.drawBars()
}
func (b *BarChart) barHeight() int {
if b.showTitles {
return b.height - 2
}
return b.height
}
func (b *BarChart) drawBars() {
if len(b.data) == 0 {
return
}
start, width := b.calculateBarArea()
if width < 2 {
return
}
barW := b.calculateBarWidth()
if barW == 0 {
return
}
coeff, max := b.calculateMultiplier()
if coeff == 0.0 {
return
}
PushAttributes()
defer PopAttributes()
h := b.barHeight()
pos := start
parts := []rune(SysObject(ObjBarChart))
fg, bg := TextColor(), BackColor()
for idx, d := range b.data {
if pos+barW > start+width {
break
}
fColor, bColor := d.Fg, d.Bg
ch := d.Ch
if fColor == ColorDefault {
fColor = fg
}
if bColor == ColorDefault {
bColor = bg
}
if ch == 0 {
ch = parts[0]
}
barH := int(d.Value * coeff)
if b.onDrawCell == nil {
SetTextColor(fColor)
SetBackColor(bColor)
FillRect(b.x+pos, b.y+h-barH, barW, barH, ch)
} else {
cellDef := BarDataCell{Item: d.Title, ID: idx,
Value: 0, BarMax: d.Value, TotalMax: max,
Fg: fColor, Bg: bColor, Ch: ch}
for dy := 0; dy < barH; dy++ {
req := cellDef
req.Value = max * float64(dy+1) / float64(h)
b.onDrawCell(&req)
SetTextColor(req.Fg)
SetBackColor(req.Bg)
for dx := 0; dx < barW; dx++ {
PutChar(b.x+pos+dx, b.y+h-1-dy, req.Ch)
}
}
}
if b.showTitles {
SetTextColor(fg)
SetBackColor(bg)
if b.showMarks {
c := parts[7]
PutChar(b.x+pos+barW/2, b.y+h, c)
}
var s string
shift := 0
if xs.Len(d.Title) > barW {
s = CutText(d.Title, barW)
} else {
shift, s = AlignText(d.Title, barW, AlignCenter)
}
DrawRawText(b.x+pos+shift, b.y+h+1, s)
}
pos += barW + int(b.BarGap())
}
}
func (b *BarChart) drawLegend() {
pos, width := b.calculateBarArea()
if pos+width >= b.width-3 {
return
}
PushAttributes()
defer PopAttributes()
fg, bg := RealColor(b.fg, b.Style(), ColorBarChartText), RealColor(b.bg, b.Style(), ColorBarChartBack)
parts := []rune(SysObject(ObjBarChart))
defRune := parts[0]
for idx, d := range b.data {
if idx >= b.height {
break
}
c := d.Ch
if c == 0 {
c = defRune
}
SetTextColor(d.Fg)
SetBackColor(d.Bg)
PutChar(b.x+pos+width, b.y+idx, c)
s := CutText(fmt.Sprintf(" - %v", d.Title), int(b.LegendWidth()))
SetTextColor(fg)
SetBackColor(bg)
DrawRawText(b.x+pos+width+1, b.y+idx, s)
}
}
func (b *BarChart) drawValues() {
valVal := int(b.ValueWidth())
if valVal <= 0 {
return
}
pos, _ := b.calculateBarArea()
if pos == 0 {
return
}
h := b.barHeight()
coeff, max := b.calculateMultiplier()
if max == coeff {
return
}
dy := 0
format := fmt.Sprintf("%%%v.2f", valVal)
for dy < h-1 {
v := float64(h-dy) / float64(h) * max
s := fmt.Sprintf(format, v)
s = CutText(s, valVal)
DrawRawText(b.x, b.y+dy, s)
dy += 2
}
}
func (b *BarChart) drawRulers() {
if int(b.ValueWidth()) <= 0 && int(b.LegendWidth()) <= 0 && !b.showTitles {
return
}
pos, vWidth := b.calculateBarArea()
parts := []rune(SysObject(ObjBarChart))
h := b.barHeight()
if pos > 0 {
pos--
vWidth++
}
// horizontal and vertical lines, corner
cH, cV, cC := parts[1], parts[2], parts[5]
if pos > 0 {
for dy := 0; dy < h; dy++ {
PutChar(b.x+pos, b.y+dy, cV)
}
}
if b.showTitles {
for dx := 0; dx < vWidth; dx++ {
PutChar(b.x+pos+dx, b.y+h, cH)
}
}
if pos > 0 && b.showTitles {
PutChar(b.x+pos, b.y+h, cC)
}
}
func (b *BarChart) calculateBarArea() (int, int) {
w := b.width
pos := 0
valVal := int(b.ValueWidth())
if valVal < w/2 {
w = w - valVal - 1
pos = valVal + 1
}
legVal := int(b.LegendWidth())
if legVal < w/2 {
w -= legVal
}
return pos, w
}
func (b *BarChart) calculateBarWidth() int {
if len(b.data) == 0 {
return 0
}
if !b.autosize {
return int(b.MinBarWidth())
}
w := b.width
legVal := int(b.LegendWidth())
valVal := int(b.ValueWidth())
if valVal < w/2 {
w = w - valVal - 1
}
if legVal < w/2 {
w -= legVal
}
dataCount := len(b.data)
gapVal := int(b.BarGap())
barVal := int(b.MinBarWidth())
minSize := dataCount*barVal + (dataCount-1)*gapVal
if minSize >= w {
return barVal
}
sz := (w - (dataCount-1)*gapVal) / dataCount
if sz == 0 {
sz = 1
}
return sz
}
func (b *BarChart) calculateMultiplier() (float64, float64) {
if len(b.data) == 0 {
return 0, 0
}
h := b.barHeight()
if h <= 1 {
return 0, 0
}
max := b.data[0].Value
for _, val := range b.data {
if val.Value > max {
max = val.Value
}
}
if max == 0 {
return 0, 0
}
return float64(h) / max, max
}
// AddData appends a new bar to a chart
func (b *BarChart) AddData(val BarData) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.data = append(b.data, val)
}
// ClearData removes all bar from chart
func (b *BarChart) ClearData() {
b.mtx.Lock()
defer b.mtx.Unlock()
b.data = make([]BarData, 0)
}
// SetData assign a new bar list to a chart
func (b *BarChart) SetData(data []BarData) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.data = make([]BarData, len(data))
copy(b.data, data)
}
// AutoSize returns whether automatic bar width
// calculation is on. If AutoSize is false then all
// bars have width BarWidth. If AutoSize is true then
// bar width is the maximum of three values: BarWidth,
// calculated width that makes all bars fit the
// bar chart area, and 1
func (b *BarChart) AutoSize() bool {
return b.autosize
}
// SetAutoSize enables or disables automatic bar
// width calculation
func (b *BarChart) SetAutoSize(auto bool) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.autosize = auto
}
// BarGap returns width of visual gap between two adjacent bars
func (b *BarChart) BarGap() int32 {
return atomic.LoadInt32(&b.gap)
}
// SetBarGap sets the space width between two adjacent bars
func (b *BarChart) SetBarGap(gap int32) {
atomic.StoreInt32(&b.gap, gap)
}
// MinBarWidth returns current minimal bar width
func (b *BarChart) MinBarWidth() int32 {
return atomic.LoadInt32(&b.barWidth)
}
// SetMinBarWidth changes the minimal bar width
func (b *BarChart) SetMinBarWidth(size int32) {
atomic.StoreInt32(&b.barWidth, size)
}
// ValueWidth returns the width of the area at the left of
// chart used to draw values. Set it to 0 to turn off the
// value panel
func (b *BarChart) ValueWidth() int32 {
return atomic.LoadInt32(&b.valueWidth)
}
// SetValueWidth changes width of the value panel on the left
func (b *BarChart) SetValueWidth(width int32) {
atomic.StoreInt32(&b.valueWidth, width)
}
// ShowTitles returns if chart displays horizontal axis and
// bar titles under it
func (b *BarChart) ShowTitles() bool {
return b.showTitles
}
// SetShowTitles turns on and off horizontal axis and bar titles
func (b *BarChart) SetShowTitles(show bool) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.showTitles = show
}
// LegendWidth returns width of chart legend displayed at the
// right side of the chart. Set it to 0 to disable legend
func (b *BarChart) LegendWidth() int32 {
return atomic.LoadInt32(&b.legendWidth)
}
// SetLegendWidth sets new legend panel width
func (b *BarChart) SetLegendWidth(width int32) {
atomic.StoreInt32(&b.legendWidth, width)
}
// OnDrawCell sets callback that allows to draw multicolored
// bars. BarChart sends the current attrubutes and rune that
// it is going to use to display as well as the current value
// of the bar. A user can change the values of BarDataCell
// depending on some external data or calculations - only
// changing colors and rune makes sense. Changing anything else
// does not affect the chart
func (b *BarChart) OnDrawCell(fn func(*BarDataCell)) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.onDrawCell = fn
}
// ShowMarks returns if horizontal axis has mark under each
// bar. To show marks, ShowTitles must be enabled.
func (b *BarChart) ShowMarks() bool {
return b.showMarks
}
// SetShowMarks turns on and off marks under horizontal axis
func (b *BarChart) SetShowMarks(show bool) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.showMarks = show
}