gocui

package
v0.0.0-...-361b1ce Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 7, 2015 License: Apache-2.0, BSD-3-Clause Imports: 6 Imported by: 0

README

GOCUI - Go Console User Interface

Minimalist Go package aimed at creating Console User Interfaces.

Features

  • Minimalist API.
  • Views (the "windows" in the GUI) implement the interface io.Writer.
  • Support for overlapping views.
  • The GUI can be modified at runtime.
  • Global and view-level keybindings.
  • Edit mode.

Example

func layout(g *gocui.Gui) error {
	maxX, maxY := g.Size()
	if v, err := g.SetView("center", maxX/2-10, maxY/2, maxX/2+10, maxY/2+2); err != nil {
		if err != gocui.ErrorUnkView {
			return err
		}
		fmt.Fprintln(v, "This is an example")
	}
	return nil
}
func quit(g *gocui.Gui, v *gocui.View) error {
	return gocui.Quit
}
func main() {
	var err error
	g := gocui.NewGui()
	if err := g.Init(); err != nil {
		log.Panicln(err)
	}
	defer g.Close()
	g.SetLayout(layout)
	if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
		log.Panicln(err)
	}
	err = g.MainLoop()
	if err != nil && err != gocui.Quit {
		log.Panicln(err)
	}
}

Screenshots

_examples/demo.go:

_examples/demo.go

_examples/delete.go:

_examples/delete.go

Installation

go get github.com/jroimartin/gocui

Documentation

godoc github.com/jroimartin/gocui

Documentation

Overview

Package gocui allows to create console user interfaces.

Example: 

func layout(g *gocui.Gui) error {
	maxX, maxY := g.Size()
	if v, err := g.SetView("center", maxX/2-10, maxY/2, maxX/2+10, maxY/2+2); err != nil {
		if err != gocui.ErrorUnkView {
			return err
		}
		fmt.Fprintln(v, "This is an example")
	}
	return nil
}
func quit(g *gocui.Gui, v *gocui.View) error {
	return gocui.Quit
}
func main() {
	var err error
	g := gocui.NewGui()
	if err := g.Init(); err != nil {
		log.Panicln(err)
	}
	defer g.Close()
	g.SetLayout(layout)
	if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
		log.Panicln(err)
	}
	err = g.MainLoop()
	if err != nil && err != gocui.Quit {
		log.Panicln(err)
	}
}

Index

Constants

View Source 
const (
	ColorDefault Attribute = Attribute(termbox.ColorDefault)
	ColorBlack             = Attribute(termbox.ColorBlack)
	ColorRed               = Attribute(termbox.ColorRed)
	ColorGreen             = Attribute(termbox.ColorGreen)
	ColorYellow            = Attribute(termbox.ColorYellow)
	ColorBlue              = Attribute(termbox.ColorBlue)
	ColorMagenta           = Attribute(termbox.ColorMagenta)
	ColorCyan              = Attribute(termbox.ColorCyan)
	ColorWhite             = Attribute(termbox.ColorWhite)
)

Color attributes.

View Source 
const (
	AttrBold      Attribute = Attribute(termbox.AttrBold)
	AttrUnderline           = Attribute(termbox.AttrUnderline)
	AttrReverse             = Attribute(termbox.AttrReverse)
)

Text style attributes.

View Source 
const (
	KeyF1         Key = Key(termbox.KeyF1)
	KeyF2             = Key(termbox.KeyF2)
	KeyF3             = Key(termbox.KeyF3)
	KeyF4             = Key(termbox.KeyF4)
	KeyF5             = Key(termbox.KeyF5)
	KeyF6             = Key(termbox.KeyF6)
	KeyF7             = Key(termbox.KeyF7)
	KeyF8             = Key(termbox.KeyF8)
	KeyF9             = Key(termbox.KeyF9)
	KeyF10            = Key(termbox.KeyF10)
	KeyF11            = Key(termbox.KeyF11)
	KeyF12            = Key(termbox.KeyF12)
	KeyInsert         = Key(termbox.KeyInsert)
	KeyDelete         = Key(termbox.KeyDelete)
	KeyHome           = Key(termbox.KeyHome)
	KeyEnd            = Key(termbox.KeyEnd)
	KeyPgup           = Key(termbox.KeyPgup)
	KeyPgdn           = Key(termbox.KeyPgdn)
	KeyArrowUp        = Key(termbox.KeyArrowUp)
	KeyArrowDown      = Key(termbox.KeyArrowDown)
	KeyArrowLeft      = Key(termbox.KeyArrowLeft)
	KeyArrowRight     = Key(termbox.KeyArrowRight)
)

