termdash

README

Termdash is a cross-platform customizable terminal based dashboard.

The feature set is inspired by the gizak/termui project, which in turn was inspired by yaronn/blessed-contrib.

This rewrite focuses on code readability, maintainability and testability, see the design goals. It aims to achieve the following requirements. See the high-level design for more details.

Public API and status

The public API surface is documented in the wiki.

Private packages can be identified by the presence of the /internal/ directory in their import path. Stability of the private packages isn't guaranteed and changes won't be backward compatible.

There might still be breaking changes to the public API, at least until the project reaches version 1.0.0. Any breaking changes will be published in the changelog.

Current feature set

• Full support for terminal window resizing throughout the infrastructure.
• Customizable layout, widget placement, borders, margins, padding, colors, etc.
• Dynamic layout changes at runtime.
• Binary tree and Grid forms of setting up the layout.
• Focusable containers and widgets.
• Processing of keyboard and mouse events.
• Periodic and event driven screen redraw.
• A library of widgets, see below.
• UTF-8 for all text elements.
• Drawing primitives (Go functions) for widget development with character and sub-character resolution.

Installation

To install this library, run the following:

go get -u github.com/mum4k/termdash

Usage

The usage of most of these elements is demonstrated in termdashdemo.go. To execute the demo:

go run github.com/mum4k/termdash/termdashdemo/termdashdemo.go

Documentation

Please refer to the Termdash wiki for all documentation and resources.

Implemented Widgets

The Button

Allows users to interact with the application, each button press runs a callback function. Run the buttondemo.

go run github.com/mum4k/termdash/widgets/button/buttondemo/buttondemo.go

The TextInput

Allows users to interact with the application by entering, editing and submitting text data. Run the textinputdemo.

go run github.com/mum4k/termdash/widgets/textinput/textinputdemo/textinputdemo.go

The Gauge

Displays the progress of an operation. Run the gaugedemo.

go run github.com/mum4k/termdash/widgets/gauge/gaugedemo/gaugedemo.go

The Donut

Visualizes progress of an operation as a partial or a complete donut. Run the donutdemo.

go run github.com/mum4k/termdash/widgets/donut/donutdemo/donutdemo.go

The Text

Displays text content, supports trimming and scrolling of content. Run the textdemo.

go run github.com/mum4k/termdash/widgets/text/textdemo/textdemo.go

The SparkLine

Draws a graph showing a series of values as vertical bars. The bars can have sub-cell height. Run the sparklinedemo.

go run github.com/mum4k/termdash/widgets/sparkline/sparklinedemo/sparklinedemo.go

The BarChart

Displays multiple bars showing relative ratios of values. Run the barchartdemo.

go run github.com/mum4k/termdash/widgets/barchart/barchartdemo/barchartdemo.go

The LineChart

Displays series of values on a line chart, supports zoom triggered by mouse events. Run the linechartdemo.

go run github.com/mum4k/termdash/widgets/linechart/linechartdemo/linechartdemo.go

The SegmentDisplay

Displays text by simulating a 16-segment display. Run the segmentdisplaydemo.

go run github.com/mum4k/termdash/widgets/segmentdisplay/segmentdisplaydemo/segmentdisplaydemo.go

Contributing

If you are willing to contribute, improve the infrastructure or develop a widget, first of all Thank You! Your help is appreciated.

Please see the CONTRIBUTING.md file for guidelines related to the Google's CLA, and code review requirements.

As stated above the primary goal of this project is to develop readable, well designed code, the functionality and efficiency come second. This is achieved through detailed code reviews, design discussions and following of the design guidelines. Please familiarize yourself with these before contributing.

If you're developing a new widget, please see the widget development section.

Termdash uses this branching model. When you fork the repository, base your changes off the devel branch and the pull request should merge it back to the devel branch. Commits to the master branch are limited to releases, major bug fixes and documentation updates.

Similar projects in Go

• clui
• gocui
• gowid
• termui
• tui-go
• tview

Projects using Termdash

• datadash: Visualize streaming or tabular data inside the terminal.
• grafterm: Metrics dashboards visualization on the terminal.

Disclaimer

This is not an official Google product.

Documentation

Overview

Package termdash implements a terminal based dashboard.

While running, the terminal dashboard performs the following:

• Periodic redrawing of the canvas and all the widgets.
• Event based redrawing of the widgets (i.e. on Keyboard or Mouse events).
• Forwards input events to widgets and optional subscribers.
• Handles terminal resize events.

