termbox

Documentation

Overview

Package termbox is a compatibility layer to allow tcell to emulate the github.com/nsf/termbox package.

Index

• Constants
• func Clear(fg, bg Attribute)
• func Close()
• func Flush() error
• func HideCursor()
• func Init() error
• func Interrupt()
• func SetCell(x, y int, ch rune, fg, bg Attribute)
• func SetCursor(x, y int)
• func Size() (int, int)
• func Sync() error
• type Attribute
• type Cell
• type Event
  • func ParseEvent(data []byte) Event
  • func PollEvent() Event
  • func PollRawEvent(data []byte) Event
• type EventType
• type InputMode
  • func SetInputMode(mode InputMode) InputMode
• type Key
• type Modifier
• type OutputMode
  • func SetOutputMode(mode OutputMode) OutputMode

Constants

const (
	KeyF1             = Key(tcell.KeyF1)
	KeyF2             = Key(tcell.KeyF2)
	KeyF3             = Key(tcell.KeyF3)
	KeyF4             = Key(tcell.KeyF4)
	KeyF5             = Key(tcell.KeyF5)
	KeyF6             = Key(tcell.KeyF6)
	KeyF7             = Key(tcell.KeyF7)
	KeyF8             = Key(tcell.KeyF8)
	KeyF9             = Key(tcell.KeyF9)
	KeyF10            = Key(tcell.KeyF10)
	KeyF11            = Key(tcell.KeyF11)
	KeyF12            = Key(tcell.KeyF12)
	KeyInsert         = Key(tcell.KeyInsert)
	KeyDelete         = Key(tcell.KeyDelete)
	KeyHome           = Key(tcell.KeyHome)
	KeyEnd            = Key(tcell.KeyEnd)
	KeyArrowUp        = Key(tcell.KeyUp)
	KeyArrowDown      = Key(tcell.KeyDown)
	KeyArrowRight     = Key(tcell.KeyRight)
	KeyArrowLeft      = Key(tcell.KeyLeft)
	KeyCtrlA          = Key(tcell.KeyCtrlA)
	KeyCtrlB          = Key(tcell.KeyCtrlB)
	KeyCtrlC          = Key(tcell.KeyCtrlC)
	KeyCtrlD          = Key(tcell.KeyCtrlD)
	KeyCtrlE          = Key(tcell.KeyCtrlE)
	KeyCtrlF          = Key(tcell.KeyCtrlF)
	KeyCtrlG          = Key(tcell.KeyCtrlG)
	KeyCtrlH          = Key(tcell.KeyCtrlH)
	KeyCtrlI          = Key(tcell.KeyCtrlI)
	KeyCtrlJ          = Key(tcell.KeyCtrlJ)
	KeyCtrlK          = Key(tcell.KeyCtrlK)
	KeyCtrlL          = Key(tcell.KeyCtrlL)
	KeyCtrlM          = Key(tcell.KeyCtrlM)
	KeyCtrlN          = Key(tcell.KeyCtrlN)
	KeyCtrlO          = Key(tcell.KeyCtrlO)
	KeyCtrlP          = Key(tcell.KeyCtrlP)
	KeyCtrlQ          = Key(tcell.KeyCtrlQ)
	KeyCtrlR          = Key(tcell.KeyCtrlR)
	KeyCtrlS          = Key(tcell.KeyCtrlS)
	KeyCtrlT          = Key(tcell.KeyCtrlT)
	KeyCtrlU          = Key(tcell.KeyCtrlU)
	KeyCtrlV          = Key(tcell.KeyCtrlV)
	KeyCtrlW          = Key(tcell.KeyCtrlW)
	KeyCtrlX          = Key(tcell.KeyCtrlX)
	KeyCtrlY          = Key(tcell.KeyCtrlY)
	KeyCtrlZ          = Key(tcell.KeyCtrlZ)
	KeyCtrlUnderscore = Key(tcell.KeyCtrlUnderscore)
	KeyBackspace      = Key(tcell.KeyBackspace)
	KeyBackspace2     = Key(tcell.KeyBackspace2)
	KeyTab            = Key(tcell.KeyTab)
	KeyEnter          = Key(tcell.KeyEnter)
	KeyEsc            = Key(tcell.KeyEscape)
	KeyPgdn           = Key(tcell.KeyPgDn)
	KeyPgup           = Key(tcell.KeyPgUp)
	KeySpace          = Key(tcell.Key(' '))
	KeyTilde          = Key(tcell.Key('~'))
	KeyCtrlSpace      = Key(tcell.KeyCtrlSpace)

	// The following assignments are provided for termbox
	// compatibility.  Their use in applications is discouraged.
	// The mouse keys are completely not supported as tcell uses
	// a separate mouse event instead of key strokes.
	MouseLeft         = Key(tcell.KeyF63) // arbitrary assignments
	MouseRight        = Key(tcell.KeyF62)
	MouseMiddle       = Key(tcell.KeyF61)
	MouseRelease      = Key(tcell.KeyF60)
	MouseWheelUp      = Key(tcell.KeyF59)
	MouseWheelDown    = Key(tcell.KeyF58)
	KeyCtrlTilde      = Key(tcell.KeyCtrlSpace) // termbox defines a bunch of weird ones, don't use them
	KeyCtrl2          = Key(tcell.KeyNUL)
	KeyCtrl3          = Key(tcell.KeyEscape)
	KeyCtrl4          = Key(tcell.KeyCtrlBackslash)
	KeyCtrl5          = Key(tcell.KeyCtrlRightSq)
	KeyCtrl6          = Key(tcell.KeyCtrlCarat)
	KeyCtrl7          = Key(tcell.KeyCtrlUnderscore)
	KeyCtrl8          = Key(tcell.KeyDEL)
	KeyCtrlSlash      = Key(tcell.KeyCtrlUnderscore)
	KeyCtrlRsqBracket = Key(tcell.KeyCtrlRightSq)
	KeyCtrlBackslash  = Key(tcell.KeyCtrlBackslash)
	KeyCtrlLsqBracket = Key(tcell.KeyCtrlLeftSq)
)