Special keys.

View Source 
const (
	KeyCtrlTilde      Key = Key(termbox.KeyCtrlTilde)
	KeyCtrl2              = Key(termbox.KeyCtrl2)
	KeyCtrlSpace          = Key(termbox.KeyCtrlSpace)
	KeyCtrlA              = Key(termbox.KeyCtrlA)
	KeyCtrlB              = Key(termbox.KeyCtrlB)
	KeyCtrlC              = Key(termbox.KeyCtrlC)
	KeyCtrlD              = Key(termbox.KeyCtrlD)
	KeyCtrlE              = Key(termbox.KeyCtrlE)
	KeyCtrlF              = Key(termbox.KeyCtrlF)
	KeyCtrlG              = Key(termbox.KeyCtrlG)
	KeyBackspace          = Key(termbox.KeyBackspace)
	KeyCtrlH              = Key(termbox.KeyCtrlH)
	KeyTab                = Key(termbox.KeyTab)
	KeyCtrlI              = Key(termbox.KeyCtrlI)
	KeyCtrlJ              = Key(termbox.KeyCtrlJ)
	KeyCtrlK              = Key(termbox.KeyCtrlK)
	KeyCtrlL              = Key(termbox.KeyCtrlL)
	KeyEnter              = Key(termbox.KeyEnter)
	KeyCtrlM              = Key(termbox.KeyCtrlM)
	KeyCtrlN              = Key(termbox.KeyCtrlN)
	KeyCtrlO              = Key(termbox.KeyCtrlO)
	KeyCtrlP              = Key(termbox.KeyCtrlP)
	KeyCtrlQ              = Key(termbox.KeyCtrlQ)
	KeyCtrlR              = Key(termbox.KeyCtrlR)
	KeyCtrlS              = Key(termbox.KeyCtrlS)
	KeyCtrlT              = Key(termbox.KeyCtrlT)
	KeyCtrlU              = Key(termbox.KeyCtrlU)
	KeyCtrlV              = Key(termbox.KeyCtrlV)
	KeyCtrlW              = Key(termbox.KeyCtrlW)
	KeyCtrlX              = Key(termbox.KeyCtrlX)
	KeyCtrlY              = Key(termbox.KeyCtrlY)
	KeyCtrlZ              = Key(termbox.KeyCtrlZ)
	KeyEsc                = Key(termbox.KeyEsc)
	KeyCtrlLsqBracket     = Key(termbox.KeyCtrlLsqBracket)
	KeyCtrl3              = Key(termbox.KeyCtrl3)
	KeyCtrl4              = Key(termbox.KeyCtrl4)
	KeyCtrlBackslash      = Key(termbox.KeyCtrlBackslash)
	KeyCtrl5              = Key(termbox.KeyCtrl5)
	KeyCtrlRsqBracket     = Key(termbox.KeyCtrlRsqBracket)
	KeyCtrl6              = Key(termbox.KeyCtrl6)
	KeyCtrl7              = Key(termbox.KeyCtrl7)
	KeyCtrlSlash          = Key(termbox.KeyCtrlSlash)
	KeyCtrlUnderscore     = Key(termbox.KeyCtrlUnderscore)
	KeySpace              = Key(termbox.KeySpace)
	KeyBackspace2         = Key(termbox.KeyBackspace2)
	KeyCtrl8              = Key(termbox.KeyCtrl8)
)

Keys combinations.

Variables

View Source 
var (
	// Quit is used to decide if the MainLoop finished succesfully.
	Quit error = errors.New("quit")

	// ErrorUnkView allows to assert if a View must be initialized.
	ErrorUnkView error = errors.New("unknown view")
)
View Source 
var Edit = EditorFunc(DefaultEditor)

Edit allows to define the editor that manages the edition mode, including keybindings or cursor behaviour. DefaultEditor is used by default.

Functions

func DefaultEditor 

func DefaultEditor(v *View, key Key, ch rune, mod Modifier)

DefaultEditor is used as the default gocui editor.