Example

Example shows how to setup and run termdash with periodic redraw.

// Create the terminal.
t, err := termbox.New()
if err != nil {
	panic(err)
}
defer t.Close()

// Create some widgets.
bc, err := barchart.New()
if err != nil {
	panic(err)
}
g, err := gauge.New()
if err != nil {
	panic(err)
}

// Create the container with two widgets.
c, err := container.New(
	t,
	container.SplitVertical(
		container.Left(
			container.PlaceWidget(bc),
		),
		container.Right(
			container.PlaceWidget(g),
		),
		container.SplitPercent(30),
	),
)
if err != nil {
	panic(err)
}

// Termdash runs until the context expires.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := Run(ctx, t, c); err != nil {
	panic(err)
}

Example (Triggered)

Example shows how to setup and run termdash with manually triggered redraw.

// Create the terminal.
t, err := termbox.New()
if err != nil {
	panic(err)
}
defer t.Close()

// Create a widget.
bc, err := barchart.New()
if err != nil {
	panic(err)
}

// Create the container with a widget.
c, err := container.New(
	t,
	container.PlaceWidget(bc),
)
if err != nil {
	panic(err)
}

// Create the controller and disable periodic redraw.
ctrl, err := NewController(t, c)
if err != nil {
	panic(err)
}
// Close the controller and termdash once it isn't required anymore.
defer ctrl.Close()

// Redraw the terminal manually.
if err := ctrl.Redraw(); err != nil {
	panic(err)
}

Index

• Constants
• func Run(ctx context.Context, t terminalapi.Terminal, c *container.Container, ...) error
• type Controller
  • func NewController(t terminalapi.Terminal, c *container.Container, opts ...Option) (*Controller, error)
  • func (c *Controller) Close()
  • func (c *Controller) Redraw() error
• type Option
  • func ErrorHandler(f func(error)) Option
  • func KeyboardSubscriber(f func(*terminalapi.Keyboard)) Option
  • func MouseSubscriber(f func(*terminalapi.Mouse)) Option
  • func RedrawInterval(t time.Duration) Option

Examples

• Package
• Package (Triggered)

Constants

const DefaultRedrawInterval = 250 * time.Millisecond

DefaultRedrawInterval is the default for the RedrawInterval option.

Functions

func Run

func Run(ctx context.Context, t terminalapi.Terminal, c *container.Container, opts ...Option) error

Run runs the terminal dashboard with the provided container on the terminal. Redraws the terminal periodically. If you prefer a manual redraw, use the Controller instead. Blocks until the context expires.

Types

type Controller

type Controller struct {
	// contains filtered or unexported fields
}

Controller controls a termdash instance. The controller instance is only valid until Close() is called. The controller is not thread-safe.

func NewController

func NewController(t terminalapi.Terminal, c *container.Container, opts ...Option) (*Controller, error)

NewController initializes termdash and returns an instance of the controller. Periodic redrawing is disabled when using the controller, the RedrawInterval option is ignored. Close the controller when it isn't needed anymore.

func (*Controller) Close

func (c *Controller) Close()

Close closes the Controller and its termdash instance.

func (*Controller) Redraw

func (c *Controller) Redraw() error

Redraw triggers redraw of the terminal.

type Option

type Option interface {
	// contains filtered or unexported methods
}

Option is used to provide options.

func ErrorHandler

func ErrorHandler(f func(error)) Option

ErrorHandler is used to provide a function that will be called with all errors that occur while the dashboard is running. If not provided, any errors panic the application. The provided function must be thread-safe.

func KeyboardSubscriber

func KeyboardSubscriber(f func(*terminalapi.Keyboard)) Option

KeyboardSubscriber registers a subscriber for Keyboard events. Each keyboard event is forwarded to the container and the registered subscriber. The provided function must be thread-safe.

func MouseSubscriber

func MouseSubscriber(f func(*terminalapi.Mouse)) Option

MouseSubscriber registers a subscriber for Mouse events. Each mouse event is forwarded to the container and the registered subscriber. The provided function must be thread-safe.

func RedrawInterval

func RedrawInterval(t time.Duration) Option

RedrawInterval sets how often termdash redraws the container and all the widgets. Defaults to DefaultRedrawInterval. Use the controller to disable the periodic redraw.