Keys codes.

const (
	ModAlt = Modifier(tcell.ModAlt)
)

Modifiers.

Functions

func Clear

func Clear(fg, bg Attribute)

Clear clears the screen with the given attributes.

func Close

func Close()

Close cleans up the terminal, restoring terminal modes, etc.

func Flush

func Flush() error

Flush updates the screen.

func HideCursor

func HideCursor()

HideCursor hides the terminal cursor.

func Init

func Init() error

Init initializes the screen for use.

func Interrupt

func Interrupt()

Interrupt posts an interrupt event.

func SetCell

func SetCell(x, y int, ch rune, fg, bg Attribute)

SetCell sets the character cell at a given location to the given content (rune) and attributes.

func SetCursor

func SetCursor(x, y int)

SetCursor displays the terminal cursor at the given location.

func Size

func Size() (int, int)

Size returns the screen size as width, height in character cells.

func Sync

func Sync() error

Sync forces a resync of the screen.

Types

type Attribute

type Attribute uint16

Attribute affects the presentation of characters, such as color, boldness, and so forth.

const (
	ColorDefault Attribute = iota
	ColorBlack
	ColorRed
	ColorGreen
	ColorYellow
	ColorBlue
	ColorMagenta
	ColorCyan
	ColorWhite
)

Colors first. The order here is significant.

const (
	AttrBold Attribute = 1 << (9 + iota)
	AttrUnderline
	AttrReverse
)

Other attributes.

type Cell

type Cell struct {
	Ch rune
	Fg Attribute
	Bg Attribute
}

Cell represents a single character cell on screen.

type Event

type Event struct {
	Type   EventType
	Mod    Modifier
	Key    Key
	Ch     rune
	Width  int
	Height int
	Err    error
	MouseX int
	MouseY int
	N      int
}

Event represents an event like a key press, mouse action, or window resize.

func ParseEvent

func ParseEvent(data []byte) Event

ParseEvent is not supported.

func PollEvent

func PollEvent() Event

PollEvent blocks until an event is ready, and then returns it.

func PollRawEvent

func PollRawEvent(data []byte) Event

PollRawEvent is not supported.

type EventType

type EventType uint8

EventType represents the type of event.

const (
	EventNone EventType = iota
	EventKey
	EventResize
	EventMouse
	EventInterrupt
	EventError
	EventRaw
)

Event types.

type InputMode

type InputMode int

InputMode is not used.

const (
	InputCurrent InputMode = iota
	InputEsc
	InputAlt
	InputMouse
)

Unused input modes; here for compatibility.

func SetInputMode

func SetInputMode(mode InputMode) InputMode

SetInputMode does not do anything in this version.

type Key

type Key tcell.Key

Key is a key press.

type Modifier

type Modifier tcell.ModMask

Modifier represents the possible modifier keys.

type OutputMode

type OutputMode int

OutputMode represents an output mode, which determines how colors are used. See the termbox documentation for an explanation.

const (
	OutputCurrent OutputMode = iota
	OutputNormal
	Output256
	Output216
	OutputGrayscale
)

OutputMode values.

func SetOutputMode

func SetOutputMode(mode OutputMode) OutputMode

SetOutputMode is used to set the color palette used.