Types

type Attribute 

type Attribute termbox.Attribute

Attributes can be combined using bitwise OR (|). Note that it is not possible to combine multiple color attributes.

type Editor 

type Editor interface {
	Edit(v *View, key Key, ch rune, mod Modifier)
}

Objects implementing the Editor interface can be used as gocui editors.

type EditorFunc 

type EditorFunc func(v *View, key Key, ch rune, mod Modifier)

The EditorFunc type is an adapter to allow the use of ordinary functions as Editors. If f is a function with the appropriate signature, EditorFunc(f) is an Editor object that calls f.

func (EditorFunc) Edit 

func (f EditorFunc) Edit(v *View, key Key, ch rune, mod Modifier)

Edit calls f(v, key, ch, mod)

type Gui 

type Gui struct {

	// BgColor and FgColor allow to configure the background and foreground
	// colors of the GUI.
	BgColor, FgColor Attribute

	// SelBgColor and SelFgColor are used to configure the background and
	// foreground colors of the selected line, when it is highlighted.
	SelBgColor, SelFgColor Attribute

	// If ShowCursor is true then the cursor is enabled.
	ShowCursor bool
	// contains filtered or unexported fields
}

Gui represents the whole User Interface, including the views, layouts and keybindings.

func NewGui 

func NewGui() *Gui

NewGui returns a new Gui object.

func (*Gui) Close 

func (g *Gui) Close()

Close finalizes the library. It should be called after a successful initialization and when gocui is not needed anymore.

func (*Gui) CurrentView 

func (g *Gui) CurrentView() *View

CurrentView returns the currently focused view, or nil if no view owns the focus.

func (*Gui) DeleteView 

func (g *Gui) DeleteView(name string) error

DeleteView deletes a view by name.

func (*Gui) Flush 

func (g *Gui) Flush() error

Flush updates the gui, re-drawing frames and buffers.

Flush is safe for concurrent use by multiple goroutines. However it is important to note that it will make the layout function to be called, which could lead to a dead lock if the same mutex is used in both the function calling Flush and the layout function.

func (*Gui) Init 

func (g *Gui) Init() error

Init initializes the library. This function must be called before any other functions.

func (*Gui) MainLoop 

func (g *Gui) MainLoop() error

MainLoop runs the main loop until an error is returned. A successful finish should return Quit.

func (*Gui) Rune 

func (g *Gui) Rune(x, y int) (rune, error)

Rune returns the rune contained in the cell at the given position. It checks if the position is valid.

func (*Gui) SetCurrentView 

func (g *Gui) SetCurrentView(name string) error

SetCurrentView gives the focus to a given view.

func (*Gui) SetKeybinding 

func (g *Gui) SetKeybinding(viewname string, key interface{}, mod Modifier, h KeybindingHandler) error

SetKeybinding creates a new keybinding. If viewname equals to "" (empty string) then the keybinding will apply to all views. key must be a rune or a Key.

func (*Gui) SetLayout 

func (g *Gui) SetLayout(layout func(*Gui) error)

SetLayout sets the current layout. A layout is a function that will be called everytime the gui is re-drawed, it must contain the base views and its initializations.

func (*Gui) SetRune 

func (g *Gui) SetRune(x, y int, ch rune) error

SetRune writes a rune at the given point, relative to the top-left corner of the terminal. It checks if the position is valid and applies the gui's colors.

func (*Gui) SetView 

func (g *Gui) SetView(name string, x0, y0, x1, y1 int) (*View, error)

SetView creates a new view with its top-left corner at (x0, y0) and the bottom-right one at (x1, y1). If a view with the same name already exists, its dimensions are updated; otherwise, the error ErrorUnkView is returned, which allows to assert if the View must be initialized. It checks if the position is valid.

func (*Gui) Size 

func (g *Gui) Size() (x, y int)

Size returns the terminal's size.

func (*Gui) View 

func (g *Gui) View(name string) (*View, error)

View returns a pointer to the view with the given name, or error ErrorUnkView if a view with that name does not exist.

func (*Gui) ViewPosition 

func (g *Gui) ViewPosition(name string) (x0, y0, x1, y1 int, err error)

Position returns the coordinates of the view with the given name, or error ErrorUnkView if a view with that name does not exist.

type Key 

type Key termbox.Key

Keys represent special keys or keys combinations.

type KeybindingHandler 

type KeybindingHandler func(*Gui, *View) error

KeybindingHandlers represent the actions linked to keybindings. The handler is called when a key-press event satisfies a configured keybinding.

type Modifier 

type Modifier termbox.Modifier

Modifiers allow to define special keys combinations. They can be used in combination with Keys or Runes when a new keybinding is defined. 

const (
	ModNone Modifier = Modifier(0)
	ModAlt           = Modifier(termbox.ModAlt)
)

Modifiers.

type View 

type View struct {

	// BgColor and FgColor allow to configure the background and foreground
	// colors of the View.
	BgColor, FgColor Attribute

	// SelBgColor and SelFgColor are used to configure the background and
	// foreground colors of the selected line, when it is highlighted.
	SelBgColor, SelFgColor Attribute

	// If Editable is true, keystrokes will be added to the view's internal
	// buffer at the cursor position.
	Editable bool

	// Overwrite enables or disables the overwrite mode of the view.
	Overwrite bool

	// If Highlight is true, Sel{Bg,Fg}Colors will be used
	// for the line under the cursor position.
	Highlight bool

	// If Frame is true, a border will be drawn around the view.
	Frame bool

	// If Wrap is true, the content that is written to this View is
	// automatically wrapped when it is longer than its width. If true the
	// view's x-origin will be ignored.
	Wrap bool

	// If Autoscroll is true, the View will automatically scroll down when the
	// text overflows. If true the view's y-origin will be ignored.
	Autoscroll bool
	// contains filtered or unexported fields
}

A View is a window. It maintains its own internal buffer and cursor position.

func (*View) Buffer 

func (v *View) Buffer() string

Buffer returns a string with the contents of the view's internal buffer

func (*View) Clear 

func (v *View) Clear()

Clear empties the view's internal buffer.

func (*View) Cursor 

func (v *View) Cursor() (x, y int)

Cursor returns the cursor position of the view.

func (*View) EditDelete 

func (v *View) EditDelete(back bool)

EditDelete deletes a rune at the cursor position. back determines the direction.

func (*View) EditNewLine 

func (v *View) EditNewLine()

EditNewLine inserts a new line under the cursor.

func (*View) EditWrite 

func (v *View) EditWrite(ch rune)

EditWrite writes a rune at the cursor position.

func (*View) Line 

func (v *View) Line(y int) (string, error)

Line returns a string with the line of the view's internal buffer at the position corresponding to the point (x, y).

func (*View) MoveCursor 

func (v *View) MoveCursor(dx, dy int, writeMode bool)

MoveCursor moves the cursor taking into account the width of the line/view, displacing the origin if necessary.

func (*View) Name 

func (v *View) Name() string

Name returns the name of the view.

func (*View) Origin 

func (v *View) Origin() (x, y int)

Origin returns the origin position of the view.

func (*View) Read 

func (v *View) Read(p []byte) (n int, err error)

Read reads data into p. It returns the number of bytes read into p. At EOF, err will be io.EOF. Calling Read() after Rewind() makes the cache to be refreshed with the contents of the view.

func (*View) Rewind 

func (v *View) Rewind()

Rewind sets the offset for the next Read to 0, which also refresh the read cache.

func (*View) SetCursor 

func (v *View) SetCursor(x, y int) error

SetCursor sets the cursor position of the view at the given point, relative to the view. It checks if the position is valid.

func (*View) SetOrigin 

func (v *View) SetOrigin(x, y int) error

SetOrigin sets the origin position of the view's internal buffer, so the buffer starts to be printed from this point, which means that it is linked with the origin point of view. It can be used to implement Horizontal and Vertical scrolling with just incrementing or decrementing ox and oy.

func (*View) Size 

func (v *View) Size() (x, y int)

Size returns the number of visible columns and rows in the View.

func (*View) Word 

func (v *View) Word(x, y int) (string, error)

Word returns a string with the word of the view's internal buffer at the position corresponding to the point (x, y).

func (*View) Write 

func (v *View) Write(p []byte) (n int, err error)

Write appends a byte slice into the view's internal buffer. Because View implements the io.Writer interface, it can be passed as parameter of functions like fmt.Fprintf, fmt.Fprintln, io.Copy, etc. Clear must be called to clear the view's buffer.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.