README

Rich Interactive Widgets for Terminal UIs

PkgGoDev Go Report

This Go package provides commonly needed components for terminal based user interfaces.

Screenshot

Among these components are:

  • Input forms (include input/password fields, drop-down selections, checkboxes, and buttons)
  • Navigable multi-color text views
  • Sophisticated navigable table views
  • Flexible tree views
  • Selectable lists
  • Grid, Flexbox and page layouts
  • Modal message windows
  • An application wrapper

They come with lots of customization options and can be easily extended to fit your needs.

Installation

go get github.com/rivo/tview

Hello World

This basic example creates a box titled "Hello, World!" and displays it in your terminal:

package main

import (
	"github.com/rivo/tview"
)

func main() {
	box := tview.NewBox().SetBorder(true).SetTitle("Hello, world!")
	if err := tview.NewApplication().SetRoot(box, true).Run(); err != nil {
		panic(err)
	}
}

Check out the GitHub Wiki for more examples along with screenshots. Or try the examples in the "demos" subdirectory.

For a presentation highlighting this package, compile and run the program found in the "demos/presentation" subdirectory.

Projects using tview

Documentation

Refer to https://pkg.go.dev/github.com/rivo/tview for the package's documentation. Also check out the Wiki.

Dependencies

This package is based on github.com/gdamore/tcell (and its dependencies) as well as on github.com/rivo/uniseg.

Versioning and Backwards-Compatibility

I try really hard to keep this project backwards compatible. Your software should not break when you upgrade tview. But this also means that some of its shortcomings that were present in the initial versions will remain. In addition, at least for the time being, you won't find any version tags in this repo. The newest version should be the one to upgrade to. It has all the bugfixes and latest features. Having said that, backwards compatibility may still break when:

  • a new version of an imported package (most likely tcell) changes in such a way that forces me to make changes in tview as well,
  • I fix something that I consider a bug, rather than a feature, something that does not work as originally intended,
  • I make changes to "internal" interfaces such as Primitive. You shouldn't need these interfaces unless you're writing your own primitives for tview. (Yes, I realize these are public interfaces. This has advantages as well as disadvantages. For the time being, it is what it is.)

Your Feedback

Add your issue here on GitHub. Feel free to get in touch if you have any questions.

Documentation

Overview

Package tview implements rich widgets for terminal based user interfaces. The widgets provided with this package are useful for data exploration and data entry.

Widgets

The package implements the following widgets:

- TextView: A scrollable window that display multi-colored text. Text may also
  be highlighted.
- Table: A scrollable display of tabular data. Table cells, rows, or columns
  may also be highlighted.
- TreeView: A scrollable display for hierarchical data. Tree nodes can be
  highlighted, collapsed, expanded, and more.
- List: A navigable text list with optional keyboard shortcuts.
- InputField: One-line input fields to enter text.
- DropDown: Drop-down selection fields.
- Checkbox: Selectable checkbox for boolean values.
- Button: Buttons which get activated when the user selects them.
- Form: Forms composed of input fields, drop down selections, checkboxes, and
  buttons.
- Modal: A centered window with a text message and one or more buttons.
- Grid: A grid based layout manager.
- Flex: A Flexbox based layout manager.
- Pages: A page based layout manager.

The package also provides Application which is used to poll the event queue and draw widgets on screen.

Hello World

The following is a very basic example showing a box with the title "Hello, world!":

package main

import (
	"github.com/rivo/tview"
)

func main() {
	box := tview.NewBox().SetBorder(true).SetTitle("Hello, world!")
	if err := tview.NewApplication().SetRoot(box, true).Run(); err != nil {
		panic(err)
	}
}

First, we create a box primitive with a border and a title. Then we create an application, set the box as its root primitive, and run the event loop. The application exits when the application's Stop() function is called or when Ctrl-C is pressed.

If we have a primitive which consumes key presses, we call the application's SetFocus() function to redirect all key presses to that primitive. Most primitives then offer ways to install handlers that allow you to react to any actions performed on them.

More Demos

You will find more demos in the "demos" subdirectory. It also contains a presentation (written using tview) which gives an overview of the different widgets and how they can be used.

Colors

Throughout this package, colors are specified using the tcell.Color type. Functions such as tcell.GetColor(), tcell.NewHexColor(), and tcell.NewRGBColor() can be used to create colors from W3C color names or RGB values.

Almost all strings which are displayed can contain color tags. Color tags are W3C color names or six hexadecimal digits following a hash tag, wrapped in square brackets. Examples:

This is a [red]warning[white]!
The sky is [#8080ff]blue[#ffffff].

A color tag changes the color of the characters following that color tag. This applies to almost everything from box titles, list text, form item labels, to table cells. In a TextView, this functionality has to be switched on explicitly. See the TextView documentation for more information.

Color tags may contain not just the foreground (text) color but also the background color and additional flags. In fact, the full definition of a color tag is as follows:

[<foreground>:<background>:<flags>]

Each of the three fields can be left blank and trailing fields can be omitted. (Empty square brackets "[]", however, are not considered color tags.) Colors that are not specified will be left unchanged. A field with just a dash ("-") means "reset to default".

You can specify the following flags (some flags may not be supported by your terminal):

l: blink
b: bold
d: dim
r: reverse (switch foreground and background color)
u: underline

Examples:

[yellow]Yellow text
[yellow:red]Yellow text on red background
[:red]Red background, text color unchanged
[yellow::u]Yellow text underlined
[::bl]Bold, blinking text
[::-]Colors unchanged, flags reset
[-]Reset foreground color
[-:-:-]Reset everything
[:]No effect
[]Not a valid color tag, will print square brackets as they are

In the rare event that you want to display a string such as "[red]" or "[#00ff1a]" without applying its effect, you need to put an opening square bracket before the closing square bracket. Note that the text inside the brackets will be matched less strictly than region or colors tags. I.e. any character that may be used in color or region tags will be recognized. Examples:

[red[]      will be output as [red]
["123"[]    will be output as ["123"]
[#6aff00[[] will be output as [#6aff00[]
[a#"[[[]    will be output as [a#"[[]
[]          will be output as [] (see color tags above)
[[]         will be output as [[] (not an escaped tag)

You can use the Escape() function to insert brackets automatically where needed.

Styles

When primitives are instantiated, they are initialized with colors taken from the global Styles variable. You may change this variable to adapt the look and feel of the primitives to your preferred style.

Unicode Support

This package supports unicode characters including wide characters.

Concurrency

Many functions in this package are not thread-safe. For many applications, this may not be an issue: If your code makes changes in response to key events, it will execute in the main goroutine and thus will not cause any race conditions.

If you access your primitives from other goroutines, however, you will need to synchronize execution. The easiest way to do this is to call Application.QueueUpdate() or Application.QueueUpdateDraw() (see the function documentation for details):

go func() {
  app.QueueUpdateDraw(func() {
    table.SetCellSimple(0, 0, "Foo bar")
  })
}()

One exception to this is the io.Writer interface implemented by TextView. You can safely write to a TextView from any goroutine. See the TextView documentation for details.

You can also call Application.Draw() from any goroutine without having to wrap it in QueueUpdate(). And, as mentioned above, key event callbacks are executed in the main goroutine and thus should not use QueueUpdate() as that may lead to deadlocks.

Type Hierarchy

All widgets listed above contain the Box type. All of Box's functions are therefore available for all widgets, too.

All widgets also implement the Primitive interface.

The tview package is based on https://github.com/gdamore/tcell. It uses types and constants from that package (e.g. colors and keyboard values).

This package does not process mouse input (yet).

Index

Constants

View Source
const (
	FlexRow = iota
	FlexColumn
)

    Configuration values.

    View Source
    const (
    	// Block: General Punctation U+2000-U+206F (http://unicode.org/charts/PDF/U2000.pdf)
    	SemigraphicsHorizontalEllipsis rune = '\u2026' // …
    
    	// Block: Box Drawing U+2500-U+257F (http://unicode.org/charts/PDF/U2500.pdf)
    	BoxDrawingsLightHorizontal                    rune = '\u2500' // ─
    	BoxDrawingsHeavyHorizontal                    rune = '\u2501' // ━
    	BoxDrawingsLightVertical                      rune = '\u2502' // │
    	BoxDrawingsHeavyVertical                      rune = '\u2503' // ┃
    	BoxDrawingsLightTripleDashHorizontal          rune = '\u2504' // ┄
    	BoxDrawingsHeavyTripleDashHorizontal          rune = '\u2505' // ┅
    	BoxDrawingsLightTripleDashVertical            rune = '\u2506' // ┆
    	BoxDrawingsHeavyTripleDashVertical            rune = '\u2507' // ┇
    	BoxDrawingsLightQuadrupleDashHorizontal       rune = '\u2508' // ┈
    	BoxDrawingsHeavyQuadrupleDashHorizontal       rune = '\u2509' // ┉
    	BoxDrawingsLightQuadrupleDashVertical         rune = '\u250a' // ┊
    	BoxDrawingsHeavyQuadrupleDashVertical         rune = '\u250b' // ┋
    	BoxDrawingsLightDownAndRight                  rune = '\u250c' // ┌
    	BoxDrawingsDownLighAndRightHeavy              rune = '\u250d' // ┍
    	BoxDrawingsDownHeavyAndRightLight             rune = '\u250e' // ┎
    	BoxDrawingsHeavyDownAndRight                  rune = '\u250f' // ┏
    	BoxDrawingsLightDownAndLeft                   rune = '\u2510' // ┐
    	BoxDrawingsDownLighAndLeftHeavy               rune = '\u2511' // ┑
    	BoxDrawingsDownHeavyAndLeftLight              rune = '\u2512' // ┒
    	BoxDrawingsHeavyDownAndLeft                   rune = '\u2513' // ┓
    	BoxDrawingsLightUpAndRight                    rune = '\u2514' // └
    	BoxDrawingsUpLightAndRightHeavy               rune = '\u2515' // ┕
    	BoxDrawingsUpHeavyAndRightLight               rune = '\u2516' // ┖
    	BoxDrawingsHeavyUpAndRight                    rune = '\u2517' // ┗
    	BoxDrawingsLightUpAndLeft                     rune = '\u2518' // ┘
    	BoxDrawingsUpLightAndLeftHeavy                rune = '\u2519' // ┙
    	BoxDrawingsUpHeavyAndLeftLight                rune = '\u251a' // ┚
    	BoxDrawingsHeavyUpAndLeft                     rune = '\u251b' // ┛
    	BoxDrawingsLightVerticalAndRight              rune = '\u251c' // ├
    	BoxDrawingsVerticalLightAndRightHeavy         rune = '\u251d' // ┝
    	BoxDrawingsUpHeavyAndRightDownLight           rune = '\u251e' // ┞
    	BoxDrawingsDownHeacyAndRightUpLight           rune = '\u251f' // ┟
    	BoxDrawingsVerticalHeavyAndRightLight         rune = '\u2520' // ┠
    	BoxDrawingsDownLightAnbdRightUpHeavy          rune = '\u2521' // ┡
    	BoxDrawingsUpLightAndRightDownHeavy           rune = '\u2522' // ┢
    	BoxDrawingsHeavyVerticalAndRight              rune = '\u2523' // ┣
    	BoxDrawingsLightVerticalAndLeft               rune = '\u2524' // ┤
    	BoxDrawingsVerticalLightAndLeftHeavy          rune = '\u2525' // ┥
    	BoxDrawingsUpHeavyAndLeftDownLight            rune = '\u2526' // ┦
    	BoxDrawingsDownHeavyAndLeftUpLight            rune = '\u2527' // ┧
    	BoxDrawingsVerticalheavyAndLeftLight          rune = '\u2528' // ┨
    	BoxDrawingsDownLightAndLeftUpHeavy            rune = '\u2529' // ┨
    	BoxDrawingsUpLightAndLeftDownHeavy            rune = '\u252a' // ┪
    	BoxDrawingsHeavyVerticalAndLeft               rune = '\u252b' // ┫
    	BoxDrawingsLightDownAndHorizontal             rune = '\u252c' // ┬
    	BoxDrawingsLeftHeavyAndRightDownLight         rune = '\u252d' // ┭
    	BoxDrawingsRightHeavyAndLeftDownLight         rune = '\u252e' // ┮
    	BoxDrawingsDownLightAndHorizontalHeavy        rune = '\u252f' // ┯
    	BoxDrawingsDownHeavyAndHorizontalLight        rune = '\u2530' // ┰
    	BoxDrawingsRightLightAndLeftDownHeavy         rune = '\u2531' // ┱
    	BoxDrawingsLeftLightAndRightDownHeavy         rune = '\u2532' // ┲
    	BoxDrawingsHeavyDownAndHorizontal             rune = '\u2533' // ┳
    	BoxDrawingsLightUpAndHorizontal               rune = '\u2534' // ┴
    	BoxDrawingsLeftHeavyAndRightUpLight           rune = '\u2535' // ┵
    	BoxDrawingsRightHeavyAndLeftUpLight           rune = '\u2536' // ┶
    	BoxDrawingsUpLightAndHorizontalHeavy          rune = '\u2537' // ┷
    	BoxDrawingsUpHeavyAndHorizontalLight          rune = '\u2538' // ┸
    	BoxDrawingsRightLightAndLeftUpHeavy           rune = '\u2539' // ┹
    	BoxDrawingsLeftLightAndRightUpHeavy           rune = '\u253a' // ┺
    	BoxDrawingsHeavyUpAndHorizontal               rune = '\u253b' // ┻
    	BoxDrawingsLightVerticalAndHorizontal         rune = '\u253c' // ┼
    	BoxDrawingsLeftHeavyAndRightVerticalLight     rune = '\u253d' // ┽
    	BoxDrawingsRightHeavyAndLeftVerticalLight     rune = '\u253e' // ┾
    	BoxDrawingsVerticalLightAndHorizontalHeavy    rune = '\u253f' // ┿
    	BoxDrawingsUpHeavyAndDownHorizontalLight      rune = '\u2540' // ╀
    	BoxDrawingsDownHeavyAndUpHorizontalLight      rune = '\u2541' // ╁
    	BoxDrawingsVerticalHeavyAndHorizontalLight    rune = '\u2542' // ╂
    	BoxDrawingsLeftUpHeavyAndRightDownLight       rune = '\u2543' // ╃
    	BoxDrawingsRightUpHeavyAndLeftDownLight       rune = '\u2544' // ╄
    	BoxDrawingsLeftDownHeavyAndRightUpLight       rune = '\u2545' // ╅
    	BoxDrawingsRightDownHeavyAndLeftUpLight       rune = '\u2546' // ╆
    	BoxDrawingsDownLightAndUpHorizontalHeavy      rune = '\u2547' // ╇
    	BoxDrawingsUpLightAndDownHorizontalHeavy      rune = '\u2548' // ╈
    	BoxDrawingsRightLightAndLeftVerticalHeavy     rune = '\u2549' // ╉
    	BoxDrawingsLeftLightAndRightVerticalHeavy     rune = '\u254a' // ╊
    	BoxDrawingsHeavyVerticalAndHorizontal         rune = '\u254b' // ╋
    	BoxDrawingsLightDoubleDashHorizontal          rune = '\u254c' // ╌
    	BoxDrawingsHeavyDoubleDashHorizontal          rune = '\u254d' // ╍
    	BoxDrawingsLightDoubleDashVertical            rune = '\u254e' // ╎
    	BoxDrawingsHeavyDoubleDashVertical            rune = '\u254f' // ╏
    	BoxDrawingsDoubleHorizontal                   rune = '\u2550' // ═
    	BoxDrawingsDoubleVertical                     rune = '\u2551' // ║
    	BoxDrawingsDownSingleAndRightDouble           rune = '\u2552' // ╒
    	BoxDrawingsDownDoubleAndRightSingle           rune = '\u2553' // ╓
    	BoxDrawingsDoubleDownAndRight                 rune = '\u2554' // ╔
    	BoxDrawingsDownSingleAndLeftDouble            rune = '\u2555' // ╕
    	BoxDrawingsDownDoubleAndLeftSingle            rune = '\u2556' // ╖
    	BoxDrawingsDoubleDownAndLeft                  rune = '\u2557' // ╗
    	BoxDrawingsUpSingleAndRightDouble             rune = '\u2558' // ╘
    	BoxDrawingsUpDoubleAndRightSingle             rune = '\u2559' // ╙
    	BoxDrawingsDoubleUpAndRight                   rune = '\u255a' // ╚
    	BoxDrawingsUpSingleAndLeftDouble              rune = '\u255b' // ╛
    	BoxDrawingsUpDobuleAndLeftSingle              rune = '\u255c' // ╜
    	BoxDrawingsDoubleUpAndLeft                    rune = '\u255d' // ╝
    	BoxDrawingsVerticalSingleAndRightDouble       rune = '\u255e' // ╞
    	BoxDrawingsVerticalDoubleAndRightSingle       rune = '\u255f' // ╟
    	BoxDrawingsDoubleVerticalAndRight             rune = '\u2560' // ╠
    	BoxDrawingsVerticalSingleAndLeftDouble        rune = '\u2561' // ╡
    	BoxDrawingsVerticalDoubleAndLeftSingle        rune = '\u2562' // ╢
    	BoxDrawingsDoubleVerticalAndLeft              rune = '\u2563' // ╣
    	BoxDrawingsDownSingleAndHorizontalDouble      rune = '\u2564' // ╤
    	BoxDrawingsDownDoubleAndHorizontalSingle      rune = '\u2565' // ╥
    	BoxDrawingsDoubleDownAndHorizontal            rune = '\u2566' // ╦
    	BoxDrawingsUpSingleAndHorizontalDouble        rune = '\u2567' // ╧
    	BoxDrawingsUpDoubleAndHorizontalSingle        rune = '\u2568' // ╨
    	BoxDrawingsDoubleUpAndHorizontal              rune = '\u2569' // ╩
    	BoxDrawingsVerticalSingleAndHorizontalDouble  rune = '\u256a' // ╪
    	BoxDrawingsVerticalDoubleAndHorizontalSingle  rune = '\u256b' // ╫
    	BoxDrawingsDoubleVerticalAndHorizontal        rune = '\u256c' // ╬
    	BoxDrawingsLightArcDownAndRight               rune = '\u256d' // ╭
    	BoxDrawingsLightArcDownAndLeft                rune = '\u256e' // ╮
    	BoxDrawingsLightArcUpAndLeft                  rune = '\u256f' // ╯
    	BoxDrawingsLightArcUpAndRight                 rune = '\u2570' // ╰
    	BoxDrawingsLightDiagonalUpperRightToLowerLeft rune = '\u2571' // ╱
    	BoxDrawingsLightDiagonalUpperLeftToLowerRight rune = '\u2572' // ╲
    	BoxDrawingsLightDiagonalCross                 rune = '\u2573' // ╳
    	BoxDrawingsLightLeft                          rune = '\u2574' // ╴
    	BoxDrawingsLightUp                            rune = '\u2575' // ╵
    	BoxDrawingsLightRight                         rune = '\u2576' // ╶
    	BoxDrawingsLightDown                          rune = '\u2577' // ╷
    	BoxDrawingsHeavyLeft                          rune = '\u2578' // ╸
    	BoxDrawingsHeavyUp                            rune = '\u2579' // ╹
    	BoxDrawingsHeavyRight                         rune = '\u257a' // ╺
    	BoxDrawingsHeavyDown                          rune = '\u257b' // ╻
    	BoxDrawingsLightLeftAndHeavyRight             rune = '\u257c' // ╼
    	BoxDrawingsLightUpAndHeavyDown                rune = '\u257d' // ╽
    	BoxDrawingsHeavyLeftAndLightRight             rune = '\u257e' // ╾
    	BoxDrawingsHeavyUpAndLightDown                rune = '\u257f' // ╿
    )

      Semigraphics provides an easy way to access unicode characters for drawing.

      Named like the unicode characters, 'Semigraphics'-prefix used if unicode block isn't prefixed itself.

      View Source
      const (
      	AlignLeft = iota
      	AlignCenter
      	AlignRight
      )

        Text alignment within a box.

        Variables

        View Source
        var (
        	// InputFieldInteger accepts integers.
        	InputFieldInteger func(text string, ch rune) bool
        
        	// InputFieldFloat accepts floating-point numbers.
        	InputFieldFloat func(text string, ch rune) bool
        
        	// InputFieldMaxLength returns an input field accept handler which accepts
        	// input strings up to a given length. Use it like this:
        	//
        	//   inputField.SetAcceptanceFunc(InputFieldMaxLength(10)) // Accept up to 10 characters.
        	InputFieldMaxLength func(maxLength int) func(text string, ch rune) bool
        )

          Predefined InputField acceptance functions.

          View Source
          var Borders = struct {
          	Horizontal  rune
          	Vertical    rune
          	TopLeft     rune
          	TopRight    rune
          	BottomLeft  rune
          	BottomRight rune
          
          	LeftT   rune
          	RightT  rune
          	TopT    rune
          	BottomT rune
          	Cross   rune
          
          	HorizontalFocus  rune
          	VerticalFocus    rune
          	TopLeftFocus     rune
          	TopRightFocus    rune
          	BottomLeftFocus  rune
          	BottomRightFocus rune
          }{
          	Horizontal:  BoxDrawingsLightHorizontal,
          	Vertical:    BoxDrawingsLightVertical,
          	TopLeft:     BoxDrawingsLightDownAndRight,
          	TopRight:    BoxDrawingsLightDownAndLeft,
          	BottomLeft:  BoxDrawingsLightUpAndRight,
          	BottomRight: BoxDrawingsLightUpAndLeft,
          
          	LeftT:   BoxDrawingsLightVerticalAndRight,
          	RightT:  BoxDrawingsLightVerticalAndLeft,
          	TopT:    BoxDrawingsLightDownAndHorizontal,
          	BottomT: BoxDrawingsLightUpAndHorizontal,
          	Cross:   BoxDrawingsLightVerticalAndHorizontal,
          
          	HorizontalFocus:  BoxDrawingsDoubleHorizontal,
          	VerticalFocus:    BoxDrawingsDoubleVertical,
          	TopLeftFocus:     BoxDrawingsDoubleDownAndRight,
          	TopRightFocus:    BoxDrawingsDoubleDownAndLeft,
          	BottomLeftFocus:  BoxDrawingsDoubleUpAndRight,
          	BottomRightFocus: BoxDrawingsDoubleUpAndLeft,
          }

            Borders defines various borders used when primitives are drawn. These may be changed to accommodate a different look and feel.

            View Source
            var DefaultFormFieldWidth = 10

              DefaultFormFieldWidth is the default field screen width of form elements whose field width is flexible (0). This is used in the Form class for horizontal layouts.

              View Source
              var DoubleClickInterval = 500 * time.Millisecond

                DoubleClickInterval specifies the maximum time between clicks to register a double click rather than click.

                View Source
                var SemigraphicJoints = map[string]rune{
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightVertical}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightDownAndRight}): BoxDrawingsLightDownAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightDownAndLeft}): BoxDrawingsLightDownAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightUpAndRight}): BoxDrawingsLightUpAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightUpAndLeft}): BoxDrawingsLightUpAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightVerticalAndRight}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightVerticalAndLeft}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightDownAndHorizontal}): BoxDrawingsLightDownAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightUpAndHorizontal,
                
                	string([]rune{BoxDrawingsLightHorizontal, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightDownAndRight}): BoxDrawingsLightVerticalAndRight,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightDownAndLeft}): BoxDrawingsLightVerticalAndLeft,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightUpAndRight}): BoxDrawingsLightVerticalAndRight,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightUpAndLeft}): BoxDrawingsLightVerticalAndLeft,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightVerticalAndRight}): BoxDrawingsLightVerticalAndRight,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightVerticalAndLeft}): BoxDrawingsLightVerticalAndLeft,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightDownAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVertical, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndRight, BoxDrawingsLightDownAndLeft}): BoxDrawingsLightDownAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndRight, BoxDrawingsLightUpAndRight}): BoxDrawingsLightVerticalAndRight,
                
                	string([]rune{BoxDrawingsLightDownAndRight, BoxDrawingsLightUpAndLeft}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndRight, BoxDrawingsLightVerticalAndRight}): BoxDrawingsLightVerticalAndRight,
                
                	string([]rune{BoxDrawingsLightDownAndRight, BoxDrawingsLightVerticalAndLeft}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndRight, BoxDrawingsLightDownAndHorizontal}): BoxDrawingsLightDownAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndRight, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndRight, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndLeft, BoxDrawingsLightUpAndRight}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndLeft, BoxDrawingsLightUpAndLeft}): BoxDrawingsLightVerticalAndLeft,
                
                	string([]rune{BoxDrawingsLightDownAndLeft, BoxDrawingsLightVerticalAndRight}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndLeft, BoxDrawingsLightVerticalAndLeft}): BoxDrawingsLightVerticalAndLeft,
                
                	string([]rune{BoxDrawingsLightDownAndLeft, BoxDrawingsLightDownAndHorizontal}): BoxDrawingsLightDownAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndLeft, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndLeft, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndRight, BoxDrawingsLightUpAndLeft}): BoxDrawingsLightUpAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndRight, BoxDrawingsLightVerticalAndRight}): BoxDrawingsLightVerticalAndRight,
                
                	string([]rune{BoxDrawingsLightUpAndRight, BoxDrawingsLightVerticalAndLeft}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndRight, BoxDrawingsLightDownAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndRight, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightUpAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndRight, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndLeft, BoxDrawingsLightVerticalAndRight}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndLeft, BoxDrawingsLightVerticalAndLeft}): BoxDrawingsLightVerticalAndLeft,
                
                	string([]rune{BoxDrawingsLightUpAndLeft, BoxDrawingsLightDownAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndLeft, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightUpAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndLeft, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVerticalAndRight, BoxDrawingsLightVerticalAndLeft}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVerticalAndRight, BoxDrawingsLightDownAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVerticalAndRight, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVerticalAndRight, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVerticalAndLeft, BoxDrawingsLightDownAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVerticalAndLeft, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightVerticalAndLeft, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndHorizontal, BoxDrawingsLightUpAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightDownAndHorizontal, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                
                	string([]rune{BoxDrawingsLightUpAndHorizontal, BoxDrawingsLightVerticalAndHorizontal}): BoxDrawingsLightVerticalAndHorizontal,
                }

                  SemigraphicJoints is a map for joining semigraphic (or otherwise) runes. So far only light lines are supported but if you want to change the border styling you need to provide the joints, too. The matching will be sorted ascending by rune value, so you don't need to provide all rune combinations, e.g. (─) + (│) = (┼) will also match (│) + (─) = (┼)

                  View Source
                  var Styles = Theme{
                  	PrimitiveBackgroundColor:    tcell.ColorBlack,
                  	ContrastBackgroundColor:     tcell.ColorBlue,
                  	MoreContrastBackgroundColor: tcell.ColorGreen,
                  	BorderColor:                 tcell.ColorWhite,
                  	TitleColor:                  tcell.ColorWhite,
                  	GraphicsColor:               tcell.ColorWhite,
                  	PrimaryTextColor:            tcell.ColorWhite,
                  	SecondaryTextColor:          tcell.ColorYellow,
                  	TertiaryTextColor:           tcell.ColorGreen,
                  	InverseTextColor:            tcell.ColorBlue,
                  	ContrastSecondaryTextColor:  tcell.ColorDarkCyan,
                  }

                    Styles defines the theme for applications. The default is for a black background and some basic colors: black, white, yellow, green, cyan, and blue.

                    View Source
                    var (
                    
                    	// TabSize is the number of spaces with which a tab character will be replaced.
                    	TabSize = 4
                    )

                    Functions

                    func ANSIWriter

                    func ANSIWriter(writer io.Writer) io.Writer

                      ANSIWriter returns an io.Writer which translates any ANSI escape codes written to it into tview color tags. Other escape codes don't have an effect and are simply removed. The translated text is written to the provided writer.

                      func Escape

                      func Escape(text string) string

                        Escape escapes the given text such that color and/or region tags are not recognized and substituted by the print functions of this package. For example, to include a tag-like string in a box title or in a TextView:

                        box.SetTitle(tview.Escape("[squarebrackets]"))
                        fmt.Fprint(textView, tview.Escape(`["quoted"]`))
                        

                        func Print

                        func Print(screen tcell.Screen, text string, x, y, maxWidth, align int, color tcell.Color) (int, int)

                          Print prints text onto the screen into the given box at (x,y,maxWidth,1), not exceeding that box. "align" is one of AlignLeft, AlignCenter, or AlignRight. The screen's background color will not be changed.

                          You can change the colors and text styles mid-text by inserting a color tag. See the package description for details.

                          Returns the number of actual bytes of the text printed (including color tags) and the actual width used for the printed runes.

                          func PrintJoinedSemigraphics

                          func PrintJoinedSemigraphics(screen tcell.Screen, x, y int, ch rune, style tcell.Style)

                            PrintJoinedSemigraphics prints a semigraphics rune into the screen at the given position with the given style, joining it with any existing semigraphics rune.At this point, only regular single line borders are supported.

                            func PrintSimple

                            func PrintSimple(screen tcell.Screen, text string, x, y int)

                              PrintSimple prints white text to the screen at the given position.

                              func TaggedStringWidth

                              func TaggedStringWidth(text string) int

                                TaggedStringWidth returns the width of the given string needed to print it on screen. The text may contain color tags which are not counted.

                                func TranslateANSI

                                func TranslateANSI(text string) string

                                  TranslateANSI replaces ANSI escape sequences found in the provided string with tview's color tags and returns the resulting string.

                                  func WordWrap

                                  func WordWrap(text string, width int) (lines []string)

                                    WordWrap splits a text such that each resulting line does not exceed the given screen width. Possible split points are after any punctuation or whitespace. Whitespace after split points will be dropped.

                                    This function considers color tags to have no width.

                                    Text is always split at newline characters ('\n').

                                    Types

                                    type Application

                                    type Application struct {
                                    	sync.RWMutex
                                    	// contains filtered or unexported fields
                                    }

                                      Application represents the top node of an application.

                                      It is not strictly required to use this class as none of the other classes depend on it. However, it provides useful tools to set up an application and plays nicely with all widgets.

                                      The following command displays a primitive p on the screen until Ctrl-C is pressed:

                                      if err := tview.NewApplication().SetRoot(p, true).Run(); err != nil {
                                          panic(err)
                                      }
                                      

                                      func NewApplication

                                      func NewApplication() *Application

                                        NewApplication creates and returns a new application.

                                        func (*Application) Draw

                                        func (a *Application) Draw() *Application

                                          Draw refreshes the screen (during the next update cycle). It calls the Draw() function of the application's root primitive and then syncs the screen buffer. It is almost never necessary to call this function. It can actually deadlock your application if you call it from the main thread (e.g. in a callback function of a widget). Please see https://github.com/rivo/tview/wiki/Concurrency for details.

                                          func (*Application) EnableMouse

                                          func (a *Application) EnableMouse(enable bool) *Application

                                            EnableMouse enables mouse events or disables them (if "false" is provided).

                                            func (*Application) ForceDraw

                                            func (a *Application) ForceDraw() *Application

                                              ForceDraw refreshes the screen immediately. Use this function with caution as it may lead to race conditions with updates to primitives in other goroutines. It is always preferrable to use Draw() instead. Never call this function from a goroutine.

                                              It is safe to call this function during queued updates and direct event handling.

                                              func (*Application) GetAfterDrawFunc

                                              func (a *Application) GetAfterDrawFunc() func(screen tcell.Screen)

                                                GetAfterDrawFunc returns the callback function installed with SetAfterDrawFunc() or nil if none has been installed.

                                                func (*Application) GetBeforeDrawFunc

                                                func (a *Application) GetBeforeDrawFunc() func(screen tcell.Screen) bool

                                                  GetBeforeDrawFunc returns the callback function installed with SetBeforeDrawFunc() or nil if none has been installed.

                                                  func (*Application) GetFocus

                                                  func (a *Application) GetFocus() Primitive

                                                    GetFocus returns the primitive which has the current focus. If none has it, nil is returned.

                                                    func (*Application) GetInputCapture

                                                    func (a *Application) GetInputCapture() func(event *tcell.EventKey) *tcell.EventKey

                                                      GetInputCapture returns the function installed with SetInputCapture() or nil if no such function has been installed.

                                                      func (*Application) GetMouseCapture

                                                      func (a *Application) GetMouseCapture() func(event *tcell.EventMouse, action MouseAction) (*tcell.EventMouse, MouseAction)

                                                        GetMouseCapture returns the function installed with SetMouseCapture() or nil if no such function has been installed.

                                                        func (*Application) QueueEvent

                                                        func (a *Application) QueueEvent(event tcell.Event) *Application

                                                          QueueEvent sends an event to the Application event loop.

                                                          It is not recommended for event to be nil.

                                                          func (*Application) QueueUpdate

                                                          func (a *Application) QueueUpdate(f func()) *Application

                                                            QueueUpdate is used to synchronize access to primitives from non-main goroutines. The provided function will be executed as part of the event loop and thus will not cause race conditions with other such update functions or the Draw() function.

                                                            Note that Draw() is not implicitly called after the execution of f as that may not be desirable. You can call Draw() from f if the screen should be refreshed after each update. Alternatively, use QueueUpdateDraw() to follow up with an immediate refresh of the screen.

                                                            This function returns after f has executed.

                                                            func (*Application) QueueUpdateDraw

                                                            func (a *Application) QueueUpdateDraw(f func()) *Application

                                                              QueueUpdateDraw works like QueueUpdate() except it refreshes the screen immediately after executing f.

                                                              func (*Application) ResizeToFullScreen

                                                              func (a *Application) ResizeToFullScreen(p Primitive) *Application

                                                                ResizeToFullScreen resizes the given primitive such that it fills the entire screen.

                                                                func (*Application) Run

                                                                func (a *Application) Run() error

                                                                  Run starts the application and thus the event loop. This function returns when Stop() was called.

                                                                  func (*Application) SetAfterDrawFunc

                                                                  func (a *Application) SetAfterDrawFunc(handler func(screen tcell.Screen)) *Application

                                                                    SetAfterDrawFunc installs a callback function which is invoked after the root primitive was drawn during screen updates.

                                                                    Provide nil to uninstall the callback function.

                                                                    func (*Application) SetBeforeDrawFunc

                                                                    func (a *Application) SetBeforeDrawFunc(handler func(screen tcell.Screen) bool) *Application

                                                                      SetBeforeDrawFunc installs a callback function which is invoked just before the root primitive is drawn during screen updates. If the function returns true, drawing will not continue, i.e. the root primitive will not be drawn (and an after-draw-handler will not be called).

                                                                      Note that the screen is not cleared by the application. To clear the screen, you may call screen.Clear().

                                                                      Provide nil to uninstall the callback function.

                                                                      func (*Application) SetFocus

                                                                      func (a *Application) SetFocus(p Primitive) *Application

                                                                        SetFocus sets the focus on a new primitive. All key events will be redirected to that primitive. Callers must ensure that the primitive will handle key events.

                                                                        Blur() will be called on the previously focused primitive. Focus() will be called on the new primitive.

                                                                        func (*Application) SetInputCapture

                                                                        func (a *Application) SetInputCapture(capture func(event *tcell.EventKey) *tcell.EventKey) *Application

                                                                          SetInputCapture sets a function which captures all key events before they are forwarded to the key event handler of the primitive which currently has focus. This function can then choose to forward that key event (or a different one) by returning it or stop the key event processing by returning nil.

                                                                          Note that this also affects the default event handling of the application itself: Such a handler can intercept the Ctrl-C event which closes the application.

                                                                          func (*Application) SetMouseCapture

                                                                          func (a *Application) SetMouseCapture(capture func(event *tcell.EventMouse, action MouseAction) (*tcell.EventMouse, MouseAction)) *Application

                                                                            SetMouseCapture sets a function which captures mouse events (consisting of the original tcell mouse event and the semantic mouse action) before they are forwarded to the appropriate mouse event handler. This function can then choose to forward that event (or a different one) by returning it or stop the event processing by returning a nil mouse event.

                                                                            func (*Application) SetRoot

                                                                            func (a *Application) SetRoot(root Primitive, fullscreen bool) *Application

                                                                              SetRoot sets the root primitive for this application. If "fullscreen" is set to true, the root primitive's position will be changed to fill the screen.

                                                                              This function must be called at least once or nothing will be displayed when the application starts.

                                                                              It also calls SetFocus() on the primitive.

                                                                              func (*Application) SetScreen

                                                                              func (a *Application) SetScreen(screen tcell.Screen) *Application

                                                                                SetScreen allows you to provide your own tcell.Screen object. For most applications, this is not needed and you should be familiar with tcell.Screen when using this function.

                                                                                This function is typically called before the first call to Run(). Init() need not be called on the screen.

                                                                                func (*Application) Stop

                                                                                func (a *Application) Stop()

                                                                                  Stop stops the application, causing Run() to return.

                                                                                  func (*Application) Suspend

                                                                                  func (a *Application) Suspend(f func()) bool

                                                                                    Suspend temporarily suspends the application by exiting terminal UI mode and invoking the provided function "f". When "f" returns, terminal UI mode is entered again and the application resumes.

                                                                                    A return value of true indicates that the application was suspended and "f" was called. If false is returned, the application was already suspended, terminal UI mode was not exited, and "f" was not called.

                                                                                    type Box

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

                                                                                      Box implements the Primitive interface with an empty background and optional elements such as a border and a title. Box itself does not hold any content but serves as the superclass of all other primitives. Subclasses add their own content, typically (but not necessarily) keeping their content within the box's rectangle.

                                                                                      Box provides a number of utility functions available to all primitives.

                                                                                      See https://github.com/rivo/tview/wiki/Box for an example.

                                                                                      func NewBox

                                                                                      func NewBox() *Box

                                                                                        NewBox returns a Box without a border.

                                                                                        func (*Box) Blur

                                                                                        func (b *Box) Blur()

                                                                                          Blur is called when this primitive loses focus.

                                                                                          func (*Box) Draw

                                                                                          func (b *Box) Draw(screen tcell.Screen)

                                                                                            Draw draws this primitive onto the screen.

                                                                                            func (*Box) DrawForSubclass

                                                                                            func (b *Box) DrawForSubclass(screen tcell.Screen, p Primitive)

                                                                                              DrawForSubclass draws this box under the assumption that primitive p is a subclass of this box. This is needed e.g. to draw proper box frames which depend on the subclass's focus.

                                                                                              Only call this function from your own custom primitives. It is not needed in applications that have no custom primitives.

                                                                                              func (*Box) Focus

                                                                                              func (b *Box) Focus(delegate func(p Primitive))

                                                                                                Focus is called when this primitive receives focus.

                                                                                                func (*Box) GetBackgroundColor

                                                                                                func (b *Box) GetBackgroundColor() tcell.Color

                                                                                                  GetBackgroundColor returns the box's background color.

                                                                                                  func (*Box) GetBorderAttributes

                                                                                                  func (b *Box) GetBorderAttributes() tcell.AttrMask

                                                                                                    GetBorderAttributes returns the border's style attributes.

                                                                                                    func (*Box) GetBorderColor

                                                                                                    func (b *Box) GetBorderColor() tcell.Color

                                                                                                      GetBorderColor returns the box's border color.

                                                                                                      func (*Box) GetDrawFunc

                                                                                                      func (b *Box) GetDrawFunc() func(screen tcell.Screen, x, y, width, height int) (int, int, int, int)

                                                                                                        GetDrawFunc returns the callback function which was installed with SetDrawFunc() or nil if no such function has been installed.

                                                                                                        func (*Box) GetInnerRect

                                                                                                        func (b *Box) GetInnerRect() (int, int, int, int)

                                                                                                          GetInnerRect returns the position of the inner rectangle (x, y, width, height), without the border and without any padding. Width and height values will clamp to 0 and thus never be negative.

                                                                                                          func (*Box) GetInputCapture

                                                                                                          func (b *Box) GetInputCapture() func(event *tcell.EventKey) *tcell.EventKey

                                                                                                            GetInputCapture returns the function installed with SetInputCapture() or nil if no such function has been installed.

                                                                                                            func (*Box) GetMouseCapture

                                                                                                            func (b *Box) GetMouseCapture() func(action MouseAction, event *tcell.EventMouse) (MouseAction, *tcell.EventMouse)

                                                                                                              GetMouseCapture returns the function installed with SetMouseCapture() or nil if no such function has been installed.

                                                                                                              func (*Box) GetRect

                                                                                                              func (b *Box) GetRect() (int, int, int, int)

                                                                                                                GetRect returns the current position of the rectangle, x, y, width, and height.

                                                                                                                func (*Box) GetTitle

                                                                                                                func (b *Box) GetTitle() string

                                                                                                                  GetTitle returns the box's current title.

                                                                                                                  func (*Box) HasFocus

                                                                                                                  func (b *Box) HasFocus() bool

                                                                                                                    HasFocus returns whether or not this primitive has focus.

                                                                                                                    func (*Box) InRect

                                                                                                                    func (b *Box) InRect(x, y int) bool

                                                                                                                      InRect returns true if the given coordinate is within the bounds of the box's rectangle.

                                                                                                                      func (*Box) InputHandler

                                                                                                                      func (b *Box) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                        InputHandler returns nil.

                                                                                                                        func (*Box) MouseHandler

                                                                                                                        func (b *Box) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                          MouseHandler returns nil.

                                                                                                                          func (*Box) SetBackgroundColor

                                                                                                                          func (b *Box) SetBackgroundColor(color tcell.Color) *Box

                                                                                                                            SetBackgroundColor sets the box's background color.

                                                                                                                            func (*Box) SetBorder

                                                                                                                            func (b *Box) SetBorder(show bool) *Box

                                                                                                                              SetBorder sets the flag indicating whether or not the box should have a border.

                                                                                                                              func (*Box) SetBorderAttributes

                                                                                                                              func (b *Box) SetBorderAttributes(attr tcell.AttrMask) *Box

                                                                                                                                SetBorderAttributes sets the border's style attributes. You can combine different attributes using bitmask operations:

                                                                                                                                box.SetBorderAttributes(tcell.AttrUnderline | tcell.AttrBold)
                                                                                                                                

                                                                                                                                func (*Box) SetBorderColor

                                                                                                                                func (b *Box) SetBorderColor(color tcell.Color) *Box

                                                                                                                                  SetBorderColor sets the box's border color.

                                                                                                                                  func (*Box) SetBorderPadding

                                                                                                                                  func (b *Box) SetBorderPadding(top, bottom, left, right int) *Box

                                                                                                                                    SetBorderPadding sets the size of the borders around the box content.

                                                                                                                                    func (*Box) SetDrawFunc

                                                                                                                                    func (b *Box) SetDrawFunc(handler func(screen tcell.Screen, x, y, width, height int) (int, int, int, int)) *Box

                                                                                                                                      SetDrawFunc sets a callback function which is invoked after the box primitive has been drawn. This allows you to add a more individual style to the box (and all primitives which extend it).

                                                                                                                                      The function is provided with the box's dimensions (set via SetRect()). It must return the box's inner dimensions (x, y, width, height) which will be returned by GetInnerRect(), used by descendent primitives to draw their own content.

                                                                                                                                      func (*Box) SetInputCapture

                                                                                                                                      func (b *Box) SetInputCapture(capture func(event *tcell.EventKey) *tcell.EventKey) *Box

                                                                                                                                        SetInputCapture installs a function which captures key events before they are forwarded to the primitive's default key event handler. This function can then choose to forward that key event (or a different one) to the default handler by returning it. If nil is returned, the default handler will not be called.

                                                                                                                                        Providing a nil handler will remove a previously existing handler.

                                                                                                                                        Note that this function will not have an effect on primitives composed of other primitives, such as Form, Flex, or Grid. Key events are only captured by the primitives that have focus (e.g. InputField) and only one primitive can have focus at a time. Composing primitives such as Form pass the focus on to their contained primitives and thus never receive any key events themselves. Therefore, they cannot intercept key events.

                                                                                                                                        func (*Box) SetMouseCapture

                                                                                                                                        func (b *Box) SetMouseCapture(capture func(action MouseAction, event *tcell.EventMouse) (MouseAction, *tcell.EventMouse)) *Box

                                                                                                                                          SetMouseCapture sets a function which captures mouse events (consisting of the original tcell mouse event and the semantic mouse action) before they are forwarded to the primitive's default mouse event handler. This function can then choose to forward that event (or a different one) by returning it or returning a nil mouse event, in which case the default handler will not be called.

                                                                                                                                          Providing a nil handler will remove a previously existing handler.

                                                                                                                                          func (*Box) SetRect

                                                                                                                                          func (b *Box) SetRect(x, y, width, height int)

                                                                                                                                            SetRect sets a new position of the primitive. Note that this has no effect if this primitive is part of a layout (e.g. Flex, Grid) or if it was added like this:

                                                                                                                                            application.SetRoot(b, true)
                                                                                                                                            

                                                                                                                                            func (*Box) SetTitle

                                                                                                                                            func (b *Box) SetTitle(title string) *Box

                                                                                                                                              SetTitle sets the box's title.

                                                                                                                                              func (*Box) SetTitleAlign

                                                                                                                                              func (b *Box) SetTitleAlign(align int) *Box

                                                                                                                                                SetTitleAlign sets the alignment of the title, one of AlignLeft, AlignCenter, or AlignRight.

                                                                                                                                                func (*Box) SetTitleColor

                                                                                                                                                func (b *Box) SetTitleColor(color tcell.Color) *Box

                                                                                                                                                  SetTitleColor sets the box's title color.

                                                                                                                                                  func (*Box) WrapInputHandler

                                                                                                                                                  func (b *Box) WrapInputHandler(inputHandler func(*tcell.EventKey, func(p Primitive))) func(*tcell.EventKey, func(p Primitive))

                                                                                                                                                    WrapInputHandler wraps an input handler (see InputHandler()) with the functionality to capture input (see SetInputCapture()) before passing it on to the provided (default) input handler.

                                                                                                                                                    This is only meant to be used by subclassing primitives.

                                                                                                                                                    func (*Box) WrapMouseHandler

                                                                                                                                                    func (b *Box) WrapMouseHandler(mouseHandler func(MouseAction, *tcell.EventMouse, func(p Primitive)) (bool, Primitive)) func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                      WrapMouseHandler wraps a mouse event handler (see MouseHandler()) with the functionality to capture mouse events (see SetMouseCapture()) before passing them on to the provided (default) event handler.

                                                                                                                                                      This is only meant to be used by subclassing primitives.

                                                                                                                                                      type Button

                                                                                                                                                      type Button struct {
                                                                                                                                                      	*Box
                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                      }

                                                                                                                                                        Button is labeled box that triggers an action when selected.

                                                                                                                                                        See https://github.com/rivo/tview/wiki/Button for an example.

                                                                                                                                                        func NewButton

                                                                                                                                                        func NewButton(label string) *Button

                                                                                                                                                          NewButton returns a new input field.

                                                                                                                                                          func (*Button) Draw

                                                                                                                                                          func (b *Button) Draw(screen tcell.Screen)

                                                                                                                                                            Draw draws this primitive onto the screen.

                                                                                                                                                            func (*Button) GetLabel

                                                                                                                                                            func (b *Button) GetLabel() string

                                                                                                                                                              GetLabel returns the button text.

                                                                                                                                                              func (*Button) InputHandler

                                                                                                                                                              func (b *Button) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                InputHandler returns the handler for this primitive.

                                                                                                                                                                func (*Button) MouseHandler

                                                                                                                                                                func (b *Button) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                  MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                  func (*Button) SetBackgroundColorActivated

                                                                                                                                                                  func (b *Button) SetBackgroundColorActivated(color tcell.Color) *Button

                                                                                                                                                                    SetBackgroundColorActivated sets the background color of the button text when the button is in focus.

                                                                                                                                                                    func (*Button) SetBlurFunc

                                                                                                                                                                    func (b *Button) SetBlurFunc(handler func(key tcell.Key)) *Button

                                                                                                                                                                      SetBlurFunc sets a handler which is called when the user leaves the button. The callback function is provided with the key that was pressed, which is one of the following:

                                                                                                                                                                      - KeyEscape: Leaving the button with no specific direction.
                                                                                                                                                                      - KeyTab: Move to the next field.
                                                                                                                                                                      - KeyBacktab: Move to the previous field.
                                                                                                                                                                      

                                                                                                                                                                      func (*Button) SetLabel

                                                                                                                                                                      func (b *Button) SetLabel(label string) *Button

                                                                                                                                                                        SetLabel sets the button text.

                                                                                                                                                                        func (*Button) SetLabelColor

                                                                                                                                                                        func (b *Button) SetLabelColor(color tcell.Color) *Button

                                                                                                                                                                          SetLabelColor sets the color of the button text.

                                                                                                                                                                          func (*Button) SetLabelColorActivated

                                                                                                                                                                          func (b *Button) SetLabelColorActivated(color tcell.Color) *Button

                                                                                                                                                                            SetLabelColorActivated sets the color of the button text when the button is in focus.

                                                                                                                                                                            func (*Button) SetSelectedFunc

                                                                                                                                                                            func (b *Button) SetSelectedFunc(handler func()) *Button

                                                                                                                                                                              SetSelectedFunc sets a handler which is called when the button was selected.

                                                                                                                                                                              type Checkbox

                                                                                                                                                                              type Checkbox struct {
                                                                                                                                                                              	*Box
                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                              }

                                                                                                                                                                                Checkbox implements a simple box for boolean values which can be checked and unchecked.

                                                                                                                                                                                See https://github.com/rivo/tview/wiki/Checkbox for an example.

                                                                                                                                                                                func NewCheckbox

                                                                                                                                                                                func NewCheckbox() *Checkbox

                                                                                                                                                                                  NewCheckbox returns a new input field.

                                                                                                                                                                                  func (*Checkbox) Draw

                                                                                                                                                                                  func (c *Checkbox) Draw(screen tcell.Screen)

                                                                                                                                                                                    Draw draws this primitive onto the screen.

                                                                                                                                                                                    func (*Checkbox) GetFieldWidth

                                                                                                                                                                                    func (c *Checkbox) GetFieldWidth() int

                                                                                                                                                                                      GetFieldWidth returns this primitive's field width.

                                                                                                                                                                                      func (*Checkbox) GetLabel

                                                                                                                                                                                      func (c *Checkbox) GetLabel() string

                                                                                                                                                                                        GetLabel returns the text to be displayed before the input area.

                                                                                                                                                                                        func (*Checkbox) InputHandler

                                                                                                                                                                                        func (c *Checkbox) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                          InputHandler returns the handler for this primitive.

                                                                                                                                                                                          func (*Checkbox) IsChecked

                                                                                                                                                                                          func (c *Checkbox) IsChecked() bool

                                                                                                                                                                                            IsChecked returns whether or not the box is checked.

                                                                                                                                                                                            func (*Checkbox) MouseHandler

                                                                                                                                                                                            func (c *Checkbox) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                              MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                              func (*Checkbox) SetChangedFunc

                                                                                                                                                                                              func (c *Checkbox) SetChangedFunc(handler func(checked bool)) *Checkbox

                                                                                                                                                                                                SetChangedFunc sets a handler which is called when the checked state of this checkbox was changed by the user. The handler function receives the new state.

                                                                                                                                                                                                func (*Checkbox) SetChecked

                                                                                                                                                                                                func (c *Checkbox) SetChecked(checked bool) *Checkbox

                                                                                                                                                                                                  SetChecked sets the state of the checkbox.

                                                                                                                                                                                                  func (*Checkbox) SetCheckedString

                                                                                                                                                                                                  func (c *Checkbox) SetCheckedString(checked string) *Checkbox

                                                                                                                                                                                                    SetCheckedString sets the string to be displayed when the checkbox is checked (defaults to "X").

                                                                                                                                                                                                    func (*Checkbox) SetDoneFunc

                                                                                                                                                                                                    func (c *Checkbox) SetDoneFunc(handler func(key tcell.Key)) *Checkbox

                                                                                                                                                                                                      SetDoneFunc sets a handler which is called when the user is done using the checkbox. The callback function is provided with the key that was pressed, which is one of the following:

                                                                                                                                                                                                      - KeyEscape: Abort text input.
                                                                                                                                                                                                      - KeyTab: Move to the next field.
                                                                                                                                                                                                      - KeyBacktab: Move to the previous field.
                                                                                                                                                                                                      

                                                                                                                                                                                                      func (*Checkbox) SetFieldBackgroundColor

                                                                                                                                                                                                      func (c *Checkbox) SetFieldBackgroundColor(color tcell.Color) *Checkbox

                                                                                                                                                                                                        SetFieldBackgroundColor sets the background color of the input area.

                                                                                                                                                                                                        func (*Checkbox) SetFieldTextColor

                                                                                                                                                                                                        func (c *Checkbox) SetFieldTextColor(color tcell.Color) *Checkbox

                                                                                                                                                                                                          SetFieldTextColor sets the text color of the input area.

                                                                                                                                                                                                          func (*Checkbox) SetFinishedFunc

                                                                                                                                                                                                          func (c *Checkbox) SetFinishedFunc(handler func(key tcell.Key)) FormItem

                                                                                                                                                                                                            SetFinishedFunc sets a callback invoked when the user leaves this form item.

                                                                                                                                                                                                            func (*Checkbox) SetFormAttributes

                                                                                                                                                                                                            func (c *Checkbox) SetFormAttributes(labelWidth int, labelColor, bgColor, fieldTextColor, fieldBgColor tcell.Color) FormItem

                                                                                                                                                                                                              SetFormAttributes sets attributes shared by all form items.

                                                                                                                                                                                                              func (*Checkbox) SetLabel

                                                                                                                                                                                                              func (c *Checkbox) SetLabel(label string) *Checkbox

                                                                                                                                                                                                                SetLabel sets the text to be displayed before the input area.

                                                                                                                                                                                                                func (*Checkbox) SetLabelColor

                                                                                                                                                                                                                func (c *Checkbox) SetLabelColor(color tcell.Color) *Checkbox

                                                                                                                                                                                                                  SetLabelColor sets the color of the label.

                                                                                                                                                                                                                  func (*Checkbox) SetLabelWidth

                                                                                                                                                                                                                  func (c *Checkbox) SetLabelWidth(width int) *Checkbox

                                                                                                                                                                                                                    SetLabelWidth sets the screen width of the label. A value of 0 will cause the primitive to use the width of the label string.

                                                                                                                                                                                                                    type DropDown struct {
                                                                                                                                                                                                                    	*Box
                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      DropDown implements a selection widget whose options become visible in a drop-down list when activated.

                                                                                                                                                                                                                      See https://github.com/rivo/tview/wiki/DropDown for an example.

                                                                                                                                                                                                                      func NewDropDown

                                                                                                                                                                                                                      func NewDropDown() *DropDown

                                                                                                                                                                                                                        NewDropDown returns a new drop-down.

                                                                                                                                                                                                                        func (d *DropDown) AddOption(text string, selected func()) *DropDown

                                                                                                                                                                                                                          AddOption adds a new selectable option to this drop-down. The "selected" callback is called when this option was selected. It may be nil.

                                                                                                                                                                                                                          func (d *DropDown) Draw(screen tcell.Screen)

                                                                                                                                                                                                                            Draw draws this primitive onto the screen.

                                                                                                                                                                                                                            func (d *DropDown) Focus(delegate func(p Primitive))

                                                                                                                                                                                                                              Focus is called by the application when the primitive receives focus.

                                                                                                                                                                                                                              func (d *DropDown) GetCurrentOption() (int, string)

                                                                                                                                                                                                                                GetCurrentOption returns the index of the currently selected option as well as its text. If no option was selected, -1 and an empty string is returned.

                                                                                                                                                                                                                                func (d *DropDown) GetFieldWidth() int

                                                                                                                                                                                                                                  GetFieldWidth returns this primitive's field screen width.

                                                                                                                                                                                                                                  func (d *DropDown) GetLabel() string

                                                                                                                                                                                                                                    GetLabel returns the text to be displayed before the input area.

                                                                                                                                                                                                                                    func (d *DropDown) HasFocus() bool

                                                                                                                                                                                                                                      HasFocus returns whether or not this primitive has focus.

                                                                                                                                                                                                                                      func (d *DropDown) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                        InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                        func (d *DropDown) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                          MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                          func (d *DropDown) SetCurrentOption(index int) *DropDown

                                                                                                                                                                                                                                            SetCurrentOption sets the index of the currently selected option. This may be a negative value to indicate that no option is currently selected. Calling this function will also trigger the "selected" callback (if there is one).

                                                                                                                                                                                                                                            func (d *DropDown) SetDoneFunc(handler func(key tcell.Key)) *DropDown

                                                                                                                                                                                                                                              SetDoneFunc sets a handler which is called when the user is done selecting options. The callback function is provided with the key that was pressed, which is one of the following:

                                                                                                                                                                                                                                              - KeyEscape: Abort selection.
                                                                                                                                                                                                                                              - KeyTab: Move to the next field.
                                                                                                                                                                                                                                              - KeyBacktab: Move to the previous field.
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              func (d *DropDown) SetFieldBackgroundColor(color tcell.Color) *DropDown

                                                                                                                                                                                                                                                SetFieldBackgroundColor sets the background color of the options area.

                                                                                                                                                                                                                                                func (d *DropDown) SetFieldTextColor(color tcell.Color) *DropDown

                                                                                                                                                                                                                                                  SetFieldTextColor sets the text color of the options area.

                                                                                                                                                                                                                                                  func (d *DropDown) SetFieldWidth(width int) *DropDown

                                                                                                                                                                                                                                                    SetFieldWidth sets the screen width of the options area. A value of 0 means extend to as long as the longest option text.

                                                                                                                                                                                                                                                    func (d *DropDown) SetFinishedFunc(handler func(key tcell.Key)) FormItem

                                                                                                                                                                                                                                                      SetFinishedFunc sets a callback invoked when the user leaves this form item.

                                                                                                                                                                                                                                                      func (d *DropDown) SetFormAttributes(labelWidth int, labelColor, bgColor, fieldTextColor, fieldBgColor tcell.Color) FormItem

                                                                                                                                                                                                                                                        SetFormAttributes sets attributes shared by all form items.

                                                                                                                                                                                                                                                        func (d *DropDown) SetLabel(label string) *DropDown

                                                                                                                                                                                                                                                          SetLabel sets the text to be displayed before the input area.

                                                                                                                                                                                                                                                          func (d *DropDown) SetLabelColor(color tcell.Color) *DropDown

                                                                                                                                                                                                                                                            SetLabelColor sets the color of the label.

                                                                                                                                                                                                                                                            func (d *DropDown) SetLabelWidth(width int) *DropDown

                                                                                                                                                                                                                                                              SetLabelWidth sets the screen width of the label. A value of 0 will cause the primitive to use the width of the label string.

                                                                                                                                                                                                                                                              func (d *DropDown) SetOptions(texts []string, selected func(text string, index int)) *DropDown

                                                                                                                                                                                                                                                                SetOptions replaces all current options with the ones provided and installs one callback function which is called when one of the options is selected. It will be called with the option's text and its index into the options slice. The "selected" parameter may be nil.

                                                                                                                                                                                                                                                                func (d *DropDown) SetPrefixTextColor(color tcell.Color) *DropDown

                                                                                                                                                                                                                                                                  SetPrefixTextColor sets the color of the prefix string. The prefix string is shown when the user starts typing text, which directly selects the first option that starts with the typed string.

                                                                                                                                                                                                                                                                  func (d *DropDown) SetSelectedFunc(handler func(text string, index int)) *DropDown

                                                                                                                                                                                                                                                                    SetSelectedFunc sets a handler which is called when the user changes the drop-down's option. This handler will be called in addition and prior to an option's optional individual handler. The handler is provided with the selected option's text and index. If "no option" was selected, these values are an empty string and -1.

                                                                                                                                                                                                                                                                    func (d *DropDown) SetTextOptions(prefix, suffix, currentPrefix, currentSuffix, noSelection string) *DropDown

                                                                                                                                                                                                                                                                      SetTextOptions sets the text to be placed before and after each drop-down option (prefix/suffix), the text placed before and after the currently selected option (currentPrefix/currentSuffix) as well as the text to be displayed when no option is currently selected. Per default, all of these strings are empty.

                                                                                                                                                                                                                                                                      type Flex

                                                                                                                                                                                                                                                                      type Flex struct {
                                                                                                                                                                                                                                                                      	*Box
                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        Flex is a basic implementation of the Flexbox layout. The contained primitives are arranged horizontally or vertically. The way they are distributed along that dimension depends on their layout settings, which is either a fixed length or a proportional length. See AddItem() for details.

                                                                                                                                                                                                                                                                        See https://github.com/rivo/tview/wiki/Flex for an example.

                                                                                                                                                                                                                                                                        func NewFlex

                                                                                                                                                                                                                                                                        func NewFlex() *Flex

                                                                                                                                                                                                                                                                          NewFlex returns a new flexbox layout container with no primitives and its direction set to FlexColumn. To add primitives to this layout, see AddItem(). To change the direction, see SetDirection().

                                                                                                                                                                                                                                                                          Note that Box, the superclass of Flex, will not clear its contents so that any nil flex items will leave their background unchanged. To clear a Flex's background before any items are drawn, set it to a box with the desired color:

                                                                                                                                                                                                                                                                          flex.Box = NewBox()
                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                          func (*Flex) AddItem

                                                                                                                                                                                                                                                                          func (f *Flex) AddItem(item Primitive, fixedSize, proportion int, focus bool) *Flex

                                                                                                                                                                                                                                                                            AddItem adds a new item to the container. The "fixedSize" argument is a width or height that may not be changed by the layout algorithm. A value of 0 means that its size is flexible and may be changed. The "proportion" argument defines the relative size of the item compared to other flexible-size items. For example, items with a proportion of 2 will be twice as large as items with a proportion of 1. The proportion must be at least 1 if fixedSize == 0 (ignored otherwise).

                                                                                                                                                                                                                                                                            If "focus" is set to true, the item will receive focus when the Flex primitive receives focus. If multiple items have the "focus" flag set to true, the first one will receive focus.

                                                                                                                                                                                                                                                                            You can provide a nil value for the primitive. This will still consume screen space but nothing will be drawn.

                                                                                                                                                                                                                                                                            func (*Flex) Clear

                                                                                                                                                                                                                                                                            func (f *Flex) Clear() *Flex

                                                                                                                                                                                                                                                                              Clear removes all items from the container.

                                                                                                                                                                                                                                                                              func (*Flex) Draw

                                                                                                                                                                                                                                                                              func (f *Flex) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                func (*Flex) Focus

                                                                                                                                                                                                                                                                                func (f *Flex) Focus(delegate func(p Primitive))

                                                                                                                                                                                                                                                                                  Focus is called when this primitive receives focus.

                                                                                                                                                                                                                                                                                  func (*Flex) HasFocus

                                                                                                                                                                                                                                                                                  func (f *Flex) HasFocus() bool

                                                                                                                                                                                                                                                                                    HasFocus returns whether or not this primitive has focus.

                                                                                                                                                                                                                                                                                    func (*Flex) InputHandler

                                                                                                                                                                                                                                                                                    func (f *Flex) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                      InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                      func (*Flex) MouseHandler

                                                                                                                                                                                                                                                                                      func (f *Flex) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                        MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                        func (*Flex) RemoveItem

                                                                                                                                                                                                                                                                                        func (f *Flex) RemoveItem(p Primitive) *Flex

                                                                                                                                                                                                                                                                                          RemoveItem removes all items for the given primitive from the container, keeping the order of the remaining items intact.

                                                                                                                                                                                                                                                                                          func (*Flex) ResizeItem

                                                                                                                                                                                                                                                                                          func (f *Flex) ResizeItem(p Primitive, fixedSize, proportion int) *Flex

                                                                                                                                                                                                                                                                                            ResizeItem sets a new size for the item(s) with the given primitive. If there are multiple Flex items with the same primitive, they will all receive the same size. For details regarding the size parameters, see AddItem().

                                                                                                                                                                                                                                                                                            func (*Flex) SetDirection

                                                                                                                                                                                                                                                                                            func (f *Flex) SetDirection(direction int) *Flex

                                                                                                                                                                                                                                                                                              SetDirection sets the direction in which the contained primitives are distributed. This can be either FlexColumn (default) or FlexRow.

                                                                                                                                                                                                                                                                                              func (*Flex) SetFullScreen

                                                                                                                                                                                                                                                                                              func (f *Flex) SetFullScreen(fullScreen bool) *Flex

                                                                                                                                                                                                                                                                                                SetFullScreen sets the flag which, when true, causes the flex layout to use the entire screen space instead of whatever size it is currently assigned to.

                                                                                                                                                                                                                                                                                                type Form

                                                                                                                                                                                                                                                                                                type Form struct {
                                                                                                                                                                                                                                                                                                	*Box
                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  Form allows you to combine multiple one-line form elements into a vertical or horizontal layout. Form elements include types such as InputField or Checkbox. These elements can be optionally followed by one or more buttons for which you can define form-wide actions (e.g. Save, Clear, Cancel).

                                                                                                                                                                                                                                                                                                  See https://github.com/rivo/tview/wiki/Form for an example.

                                                                                                                                                                                                                                                                                                  func NewForm

                                                                                                                                                                                                                                                                                                  func NewForm() *Form

                                                                                                                                                                                                                                                                                                    NewForm returns a new form.

                                                                                                                                                                                                                                                                                                    func (*Form) AddButton

                                                                                                                                                                                                                                                                                                    func (f *Form) AddButton(label string, selected func()) *Form

                                                                                                                                                                                                                                                                                                      AddButton adds a new button to the form. The "selected" function is called when the user selects this button. It may be nil.

                                                                                                                                                                                                                                                                                                      func (*Form) AddCheckbox

                                                                                                                                                                                                                                                                                                      func (f *Form) AddCheckbox(label string, checked bool, changed func(checked bool)) *Form

                                                                                                                                                                                                                                                                                                        AddCheckbox adds a checkbox to the form. It has a label, an initial state, and an (optional) callback function which is invoked when the state of the checkbox was changed by the user.

                                                                                                                                                                                                                                                                                                        func (*Form) AddDropDown

                                                                                                                                                                                                                                                                                                        func (f *Form) AddDropDown(label string, options []string, initialOption int, selected func(option string, optionIndex int)) *Form

                                                                                                                                                                                                                                                                                                          AddDropDown adds a drop-down element to the form. It has a label, options, and an (optional) callback function which is invoked when an option was selected. The initial option may be a negative value to indicate that no option is currently selected.

                                                                                                                                                                                                                                                                                                          func (*Form) AddFormItem

                                                                                                                                                                                                                                                                                                          func (f *Form) AddFormItem(item FormItem) *Form

                                                                                                                                                                                                                                                                                                            AddFormItem adds a new item to the form. This can be used to add your own objects to the form. Note, however, that the Form class will override some of its attributes to make it work in the form context. Specifically, these are:

                                                                                                                                                                                                                                                                                                            - The label width
                                                                                                                                                                                                                                                                                                            - The label color
                                                                                                                                                                                                                                                                                                            - The background color
                                                                                                                                                                                                                                                                                                            - The field text color
                                                                                                                                                                                                                                                                                                            - The field background color
                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                            func (*Form) AddInputField

                                                                                                                                                                                                                                                                                                            func (f *Form) AddInputField(label, value string, fieldWidth int, accept func(textToCheck string, lastChar rune) bool, changed func(text string)) *Form

                                                                                                                                                                                                                                                                                                              AddInputField adds an input field to the form. It has a label, an optional initial value, a field width (a value of 0 extends it as far as possible), an optional accept function to validate the item's value (set to nil to accept any text), and an (optional) callback function which is invoked when the input field's text has changed.

                                                                                                                                                                                                                                                                                                              func (*Form) AddPasswordField

                                                                                                                                                                                                                                                                                                              func (f *Form) AddPasswordField(label, value string, fieldWidth int, mask rune, changed func(text string)) *Form

                                                                                                                                                                                                                                                                                                                AddPasswordField adds a password field to the form. This is similar to an input field except that the user's input not shown. Instead, a "mask" character is displayed. The password field has a label, an optional initial value, a field width (a value of 0 extends it as far as possible), and an (optional) callback function which is invoked when the input field's text has changed.

                                                                                                                                                                                                                                                                                                                func (*Form) Clear

                                                                                                                                                                                                                                                                                                                func (f *Form) Clear(includeButtons bool) *Form

                                                                                                                                                                                                                                                                                                                  Clear removes all input elements from the form, including the buttons if specified.

                                                                                                                                                                                                                                                                                                                  func (*Form) ClearButtons

                                                                                                                                                                                                                                                                                                                  func (f *Form) ClearButtons() *Form

                                                                                                                                                                                                                                                                                                                    ClearButtons removes all buttons from the form.

                                                                                                                                                                                                                                                                                                                    func (*Form) Draw

                                                                                                                                                                                                                                                                                                                    func (f *Form) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                      Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                      func (*Form) Focus

                                                                                                                                                                                                                                                                                                                      func (f *Form) Focus(delegate func(p Primitive))

                                                                                                                                                                                                                                                                                                                        Focus is called by the application when the primitive receives focus.

                                                                                                                                                                                                                                                                                                                        func (*Form) GetButton

                                                                                                                                                                                                                                                                                                                        func (f *Form) GetButton(index int) *Button

                                                                                                                                                                                                                                                                                                                          GetButton returns the button at the specified 0-based index. Note that buttons have been specially prepared for this form and modifying some of their attributes may have unintended side effects.

                                                                                                                                                                                                                                                                                                                          func (*Form) GetButtonCount

                                                                                                                                                                                                                                                                                                                          func (f *Form) GetButtonCount() int

                                                                                                                                                                                                                                                                                                                            GetButtonCount returns the number of buttons in this form.

                                                                                                                                                                                                                                                                                                                            func (*Form) GetButtonIndex

                                                                                                                                                                                                                                                                                                                            func (f *Form) GetButtonIndex(label string) int

                                                                                                                                                                                                                                                                                                                              GetButtonIndex returns the index of the button with the given label, starting with 0 for the button that was added first. If no such label was found, -1 is returned.

                                                                                                                                                                                                                                                                                                                              func (*Form) GetFocusedItemIndex

                                                                                                                                                                                                                                                                                                                              func (f *Form) GetFocusedItemIndex() (formItem, button int)

                                                                                                                                                                                                                                                                                                                                GetFocusedItemIndex returns the indices of the form element or button which currently has focus. If they don't, -1 is returned resepectively.

                                                                                                                                                                                                                                                                                                                                func (*Form) GetFormItem

                                                                                                                                                                                                                                                                                                                                func (f *Form) GetFormItem(index int) FormItem

                                                                                                                                                                                                                                                                                                                                  GetFormItem returns the form item at the given position, starting with index 0. Elements are referenced in the order they were added. Buttons are not included.

                                                                                                                                                                                                                                                                                                                                  func (*Form) GetFormItemByLabel

                                                                                                                                                                                                                                                                                                                                  func (f *Form) GetFormItemByLabel(label string) FormItem

                                                                                                                                                                                                                                                                                                                                    GetFormItemByLabel returns the first form element with the given label. If no such element is found, nil is returned. Buttons are not searched and will therefore not be returned.

                                                                                                                                                                                                                                                                                                                                    func (*Form) GetFormItemCount

                                                                                                                                                                                                                                                                                                                                    func (f *Form) GetFormItemCount() int

                                                                                                                                                                                                                                                                                                                                      GetFormItemCount returns the number of items in the form (not including the buttons).

                                                                                                                                                                                                                                                                                                                                      func (*Form) GetFormItemIndex

                                                                                                                                                                                                                                                                                                                                      func (f *Form) GetFormItemIndex(label string) int

                                                                                                                                                                                                                                                                                                                                        GetFormItemIndex returns the index of the first form element with the given label. If no such element is found, -1 is returned. Buttons are not searched and will therefore not be returned.

                                                                                                                                                                                                                                                                                                                                        func (*Form) HasFocus

                                                                                                                                                                                                                                                                                                                                        func (f *Form) HasFocus() bool

                                                                                                                                                                                                                                                                                                                                          HasFocus returns whether or not this primitive has focus.

                                                                                                                                                                                                                                                                                                                                          func (*Form) InputHandler

                                                                                                                                                                                                                                                                                                                                          func (f *Form) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                            InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                            func (*Form) MouseHandler

                                                                                                                                                                                                                                                                                                                                            func (f *Form) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                              MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                              func (*Form) RemoveButton

                                                                                                                                                                                                                                                                                                                                              func (f *Form) RemoveButton(index int) *Form

                                                                                                                                                                                                                                                                                                                                                RemoveButton removes the button at the specified position, starting with 0 for the button that was added first.

                                                                                                                                                                                                                                                                                                                                                func (*Form) RemoveFormItem

                                                                                                                                                                                                                                                                                                                                                func (f *Form) RemoveFormItem(index int) *Form

                                                                                                                                                                                                                                                                                                                                                  RemoveFormItem removes the form element at the given position, starting with index 0. Elements are referenced in the order they were added. Buttons are not included.

                                                                                                                                                                                                                                                                                                                                                  func (*Form) SetButtonBackgroundColor

                                                                                                                                                                                                                                                                                                                                                  func (f *Form) SetButtonBackgroundColor(color tcell.Color) *Form

                                                                                                                                                                                                                                                                                                                                                    SetButtonBackgroundColor sets the background color of the buttons.

                                                                                                                                                                                                                                                                                                                                                    func (*Form) SetButtonTextColor

                                                                                                                                                                                                                                                                                                                                                    func (f *Form) SetButtonTextColor(color tcell.Color) *Form

                                                                                                                                                                                                                                                                                                                                                      SetButtonTextColor sets the color of the button texts.

                                                                                                                                                                                                                                                                                                                                                      func (*Form) SetButtonsAlign

                                                                                                                                                                                                                                                                                                                                                      func (f *Form) SetButtonsAlign(align int) *Form

                                                                                                                                                                                                                                                                                                                                                        SetButtonsAlign sets how the buttons align horizontally, one of AlignLeft (the default), AlignCenter, and AlignRight. This is only

                                                                                                                                                                                                                                                                                                                                                        func (*Form) SetCancelFunc

                                                                                                                                                                                                                                                                                                                                                        func (f *Form) SetCancelFunc(callback func()) *Form

                                                                                                                                                                                                                                                                                                                                                          SetCancelFunc sets a handler which is called when the user hits the Escape key.

                                                                                                                                                                                                                                                                                                                                                          func (*Form) SetFieldBackgroundColor

                                                                                                                                                                                                                                                                                                                                                          func (f *Form) SetFieldBackgroundColor(color tcell.Color) *Form

                                                                                                                                                                                                                                                                                                                                                            SetFieldBackgroundColor sets the background color of the input areas.

                                                                                                                                                                                                                                                                                                                                                            func (*Form) SetFieldTextColor

                                                                                                                                                                                                                                                                                                                                                            func (f *Form) SetFieldTextColor(color tcell.Color) *Form

                                                                                                                                                                                                                                                                                                                                                              SetFieldTextColor sets the text color of the input areas.

                                                                                                                                                                                                                                                                                                                                                              func (*Form) SetFocus

                                                                                                                                                                                                                                                                                                                                                              func (f *Form) SetFocus(index int) *Form

                                                                                                                                                                                                                                                                                                                                                                SetFocus shifts the focus to the form element with the given index, counting non-button items first and buttons last. Note that this index is only used when the form itself receives focus.

                                                                                                                                                                                                                                                                                                                                                                func (*Form) SetHorizontal

                                                                                                                                                                                                                                                                                                                                                                func (f *Form) SetHorizontal(horizontal bool) *Form

                                                                                                                                                                                                                                                                                                                                                                  SetHorizontal sets the direction the form elements are laid out. If set to true, instead of positioning them from top to bottom (the default), they are positioned from left to right, moving into the next row if there is not enough space.

                                                                                                                                                                                                                                                                                                                                                                  func (*Form) SetItemPadding

                                                                                                                                                                                                                                                                                                                                                                  func (f *Form) SetItemPadding(padding int) *Form

                                                                                                                                                                                                                                                                                                                                                                    SetItemPadding sets the number of empty rows between form items for vertical layouts and the number of empty cells between form items for horizontal layouts.

                                                                                                                                                                                                                                                                                                                                                                    func (*Form) SetLabelColor

                                                                                                                                                                                                                                                                                                                                                                    func (f *Form) SetLabelColor(color tcell.Color) *Form

                                                                                                                                                                                                                                                                                                                                                                      SetLabelColor sets the color of the labels.

                                                                                                                                                                                                                                                                                                                                                                      type FormItem

                                                                                                                                                                                                                                                                                                                                                                      type FormItem interface {
                                                                                                                                                                                                                                                                                                                                                                      	Primitive
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// GetLabel returns the item's label text.
                                                                                                                                                                                                                                                                                                                                                                      	GetLabel() string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// SetFormAttributes sets a number of item attributes at once.
                                                                                                                                                                                                                                                                                                                                                                      	SetFormAttributes(labelWidth int, labelColor, bgColor, fieldTextColor, fieldBgColor tcell.Color) FormItem
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// GetFieldWidth returns the width of the form item's field (the area which
                                                                                                                                                                                                                                                                                                                                                                      	// is manipulated by the user) in number of screen cells. A value of 0
                                                                                                                                                                                                                                                                                                                                                                      	// indicates the the field width is flexible and may use as much space as
                                                                                                                                                                                                                                                                                                                                                                      	// required.
                                                                                                                                                                                                                                                                                                                                                                      	GetFieldWidth() int
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// SetFinishedFunc sets the handler function for when the user finished
                                                                                                                                                                                                                                                                                                                                                                      	// entering data into the item. The handler may receive events for the
                                                                                                                                                                                                                                                                                                                                                                      	// Enter key (we're done), the Escape key (cancel input), the Tab key (move to
                                                                                                                                                                                                                                                                                                                                                                      	// next field), and the Backtab key (move to previous field).
                                                                                                                                                                                                                                                                                                                                                                      	SetFinishedFunc(handler func(key tcell.Key)) FormItem
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                        FormItem is the interface all form items must implement to be able to be included in a form.

                                                                                                                                                                                                                                                                                                                                                                        type Frame

                                                                                                                                                                                                                                                                                                                                                                        type Frame struct {
                                                                                                                                                                                                                                                                                                                                                                        	*Box
                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                          Frame is a wrapper which adds space around another primitive. In addition, the top area (header) and the bottom area (footer) may also contain text.

                                                                                                                                                                                                                                                                                                                                                                          See https://github.com/rivo/tview/wiki/Frame for an example.

                                                                                                                                                                                                                                                                                                                                                                          func NewFrame

                                                                                                                                                                                                                                                                                                                                                                          func NewFrame(primitive Primitive) *Frame

                                                                                                                                                                                                                                                                                                                                                                            NewFrame returns a new frame around the given primitive. The primitive's size will be changed to fit within this frame. The primitive may be nil, in which case no other primitive is embedded in the frame.

                                                                                                                                                                                                                                                                                                                                                                            func (*Frame) AddText

                                                                                                                                                                                                                                                                                                                                                                            func (f *Frame) AddText(text string, header bool, align int, color tcell.Color) *Frame

                                                                                                                                                                                                                                                                                                                                                                              AddText adds text to the frame. Set "header" to true if the text is to appear in the header, above the contained primitive. Set it to false for it to appear in the footer, below the contained primitive. "align" must be one of the Align constants. Rows in the header are printed top to bottom, rows in the footer are printed bottom to top. Note that long text can overlap as different alignments will be placed on the same row.

                                                                                                                                                                                                                                                                                                                                                                              func (*Frame) Clear

                                                                                                                                                                                                                                                                                                                                                                              func (f *Frame) Clear() *Frame

                                                                                                                                                                                                                                                                                                                                                                                Clear removes all text from the frame.

                                                                                                                                                                                                                                                                                                                                                                                func (*Frame) Draw

                                                                                                                                                                                                                                                                                                                                                                                func (f *Frame) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                  Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                  func (*Frame) Focus

                                                                                                                                                                                                                                                                                                                                                                                  func (f *Frame) Focus(delegate func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                    Focus is called when this primitive receives focus.

                                                                                                                                                                                                                                                                                                                                                                                    func (*Frame) HasFocus

                                                                                                                                                                                                                                                                                                                                                                                    func (f *Frame) HasFocus() bool

                                                                                                                                                                                                                                                                                                                                                                                      HasFocus returns whether or not this primitive has focus.

                                                                                                                                                                                                                                                                                                                                                                                      func (*Frame) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                      func (f *Frame) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                        InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                        func (*Frame) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                        func (f *Frame) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                          MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                          func (*Frame) SetBorders

                                                                                                                                                                                                                                                                                                                                                                                          func (f *Frame) SetBorders(top, bottom, header, footer, left, right int) *Frame

                                                                                                                                                                                                                                                                                                                                                                                            SetBorders sets the width of the frame borders as well as "header" and "footer", the vertical space between the header and footer text and the contained primitive (does not apply if there is no text).

                                                                                                                                                                                                                                                                                                                                                                                            type Grid

                                                                                                                                                                                                                                                                                                                                                                                            type Grid struct {
                                                                                                                                                                                                                                                                                                                                                                                            	*Box
                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              Grid is an implementation of a grid-based layout. It works by defining the size of the rows and columns, then placing primitives into the grid.

                                                                                                                                                                                                                                                                                                                                                                                              Some settings can lead to the grid exceeding its available space. SetOffset() can then be used to scroll in steps of rows and columns. These offset values can also be controlled with the arrow keys (or the "g","G", "j", "k", "h", and "l" keys) while the grid has focus and none of its contained primitives do.

                                                                                                                                                                                                                                                                                                                                                                                              See https://github.com/rivo/tview/wiki/Grid for an example.

                                                                                                                                                                                                                                                                                                                                                                                              func NewGrid

                                                                                                                                                                                                                                                                                                                                                                                              func NewGrid() *Grid

                                                                                                                                                                                                                                                                                                                                                                                                NewGrid returns a new grid-based layout container with no initial primitives.

                                                                                                                                                                                                                                                                                                                                                                                                Note that Box, the superclass of Grid, will be transparent so that any grid areas not covered by any primitives will leave their background unchanged. To clear a Grid's background before any items are drawn, reset its Box to one with the desired color:

                                                                                                                                                                                                                                                                                                                                                                                                grid.Box = NewBox()
                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                func (*Grid) AddItem

                                                                                                                                                                                                                                                                                                                                                                                                func (g *Grid) AddItem(p Primitive, row, column, rowSpan, colSpan, minGridHeight, minGridWidth int, focus bool) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                  AddItem adds a primitive and its position to the grid. The top-left corner of the primitive will be located in the top-left corner of the grid cell at the given row and column and will span "rowSpan" rows and "colSpan" columns. For example, for a primitive to occupy rows 2, 3, and 4 and columns 5 and 6:

                                                                                                                                                                                                                                                                                                                                                                                                  grid.AddItem(p, 2, 5, 3, 2, 0, 0, true)
                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                  If rowSpan or colSpan is 0, the primitive will not be drawn.

                                                                                                                                                                                                                                                                                                                                                                                                  You can add the same primitive multiple times with different grid positions. The minGridWidth and minGridHeight values will then determine which of those positions will be used. This is similar to CSS media queries. These minimum values refer to the overall size of the grid. If multiple items for the same primitive apply, the one that has at least one highest minimum value will be used, or the primitive added last if those values are the same. Example:

                                                                                                                                                                                                                                                                                                                                                                                                  grid.AddItem(p, 0, 0, 0, 0, 0, 0, true). // Hide in small grids.
                                                                                                                                                                                                                                                                                                                                                                                                    AddItem(p, 0, 0, 1, 2, 100, 0, true).  // One-column layout for medium grids.
                                                                                                                                                                                                                                                                                                                                                                                                    AddItem(p, 1, 1, 3, 2, 300, 0, true)   // Multi-column layout for large grids.
                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                  To use the same grid layout for all sizes, simply set minGridWidth and minGridHeight to 0.

                                                                                                                                                                                                                                                                                                                                                                                                  If the item's focus is set to true, it will receive focus when the grid receives focus. If there are multiple items with a true focus flag, the last visible one that was added will receive focus.

                                                                                                                                                                                                                                                                                                                                                                                                  func (*Grid) Blur

                                                                                                                                                                                                                                                                                                                                                                                                  func (g *Grid) Blur()

                                                                                                                                                                                                                                                                                                                                                                                                    Blur is called when this primitive loses focus.

                                                                                                                                                                                                                                                                                                                                                                                                    func (*Grid) Clear

                                                                                                                                                                                                                                                                                                                                                                                                    func (g *Grid) Clear() *Grid

                                                                                                                                                                                                                                                                                                                                                                                                      Clear removes all items from the grid.

                                                                                                                                                                                                                                                                                                                                                                                                      func (*Grid) Draw

                                                                                                                                                                                                                                                                                                                                                                                                      func (g *Grid) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                                        Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*Grid) Focus

                                                                                                                                                                                                                                                                                                                                                                                                        func (g *Grid) Focus(delegate func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                          Focus is called when this primitive receives focus.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*Grid) GetOffset

                                                                                                                                                                                                                                                                                                                                                                                                          func (g *Grid) GetOffset() (rows, columns int)

                                                                                                                                                                                                                                                                                                                                                                                                            GetOffset returns the current row and column offset (see SetOffset() for details).

                                                                                                                                                                                                                                                                                                                                                                                                            func (*Grid) HasFocus

                                                                                                                                                                                                                                                                                                                                                                                                            func (g *Grid) HasFocus() bool

                                                                                                                                                                                                                                                                                                                                                                                                              HasFocus returns whether or not this primitive has focus.

                                                                                                                                                                                                                                                                                                                                                                                                              func (*Grid) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                                              func (g *Grid) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                func (*Grid) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                                                func (g *Grid) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                  MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Grid) RemoveItem

                                                                                                                                                                                                                                                                                                                                                                                                                  func (g *Grid) RemoveItem(p Primitive) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                    RemoveItem removes all items for the given primitive from the grid, keeping the order of the remaining items intact.

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Grid) SetBorders

                                                                                                                                                                                                                                                                                                                                                                                                                    func (g *Grid) SetBorders(borders bool) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                      SetBorders sets whether or not borders are drawn around grid items. Setting this value to true will cause the gap values (see SetGap()) to be ignored and automatically assumed to be 1 where the border graphics are drawn.

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Grid) SetBordersColor

                                                                                                                                                                                                                                                                                                                                                                                                                      func (g *Grid) SetBordersColor(color tcell.Color) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                        SetBordersColor sets the color of the item borders.

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Grid) SetColumns

                                                                                                                                                                                                                                                                                                                                                                                                                        func (g *Grid) SetColumns(columns ...int) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                          SetColumns defines how the columns of the grid are distributed. Each value defines the size of one column, starting with the leftmost column. Values greater 0 represent absolute column widths (gaps not included). Values less or equal 0 represent proportional column widths or fractions of the remaining free space, where 0 is treated the same as -1. That is, a column with a value of -3 will have three times the width of a column with a value of -1 (or 0). The minimum width set with SetMinSize() is always observed.

                                                                                                                                                                                                                                                                                                                                                                                                                          Primitives may extend beyond the columns defined explicitly with this function. A value of 0 is assumed for any undefined column. In fact, if you never call this function, all columns occupied by primitives will have the same width. On the other hand, unoccupied columns defined with this function will always take their place.

                                                                                                                                                                                                                                                                                                                                                                                                                          Assuming a total width of the grid of 100 cells and a minimum width of 0, the following call will result in columns with widths of 30, 10, 15, 15, and 30 cells:

                                                                                                                                                                                                                                                                                                                                                                                                                          grid.SetColumns(30, 10, -1, -1, -2)
                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                          If a primitive were then placed in the 6th and 7th column, the resulting widths would be: 30, 10, 10, 10, 20, 10, and 10 cells.

                                                                                                                                                                                                                                                                                                                                                                                                                          If you then called SetMinSize() as follows:

                                                                                                                                                                                                                                                                                                                                                                                                                          grid.SetMinSize(15, 20)
                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                          The resulting widths would be: 30, 15, 15, 15, 20, 15, and 15 cells, a total of 125 cells, 25 cells wider than the available grid width.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Grid) SetGap

                                                                                                                                                                                                                                                                                                                                                                                                                          func (g *Grid) SetGap(row, column int) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                            SetGap sets the size of the gaps between neighboring primitives on the grid. If borders are drawn (see SetBorders()), these values are ignored and a gap of 1 is assumed. Panics if negative values are provided.

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Grid) SetMinSize

                                                                                                                                                                                                                                                                                                                                                                                                                            func (g *Grid) SetMinSize(row, column int) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                              SetMinSize sets an absolute minimum width for rows and an absolute minimum height for columns. Panics if negative values are provided.

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Grid) SetOffset

                                                                                                                                                                                                                                                                                                                                                                                                                              func (g *Grid) SetOffset(rows, columns int) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                                SetOffset sets the number of rows and columns which are skipped before drawing the first grid cell in the top-left corner. As the grid will never completely move off the screen, these values may be adjusted the next time the grid is drawn. The actual position of the grid may also be adjusted such that contained primitives that have focus remain visible.

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Grid) SetRows

                                                                                                                                                                                                                                                                                                                                                                                                                                func (g *Grid) SetRows(rows ...int) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                                  SetRows defines how the rows of the grid are distributed. These values behave the same as the column values provided with SetColumns(), see there for a definition and examples.

                                                                                                                                                                                                                                                                                                                                                                                                                                  The provided values correspond to row heights, the first value defining the height of the topmost row.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Grid) SetSize

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (g *Grid) SetSize(numRows, numColumns, rowSize, columnSize int) *Grid

                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSize is a shortcut for SetRows() and SetColumns() where all row and column values are set to the given size values. See SetColumns() for details on sizes.

                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputField struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                    	*Box
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                      InputField is a one-line box (three lines if there is a title) where the user can enter text. Use SetAcceptanceFunc() to accept or reject input, SetChangedFunc() to listen for changes, and SetMaskCharacter() to hide input from onlookers (e.g. for password input).

                                                                                                                                                                                                                                                                                                                                                                                                                                      The following keys can be used for navigation and editing:

                                                                                                                                                                                                                                                                                                                                                                                                                                      - Left arrow: Move left by one character.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Right arrow: Move right by one character.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Home, Ctrl-A, Alt-a: Move to the beginning of the line.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - End, Ctrl-E, Alt-e: Move to the end of the line.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Alt-left, Alt-b: Move left by one word.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Alt-right, Alt-f: Move right by one word.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Backspace: Delete the character before the cursor.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Delete: Delete the character after the cursor.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Ctrl-K: Delete from the cursor to the end of the line.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Ctrl-W: Delete the last word before the cursor.
                                                                                                                                                                                                                                                                                                                                                                                                                                      - Ctrl-U: Delete the entire line.
                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                      See https://github.com/rivo/tview/wiki/InputField for an example.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewInputField

                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewInputField() *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                        NewInputField returns a new input field.

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*InputField) Autocomplete

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (i *InputField) Autocomplete() *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                          Autocomplete invokes the autocomplete callback (if there is one). If the length of the returned autocomplete entries slice is greater than 0, the input field will present the user with a corresponding drop-down list the next time the input field is drawn.

                                                                                                                                                                                                                                                                                                                                                                                                                                          It is safe to call this function from any goroutine. Note that the input field is not redrawn automatically unless called from the main goroutine (e.g. in response to events).

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*InputField) Draw

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (i *InputField) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                                                                            Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*InputField) GetFieldWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (i *InputField) GetFieldWidth() int

                                                                                                                                                                                                                                                                                                                                                                                                                                              GetFieldWidth returns this primitive's field width.

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*InputField) GetLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (i *InputField) GetLabel() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                GetLabel returns the text to be displayed before the input area.

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*InputField) GetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (i *InputField) GetText() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetText returns the current text of the input field.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*InputField) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (i *InputField) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                    InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*InputField) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (i *InputField) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                                                      MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*InputField) SetAcceptanceFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (i *InputField) SetAcceptanceFunc(handler func(textToCheck string, lastChar rune) bool) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetAcceptanceFunc sets a handler which may reject the last character that was entered (by returning false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                        This package defines a number of variables prefixed with InputField which may be used for common input (e.g. numbers, maximum text length).

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*InputField) SetAutocompleteFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (i *InputField) SetAutocompleteFunc(callback func(currentText string) (entries []string)) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetAutocompleteFunc sets an autocomplete callback function which may return strings to be selected from a drop-down based on the current text of the input field. The drop-down appears only if len(entries) > 0. The callback is invoked in this function and whenever the current text changes or when Autocomplete() is called. Entries are cleared when the user selects an entry or presses Escape.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*InputField) SetChangedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (i *InputField) SetChangedFunc(handler func(text string)) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetChangedFunc sets a handler which is called whenever the text of the input field has changed. It receives the current text (after the change).

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*InputField) SetDoneFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (i *InputField) SetDoneFunc(handler func(key tcell.Key)) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetDoneFunc sets a handler which is called when the user is done entering text. The callback function is provided with the key that was pressed, which is one of the following:

                                                                                                                                                                                                                                                                                                                                                                                                                                                              - KeyEnter: Done entering text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              - KeyEscape: Abort text input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              - KeyTab: Move to the next field.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              - KeyBacktab: Move to the previous field.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*InputField) SetFieldBackgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (i *InputField) SetFieldBackgroundColor(color tcell.Color) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetFieldBackgroundColor sets the background color of the input area.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*InputField) SetFieldTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (i *InputField) SetFieldTextColor(color tcell.Color) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetFieldTextColor sets the text color of the input area.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*InputField) SetFieldWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (i *InputField) SetFieldWidth(width int) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetFieldWidth sets the screen width of the input area. A value of 0 means extend as much as possible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*InputField) SetFinishedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (i *InputField) SetFinishedFunc(handler func(key tcell.Key)) FormItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetFinishedFunc sets a callback invoked when the user leaves this form item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*InputField) SetFormAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (i *InputField) SetFormAttributes(labelWidth int, labelColor, bgColor, fieldTextColor, fieldBgColor tcell.Color) FormItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetFormAttributes sets attributes shared by all form items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*InputField) SetLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (i *InputField) SetLabel(label string) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetLabel sets the text to be displayed before the input area.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*InputField) SetLabelColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (i *InputField) SetLabelColor(color tcell.Color) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetLabelColor sets the color of the label.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*InputField) SetLabelWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (i *InputField) SetLabelWidth(width int) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetLabelWidth sets the screen width of the label. A value of 0 will cause the primitive to use the width of the label string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*InputField) SetMaskCharacter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (i *InputField) SetMaskCharacter(mask rune) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetMaskCharacter sets a character that masks user input on a screen. A value of 0 disables masking.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*InputField) SetPlaceholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (i *InputField) SetPlaceholder(text string) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetPlaceholder sets the text to be displayed when the input text is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*InputField) SetPlaceholderTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (i *InputField) SetPlaceholderTextColor(color tcell.Color) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetPlaceholderTextColor sets the text color of placeholder text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*InputField) SetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (i *InputField) SetText(text string) *InputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetText sets the current text of the input field.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type List struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	*Box
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        List displays rows of items, each of which can be selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See https://github.com/rivo/tview/wiki/List for an example.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewList() *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewList returns a new form.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*List) AddItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (l *List) AddItem(mainText, secondaryText string, shortcut rune, selected func()) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            AddItem calls InsertItem() with an index of -1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*List) Clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (l *List) Clear() *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Clear removes all items from the list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*List) Draw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (l *List) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*List) FindItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (l *List) FindItems(mainSearch, secondarySearch string, mustContainBoth, ignoreCase bool) (indices []int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  FindItems searches the main and secondary texts for the given strings and returns a list of item indices in which those strings are found. One of the two search strings may be empty, it will then be ignored. Indices are always returned in ascending order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If mustContainBoth is set to true, mainSearch must be contained in the main text AND secondarySearch must be contained in the secondary text. If it is false, only one of the two search strings must be contained.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Set ignoreCase to true for case-insensitive search.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*List) GetCurrentItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (l *List) GetCurrentItem() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetCurrentItem returns the index of the currently selected list item, starting at 0 for the first item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*List) GetItemCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (l *List) GetItemCount() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetItemCount returns the number of items in the list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*List) GetItemText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (l *List) GetItemText(index int) (main, secondary string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetItemText returns an item's texts (main and secondary). Panics if the index is out of range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*List) GetOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (l *List) GetOffset() (int, int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetOffset returns the number of items skipped while drawing, as well as the number of cells item text is moved to the left. See also SetOffset() for more information on these values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*List) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (l *List) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*List) InsertItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (l *List) InsertItem(index int, mainText, secondaryText string, shortcut rune, selected func()) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InsertItem adds a new item to the list at the specified index. An index of 0 will insert the item at the beginning, an index of 1 before the second item, and so on. An index of GetItemCount() or higher will insert the item at the end of the list. Negative indices are also allowed: An index of -1 will insert the item at the end of the list, an index of -2 before the last item, and so on. An index of -GetItemCount()-1 or lower will insert the item at the beginning.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An item has a main text which will be highlighted when selected. It also has a secondary text which is shown underneath the main text (if it is set to visible) but which may remain empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The shortcut is a key binding. If the specified rune is entered, the item is selected immediately. Set to 0 for no binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The "selected" callback will be invoked when the user selects the item. You may provide nil if no such callback is needed or if all events are handled through the selected callback set with SetSelectedFunc().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The currently selected item will shift its position accordingly. If the list was previously empty, a "changed" event is fired because the new item becomes selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*List) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (l *List) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*List) RemoveItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (l *List) RemoveItem(index int) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RemoveItem removes the item with the given index (starting at 0) from the list. If a negative index is provided, items are referred to from the back (-1 = last item, -2 = second-to-last item, and so on). Out of range indices are clamped to the beginning/end, i.e. unless the list is empty, an item is always removed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The currently selected item is shifted accordingly. If it is the one that is removed, a "changed" event is fired.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*List) SetChangedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (l *List) SetChangedFunc(handler func(index int, mainText string, secondaryText string, shortcut rune)) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetChangedFunc sets the function which is called when the user navigates to a list item. The function receives the item's index in the list of items (starting with 0), its main text, secondary text, and its shortcut rune.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This function is also called when the first item is added or when SetCurrentItem() is called.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*List) SetCurrentItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (l *List) SetCurrentItem(index int) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetCurrentItem sets the currently selected item by its index, starting at 0 for the first item. If a negative index is provided, items are referred to from the back (-1 = last item, -2 = second-to-last item, and so on). Out of range indices are clamped to the beginning/end.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Calling this function triggers a "changed" event if the selection changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*List) SetDoneFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (l *List) SetDoneFunc(handler func()) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetDoneFunc sets a function which is called when the user presses the Escape key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*List) SetHighlightFullLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (l *List) SetHighlightFullLine(highlight bool) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetHighlightFullLine sets a flag which determines whether the colored background of selected items spans the entire width of the view. If set to true, the highlight spans the entire view. If set to false, only the text of the selected item from beginning to end is highlighted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*List) SetItemText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (l *List) SetItemText(index int, main, secondary string) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetItemText sets an item's main and secondary text. Panics if the index is out of range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*List) SetMainTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (l *List) SetMainTextColor(color tcell.Color) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetMainTextColor sets the color of the items' main text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*List) SetOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (l *List) SetOffset(items, horizontal int) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetOffset sets the number of items to be skipped (vertically) as well as the number of cells skipped horizontally when the list is drawn. Note that one item corresponds to two rows when there are secondary texts. Shortcuts are always drawn.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                These values may change when the list is drawn to ensure the currently selected item is visible and item texts move out of view. Users can also modify these values by interacting with the list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*List) SetSecondaryTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (l *List) SetSecondaryTextColor(color tcell.Color) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetSecondaryTextColor sets the color of the items' secondary text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*List) SetSelectedBackgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (l *List) SetSelectedBackgroundColor(color tcell.Color) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSelectedBackgroundColor sets the background color of selected items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*List) SetSelectedFocusOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (l *List) SetSelectedFocusOnly(focusOnly bool) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetSelectedFocusOnly sets a flag which determines when the currently selected list item is highlighted. If set to true, selected items are only highlighted when the list has focus. If set to false, they are always highlighted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*List) SetSelectedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (l *List) SetSelectedFunc(handler func(int, string, string, rune)) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetSelectedFunc sets the function which is called when the user selects a list item by pressing Enter on the current selection. The function receives the item's index in the list of items (starting with 0), its main text, secondary text, and its shortcut rune.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*List) SetSelectedTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (l *List) SetSelectedTextColor(color tcell.Color) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetSelectedTextColor sets the text color of selected items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*List) SetShortcutColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (l *List) SetShortcutColor(color tcell.Color) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetShortcutColor sets the color of the items' shortcut.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*List) SetWrapAround

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (l *List) SetWrapAround(wrapAround bool) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetWrapAround sets the flag that determines whether navigating the list will wrap around. That is, navigating downwards on the last item will move the selection to the first item (similarly in the other direction). If set to false, the selection won't change when navigating downwards on the last item or navigating upwards on the first item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*List) ShowSecondaryText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (l *List) ShowSecondaryText(show bool) *List

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ShowSecondaryText determines whether or not to show secondary item texts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Modal struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	*Box
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Modal is a centered message window used to inform the user or prompt them for an immediate decision. It needs to have at least one button (added via AddButtons()) or it will never disappear.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See https://github.com/rivo/tview/wiki/Modal for an example.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewModal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewModal() *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewModal returns a new modal message window.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Modal) AddButtons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Modal) AddButtons(labels []string) *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AddButtons adds buttons to the window. There must be at least one button and a "done" handler so the window can be closed again.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Modal) ClearButtons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Modal) ClearButtons() *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ClearButtons removes all buttons from the window.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Modal) Draw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Modal) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Modal) Focus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *Modal) Focus(delegate func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Focus is called when this primitive receives focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Modal) HasFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *Modal) HasFocus() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HasFocus returns whether or not this primitive has focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Modal) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *Modal) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Modal) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *Modal) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Modal) SetBackgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Modal) SetBackgroundColor(color tcell.Color) *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetBackgroundColor sets the color of the modal frame background.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Modal) SetButtonBackgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Modal) SetButtonBackgroundColor(color tcell.Color) *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetButtonBackgroundColor sets the background color of the buttons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Modal) SetButtonTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Modal) SetButtonTextColor(color tcell.Color) *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetButtonTextColor sets the color of the button texts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Modal) SetDoneFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Modal) SetDoneFunc(handler func(buttonIndex int, buttonLabel string)) *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetDoneFunc sets a handler which is called when one of the buttons was pressed. It receives the index of the button as well as its label text. The handler is also called when the user presses the Escape key. The index will then be negative and the label text an emptry string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Modal) SetFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *Modal) SetFocus(index int) *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetFocus shifts the focus to the button with the given index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Modal) SetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *Modal) SetText(text string) *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetText sets the message text of the window. The text may contain line breaks. Note that words are wrapped, too, based on the final size of the window.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Modal) SetTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *Modal) SetTextColor(color tcell.Color) *Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetTextColor sets the color of the message text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MouseAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MouseAction int16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MouseAction indicates one of the actions the mouse is logically doing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseMove MouseAction = iota
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseLeftDown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseLeftUp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseLeftClick
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseLeftDoubleClick
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseMiddleDown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseMiddleUp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseMiddleClick
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseMiddleDoubleClick
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseRightDown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseRightUp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseRightClick
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseRightDoubleClick
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseScrollUp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseScrollDown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseScrollLeft
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MouseScrollRight
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Available mouse actions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Pages struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	*Box
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pages is a container for other primitives laid out on top of each other, overlapping or not. It is often used as the application's root primitive. It allows to easily switch the visibility of the contained primitives.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      See https://github.com/rivo/tview/wiki/Pages for an example.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewPages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewPages() *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewPages returns a new Pages object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Pages) AddAndSwitchToPage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *Pages) AddAndSwitchToPage(name string, item Primitive, resize bool) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AddAndSwitchToPage calls AddPage(), then SwitchToPage() on that newly added page.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Pages) AddPage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *Pages) AddPage(name string, item Primitive, resize, visible bool) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            AddPage adds a new page with the given name and primitive. If there was previously a page with the same name, it is overwritten. Leaving the name empty may cause conflicts in other functions so always specify a non-empty name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Visible pages will be drawn in the order they were added (unless that order was changed in one of the other functions). If "resize" is set to true, the primitive will be set to the size available to the Pages primitive whenever the pages are drawn.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Pages) Draw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (p *Pages) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Pages) Focus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *Pages) Focus(delegate func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Focus is called by the application when the primitive receives focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Pages) GetFrontPage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (p *Pages) GetFrontPage() (name string, item Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetFrontPage returns the front-most visible page. If there are no visible pages, ("", nil) is returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Pages) GetPageCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (p *Pages) GetPageCount() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetPageCount returns the number of pages currently stored in this object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Pages) HasFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (p *Pages) HasFocus() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HasFocus returns whether or not this primitive has focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Pages) HasPage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *Pages) HasPage(name string) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        HasPage returns true if a page with the given name exists in this object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Pages) HidePage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *Pages) HidePage(name string) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          HidePage sets a page's visibility to "false".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Pages) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *Pages) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Pages) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (p *Pages) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Pages) RemovePage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *Pages) RemovePage(name string) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RemovePage removes the page with the given name. If that page was the only visible page, visibility is assigned to the last page.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Pages) SendToBack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (p *Pages) SendToBack(name string) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SendToBack changes the order of the pages such that the page with the given name comes first, causing it to be drawn first with the next update (if visible).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Pages) SendToFront

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (p *Pages) SendToFront(name string) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SendToFront changes the order of the pages such that the page with the given name comes last, causing it to be drawn last with the next update (if visible).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Pages) SetChangedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (p *Pages) SetChangedFunc(handler func()) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetChangedFunc sets a handler which is called whenever the visibility or the order of any visible pages changes. This can be used to redraw the pages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Pages) ShowPage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *Pages) ShowPage(name string) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ShowPage sets a page's visibility to "true" (in addition to any other pages which are already visible).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Pages) SwitchToPage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *Pages) SwitchToPage(name string) *Pages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SwitchToPage sets a page's visibility to "true" and all other pages' visibility to "false".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Primitive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Primitive interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Draw draws this primitive onto the screen. Implementers can call the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// screen's ShowCursor() function but should only do so when they have focus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// (They will need to keep track of this themselves.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Draw(screen tcell.Screen)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// GetRect returns the current position of the primitive, x, y, width, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// height.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	GetRect() (int, int, int, int)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// SetRect sets a new position of the primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SetRect(x, y, width, height int)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// InputHandler returns a handler which receives key events when it has focus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// It is called by the Application class.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A value of nil may also be returned, in which case this primitive cannot
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// receive focus and will not process any key events.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The handler will receive the key event and a function that allows it to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// set the focus to a different primitive, so that future key events are sent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// to that primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Application's Draw() function will be called automatically after the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// handler returns.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Box class provides functionality to intercept keyboard input. If you
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// subclass from Box, it is recommended that you wrap your handler using
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Box.WrapInputHandler() so you inherit that functionality.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Focus is called by the application when the primitive receives focus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Implementers may call delegate() to pass the focus on to another primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Focus(delegate func(p Primitive))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// HasFocus determines if the primitive has focus. This function must return
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// true also if one of this primitive's child elements has focus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HasFocus() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Blur is called by the application when the primitive loses focus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Blur()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// MouseHandler returns a handler which receives mouse events.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// It is called by the Application class.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A value of nil may also be returned to stop the downward propagation of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// mouse events.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Box class provides functionality to intercept mouse events. If you
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// subclass from Box, it is recommended that you wrap your handler using
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Box.WrapMouseHandler() so you inherit that functionality.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Primitive is the top-most interface for all graphical primitives.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Table struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	*Box
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Table visualizes two-dimensional data consisting of rows and columns. Each Table cell is defined via SetCell() by the TableCell type. They can be added dynamically to the table and changed any time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The most compact display of a table is without borders. Each row will then occupy one row on screen and columns are separated by the rune defined via SetSeparator() (a space character by default).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When borders are turned on (via SetBorders()), each table cell is surrounded by lines. Therefore one table row will require two rows on screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Columns will use as much horizontal space as they need. You can constrain their size with the MaxWidth parameter of the TableCell type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Fixed Columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can define fixed rows and rolumns via SetFixed(). They will always stay in their place, even when the table is scrolled. Fixed rows are always the top rows. Fixed columns are always the leftmost columns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Selections

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can call SetSelectable() to set columns and/or rows to "selectable". If the flag is set only for columns, entire columns can be selected by the user. If it is set only for rows, entire rows can be selected. If both flags are set, individual cells can be selected. The "selected" handler set via SetSelectedFunc() is invoked when the user presses Enter on a selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Navigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If the table extends beyond the available space, it can be navigated with key bindings similar to Vim:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - h, left arrow: Move left by one column.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - l, right arrow: Move right by one column.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - j, down arrow: Move down by one row.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - k, up arrow: Move up by one row.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - g, home: Move to the top.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - G, end: Move to the bottom.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - Ctrl-F, page down: Move down by one page.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - Ctrl-B, page up: Move up by one page.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When there is no selection, this affects the entire table (except for fixed rows and columns). When there is a selection, the user moves the selection. The class will attempt to keep the selection from moving out of the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use SetInputCapture() to override or modify keyboard input.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See https://github.com/rivo/tview/wiki/Table for an example.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewTable() *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewTable returns a new table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Table) Clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *Table) Clear() *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Clear removes all table data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Table) Draw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *Table) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Table) GetCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *Table) GetCell(row, column int) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetCell returns the contents of the cell at the specified position. A valid TableCell object is always returned but it will be uninitialized if the cell was not previously set. Such an uninitialized object will not automatically be inserted. Therefore, repeated calls to this function may return different pointers for uninitialized cells.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Table) GetColumnCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *Table) GetColumnCount() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetColumnCount returns the (maximum) number of columns in the table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Table) GetOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *Table) GetOffset() (row, column int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetOffset returns the current row and column offset. This indicates how many rows and columns the table is scrolled down and to the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Table) GetRowCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *Table) GetRowCount() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetRowCount returns the number of rows in the table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Table) GetSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *Table) GetSelectable() (rows, columns bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetSelectable returns what can be selected in a table. Refer to SetSelectable() for details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Table) GetSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *Table) GetSelection() (row, column int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetSelection returns the position of the current selection. If entire rows are selected, the column index is undefined. Likewise for entire columns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Table) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *Table) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Table) InsertColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *Table) InsertColumn(column int) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  InsertColumn inserts a column before the column with the given index. Cells in the given column and to its right will be shifted to the right by one column. Rows that have fewer initialized cells than "column" will remain unchanged.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Table) InsertRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *Table) InsertRow(row int) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    InsertRow inserts a row before the row with the given index. Cells on the given row and below will be shifted to the bottom by one row. If "row" is equal or larger than the current number of rows, this function has no effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Table) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *Table) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Table) RemoveColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *Table) RemoveColumn(column int) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RemoveColumn removes the column at the given position from the table. If there is no such column, this has no effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Table) RemoveRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *Table) RemoveRow(row int) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          RemoveRow removes the row at the given position from the table. If there is no such row, this has no effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Table) ScrollToBeginning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *Table) ScrollToBeginning() *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ScrollToBeginning scrolls the table to the beginning to that the top left corner of the table is shown. Note that this position may be corrected if there is a selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Table) ScrollToEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *Table) ScrollToEnd() *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ScrollToEnd scrolls the table to the beginning to that the bottom left corner of the table is shown. Adding more rows to the table will cause it to automatically scroll with the new data. Note that this position may be corrected if there is a selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Table) Select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *Table) Select(row, column int) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Select sets the selected cell. Depending on the selection settings specified via SetSelectable(), this may be an entire row or column, or even ignored completely. The "selection changed" event is fired if such a callback is available (even if the selection ends up being the same as before and even if cells are not selectable).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Table) SetBorders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *Table) SetBorders(show bool) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetBorders sets whether or not each cell in the table is surrounded by a border.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Table) SetBordersColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *Table) SetBordersColor(color tcell.Color) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetBordersColor sets the color of the cell borders.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Table) SetCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *Table) SetCell(row, column int, cell *TableCell) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetCell sets the content of a cell the specified position. It is ok to directly instantiate a TableCell object. If the cell has content, at least the Text and Color fields should be set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Note that setting cells in previously unknown rows and columns will automatically extend the internal table representation with empty TableCell objects, e.g. starting with a row of 100,000 will immediately create 100,000 empty rows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To avoid unnecessary garbage collection, fill columns from left to right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Table) SetCellSimple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *Table) SetCellSimple(row, column int, text string) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetCellSimple calls SetCell() with the given text, left-aligned, in white.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Table) SetDoneFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *Table) SetDoneFunc(handler func(key tcell.Key)) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetDoneFunc sets a handler which is called whenever the user presses the Escape, Tab, or Backtab key. If nothing is selected, it is also called when user presses the Enter key (because pressing Enter on a selection triggers the "selected" handler set via SetSelectedFunc()).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Table) SetEvaluateAllRows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *Table) SetEvaluateAllRows(all bool) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetEvaluateAllRows sets a flag which determines the rows to be evaluated when calculating the widths of the table's columns. When false, only visible rows are evaluated. When true, all rows in the table are evaluated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Set this flag to true to avoid shifting column widths when the table is scrolled. (May be slower for large tables.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Table) SetFixed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *Table) SetFixed(rows, columns int) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetFixed sets the number of fixed rows and columns which are always visible even when the rest of the cells are scrolled out of view. Rows are always the top-most ones. Columns are always the left-most ones.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Table) SetOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *Table) SetOffset(row, column int) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetOffset sets how many rows and columns should be skipped when drawing the table. This is useful for large tables that do not fit on the screen. Navigating a selection can change these values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Fixed rows and columns are never skipped.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Table) SetSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *Table) SetSelectable(rows, columns bool) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetSelectable sets the flags which determine what can be selected in a table. There are three selection modi:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - rows = false, columns = false: Nothing can be selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - rows = true, columns = false: Rows can be selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - rows = false, columns = true: Columns can be selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - rows = true, columns = true: Individual cells can be selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Table) SetSelectedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *Table) SetSelectedFunc(handler func(row, column int)) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSelectedFunc sets a handler which is called whenever the user presses the Enter key on a selected cell/row/column. The handler receives the position of the selection and its cell contents. If entire rows are selected, the column index is undefined. Likewise for entire columns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Table) SetSelectedStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *Table) SetSelectedStyle(style tcell.Style) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetSelectedStyle sets a specific style for selected cells. If no such style is set, per default, selected cells are inverted (i.e. their foreground and background colors are swapped).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To reset a previous setting to its default, make the following call:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      table.SetSelectedStyle(tcell.Style{})
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Table) SetSelectionChangedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *Table) SetSelectionChangedFunc(handler func(row, column int)) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetSelectionChangedFunc sets a handler which is called whenever the current selection changes. The handler receives the position of the new selection. If entire rows are selected, the column index is undefined. Likewise for entire columns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Table) SetSeparator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *Table) SetSeparator(separator rune) *Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetSeparator sets the character used to fill the space between two neighboring cells. This is a space character ' ' per default but you may want to set it to Borders.Vertical (or any other rune) if the column separation should be more visible. If cell borders are activated, this is ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Separators have the same color as borders.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TableCell struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The reference object.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Reference interface{}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The text to be displayed in the table cell.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Text string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The alignment of the cell text. One of AlignLeft (default), AlignCenter,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// or AlignRight.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Align int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The maximum width of the cell in screen space. This is used to give a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// column a maximum width. Any cell text whose screen width exceeds this width
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// is cut off. Set to 0 if there is no maximum width.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MaxWidth int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// If the total table width is less than the available width, this value is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// used to add extra width to a column. See SetExpansion() for details.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Expansion int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The color of the cell text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Color tcell.Color
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The background color of the cell.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	BackgroundColor tcell.Color
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// If set to true, the BackgroundColor is not used and the cell will have
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// the background color of the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Transparent bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The style attributes of the cell.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Attributes tcell.AttrMask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// If set to true, this cell cannot be selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	NotSelectable bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// An optional handler for mouse clicks. This also fires if the cell is not
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// selectable. If true is returned, no additional "selected" event is fired
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// on selectable cells.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Clicked func() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TableCell represents one cell inside a Table. You can instantiate this type directly but all colors (background and text) will be set to their default which is black.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewTableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewTableCell(text string) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewTableCell returns a new table cell with sensible defaults. That is, left aligned text with the primary text color (see Styles) and a transparent background (using the background of the Table).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TableCell) GetLastPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *TableCell) GetLastPosition() (x, y, width int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetLastPosition returns the position of the table cell the last time it was drawn on screen. If the cell is not on screen, the return values are undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Because the Table class will attempt to keep selected cells on screen, this function is most useful in response to a "selected" event (see SetSelectedFunc()) or a "selectionChanged" event (see SetSelectionChangedFunc()).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TableCell) GetReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *TableCell) GetReference() interface{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetReference returns this cell's reference object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TableCell) SetAlign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *TableCell) SetAlign(align int) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetAlign sets the cell's text alignment, one of AlignLeft, AlignCenter, or AlignRight.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TableCell) SetAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *TableCell) SetAttributes(attr tcell.AttrMask) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetAttributes sets the cell's text attributes. You can combine different attributes using bitmask operations:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cell.SetAttributes(tcell.AttrUnderline | tcell.AttrBold)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TableCell) SetBackgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *TableCell) SetBackgroundColor(color tcell.Color) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetBackgroundColor sets the cell's background color. This will also cause the cell's Transparent flag to be set to "false".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TableCell) SetClickedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *TableCell) SetClickedFunc(clicked func() bool) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetClickedFunc sets a handler which fires when this cell is clicked. This is independent of whether the cell is selectable or not. But for selectable cells, if the function returns "true", the "selected" event is not fired.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TableCell) SetExpansion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *TableCell) SetExpansion(expansion int) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetExpansion sets the value by which the column of this cell expands if the available width for the table is more than the table width (prior to applying this expansion value). This is a proportional value. The amount of unused horizontal space is divided into widths to be added to each column. How much extra width a column receives depends on the expansion value: A value of 0 (the default) will not cause the column to increase in width. Other values are proportional, e.g. a value of 2 will cause a column to grow by twice the amount of a column with a value of 1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Since this value affects an entire column, the maximum over all visible cells in that column is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This function panics if a negative value is provided.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TableCell) SetMaxWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *TableCell) SetMaxWidth(maxWidth int) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetMaxWidth sets maximum width of the cell in screen space. This is used to give a column a maximum width. Any cell text whose screen width exceeds this width is cut off. Set to 0 if there is no maximum width.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TableCell) SetReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *TableCell) SetReference(reference interface{}) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetReference allows you to store a reference of any type in this cell. This will allow you to establish a mapping between the cell and your actual data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TableCell) SetSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *TableCell) SetSelectable(selectable bool) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetSelectable sets whether or not this cell can be selected by the user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TableCell) SetStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *TableCell) SetStyle(style tcell.Style) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetStyle sets the cell's style (foreground color, background color, and attributes) all at once.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TableCell) SetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *TableCell) SetText(text string) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetText sets the cell's text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TableCell) SetTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *TableCell) SetTextColor(color tcell.Color) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetTextColor sets the cell's text color.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TableCell) SetTransparency

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *TableCell) SetTransparency(transparent bool) *TableCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetTransparency sets the background transparency of this cell. A value of "true" will cause the cell to use the table's background color. A value of "false" will cause it to use its own background color.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TextView struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	sync.Mutex
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	*Box
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TextView is a box which displays text. It implements the io.Writer interface so you can stream text to it. This does not trigger a redraw automatically but if a handler is installed via SetChangedFunc(), you can cause it to be redrawn. (See SetChangedFunc() for more details.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Navigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If the text view is scrollable (the default), text is kept in a buffer which may be larger than the screen and can be navigated similarly to Vim:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - h, left arrow: Move left.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - l, right arrow: Move right.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - j, down arrow: Move down.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - k, up arrow: Move up.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - g, home: Move to the top.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - G, end: Move to the bottom.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - Ctrl-F, page down: Move down by one page.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - Ctrl-B, page up: Move up by one page.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If the text is not scrollable, any text above the top visible line is discarded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use SetInputCapture() to override or modify keyboard input.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Colors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If dynamic colors are enabled via SetDynamicColors(), text color can be changed dynamically by embedding color strings in square brackets. This works the same way as anywhere else. Please see the package documentation for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Regions and Highlights

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If regions are enabled via SetRegions(), you can define text regions within the text and assign region IDs to them. Text regions start with region tags. Region tags are square brackets that contain a region ID in double quotes, for example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          We define a ["rg"]region[""] here.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A text region ends with the next region tag. Tags with no region ID ([""]) don't start new regions. They can therefore be used to mark the end of a region. Region IDs must satisfy the following regular expression:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [a-zA-Z0-9_,;: \-\.]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Regions can be highlighted by calling the Highlight() function with one or more region IDs. This can be used to display search results, for example.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The ScrollToHighlight() function can be used to jump to the currently highlighted region once when the text view is drawn the next time.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See https://github.com/rivo/tview/wiki/TextView for an example.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewTextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewTextView() *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewTextView returns a new text view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TextView) Clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TextView) Clear() *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Clear removes all text from the buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TextView) Draw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TextView) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TextView) Focus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TextView) Focus(delegate func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Focus is called when this primitive receives focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TextView) GetHighlights

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TextView) GetHighlights() (regionIDs []string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetHighlights returns the IDs of all currently highlighted regions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TextView) GetRegionText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TextView) GetRegionText(regionID string) string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetRegionText returns the text of the region with the given ID. If dynamic colors are enabled, color tags are stripped from the text. Newlines are always returned as '\n' runes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If the region does not exist or if regions are turned off, an empty string is returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TextView) GetScrollOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TextView) GetScrollOffset() (row, column int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetScrollOffset returns the number of rows and columns that are skipped at the top left corner when the text view has been scrolled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TextView) GetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TextView) GetText(stripAllTags bool) string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetText returns the current text of this text view. If "stripAllTags" is set to true, any region/color tags are stripped from the text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TextView) HasFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TextView) HasFocus() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HasFocus returns whether or not this primitive has focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TextView) Highlight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TextView) Highlight(regionIDs ...string) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Highlight specifies which regions should be highlighted. If highlight toggling is set to true (see SetToggleHighlights()), the highlight of the provided regions is toggled (highlighted regions are un-highlighted and vice versa). If toggling is set to false, the provided regions are highlighted and all other regions will not be highlighted (you may also provide nil to turn off all highlights).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For more information on regions, see class description. Empty region strings are ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Text in highlighted regions will be drawn inverted, i.e. with their background and foreground colors swapped.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TextView) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TextView) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TextView) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TextView) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TextView) ScrollTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TextView) ScrollTo(row, column int) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ScrollTo scrolls to the specified row and column (both starting with 0).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TextView) ScrollToBeginning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TextView) ScrollToBeginning() *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ScrollToBeginning scrolls to the top left corner of the text if the text view is scrollable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TextView) ScrollToEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TextView) ScrollToEnd() *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ScrollToEnd scrolls to the bottom left corner of the text if the text view is scrollable. Adding new rows to the end of the text view will cause it to scroll with the new data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TextView) ScrollToHighlight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TextView) ScrollToHighlight() *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ScrollToHighlight will cause the visible area to be scrolled so that the highlighted regions appear in the visible area of the text view. This repositioning happens the next time the text view is drawn. It happens only once so you will need to call this function repeatedly to always keep highlighted regions in view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nothing happens if there are no highlighted regions or if the text view is not scrollable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TextView) SetChangedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TextView) SetChangedFunc(handler func()) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetChangedFunc sets a handler function which is called when the text of the text view has changed. This is useful when text is written to this io.Writer in a separate goroutine. Doing so does not automatically cause the screen to be refreshed so you may want to use the "changed" handler to redraw the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Note that to avoid race conditions or deadlocks, there are a few rules you should follow:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - You can call Application.Draw() from this handler.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - You can call TextView.HasFocus() from this handler.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - During the execution of this handler, access to any other variables from
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this primitive or any other primitive must be queued using
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Application.QueueUpdate().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See package description for details on dealing with concurrency.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TextView) SetDoneFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TextView) SetDoneFunc(handler func(key tcell.Key)) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetDoneFunc sets a handler which is called when the user presses on the following keys: Escape, Enter, Tab, Backtab. The key is passed to the handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TextView) SetDynamicColors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TextView) SetDynamicColors(dynamic bool) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetDynamicColors sets the flag that allows the text color to be changed dynamically. See class description for details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TextView) SetHighlightedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TextView) SetHighlightedFunc(handler func(added, removed, remaining []string)) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetHighlightedFunc sets a handler which is called when the list of currently highlighted regions change. It receives a list of region IDs which were newly highlighted, those that are not highlighted anymore, and those that remain highlighted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Note that because regions are only determined during drawing, this function can only fire for regions that have existed during the last call to Draw().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TextView) SetMaxLines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TextView) SetMaxLines(maxLines int) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetMaxLines sets the maximum number of lines for this text view. Lines at the beginning of the text will be discarded when the text view is drawn, so as to remain below this value. Broken lines via word wrapping are counted individually.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note that GetText() will return the shortened text and may start with color and/or region tags that were open at the cutoff point.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A value of 0 (the default) will keep all lines in place.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TextView) SetRegions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TextView) SetRegions(regions bool) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetRegions sets the flag that allows to define regions in the text. See class description for details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TextView) SetScrollable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TextView) SetScrollable(scrollable bool) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetScrollable sets the flag that decides whether or not the text view is scrollable. If true, text is kept in a buffer and can be navigated. If false, the last line will always be visible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TextView) SetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TextView) SetText(text string) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetText sets the text of this text view to the provided string. Previously contained text will be removed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TextView) SetTextAlign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TextView) SetTextAlign(align int) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetTextAlign sets the text alignment within the text view. This must be either AlignLeft, AlignCenter, or AlignRight.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TextView) SetTextColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TextView) SetTextColor(color tcell.Color) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetTextColor sets the initial color of the text (which can be changed dynamically by sending color strings in square brackets to the text view if dynamic colors are enabled).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TextView) SetToggleHighlights

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TextView) SetToggleHighlights(toggle bool) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetToggleHighlights sets a flag to determine how regions are highlighted. When set to true, the Highlight() function (or a mouse click) will toggle the provided/selected regions. When set to false, Highlight() (or a mouse click) will simply highlight the provided regions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TextView) SetWordWrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TextView) SetWordWrap(wrapOnWords bool) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetWordWrap sets the flag that, if true and if the "wrap" flag is also true (see SetWrap()), wraps the line at spaces or after punctuation marks. Note that trailing spaces will not be printed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This flag is ignored if the "wrap" flag is false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TextView) SetWrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TextView) SetWrap(wrap bool) *TextView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetWrap sets the flag that, if true, leads to lines that are longer than the available width being wrapped onto the next line. If false, any characters beyond the available width are not displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TextView) Write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TextView) Write(p []byte) (n int, err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Write lets us implement the io.Writer interface. Tab characters will be replaced with TabSize space characters. A "\n" or "\r\n" will be interpreted as a new line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Theme struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PrimitiveBackgroundColor    tcell.Color // Main background color for primitives.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ContrastBackgroundColor     tcell.Color // Background color for contrasting elements.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	MoreContrastBackgroundColor tcell.Color // Background color for even more contrasting elements.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	BorderColor                 tcell.Color // Box borders.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TitleColor                  tcell.Color // Box titles.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	GraphicsColor               tcell.Color // Graphics.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PrimaryTextColor            tcell.Color // Primary text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SecondaryTextColor          tcell.Color // Secondary text (e.g. labels).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TertiaryTextColor           tcell.Color // Tertiary text (e.g. subtitles, notes).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InverseTextColor            tcell.Color // Text on primary-colored backgrounds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ContrastSecondaryTextColor  tcell.Color // Secondary text on ContrastBackgroundColor-colored backgrounds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Theme defines the colors used when primitives are initialized.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TreeNode

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TreeNode represents one node in a tree view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewTreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewTreeNode(text string) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewTreeNode returns a new tree node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TreeNode) AddChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (n *TreeNode) AddChild(node *TreeNode) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AddChild adds a new child node to this node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TreeNode) ClearChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (n *TreeNode) ClearChildren() *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ClearChildren removes all child nodes from this node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TreeNode) Collapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (n *TreeNode) Collapse() *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Collapse makes the child nodes of this node disappear.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TreeNode) CollapseAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (n *TreeNode) CollapseAll() *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CollapseAll collapses this node and all descendent nodes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TreeNode) Expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (n *TreeNode) Expand() *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Expand makes the child nodes of this node appear.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TreeNode) ExpandAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (n *TreeNode) ExpandAll() *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ExpandAll expands this node and all descendent nodes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TreeNode) GetChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (n *TreeNode) GetChildren() []*TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetChildren returns this node's children.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TreeNode) GetColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (n *TreeNode) GetColor() tcell.Color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetColor returns the node's color.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TreeNode) GetLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (n *TreeNode) GetLevel() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetLevel returns the node's level within the hierarchy, where 0 corresponds to the root node, 1 corresponds to its children, and so on. This is only guaranteed to be up to date immediately after the tree that contains this node is drawn.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TreeNode) GetReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (n *TreeNode) GetReference() interface{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetReference returns this node's reference object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TreeNode) GetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (n *TreeNode) GetText() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetText returns this node's text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TreeNode) IsExpanded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (n *TreeNode) IsExpanded() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IsExpanded returns whether the child nodes of this node are visible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TreeNode) RemoveChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (n *TreeNode) RemoveChild(node *TreeNode) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RemoveChild removes a child node from this node. If the child node cannot be found, nothing happens.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TreeNode) SetChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (n *TreeNode) SetChildren(childNodes []*TreeNode) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetChildren sets this node's child nodes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TreeNode) SetColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (n *TreeNode) SetColor(color tcell.Color) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetColor sets the node's text color.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TreeNode) SetExpanded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (n *TreeNode) SetExpanded(expanded bool) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetExpanded sets whether or not this node's child nodes should be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TreeNode) SetIndent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (n *TreeNode) SetIndent(indent int) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetIndent sets an additional indentation for this node's text. A value of 0 keeps the text as far left as possible with a minimum of line graphics. Any value greater than that moves the text to the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TreeNode) SetReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (n *TreeNode) SetReference(reference interface{}) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetReference allows you to store a reference of any type in this node. This will allow you to establish a mapping between the TreeView hierarchy and your internal tree structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TreeNode) SetSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (n *TreeNode) SetSelectable(selectable bool) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetSelectable sets a flag indicating whether this node can be selected by the user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TreeNode) SetSelectedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (n *TreeNode) SetSelectedFunc(handler func()) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSelectedFunc sets a function which is called when the user selects this node by hitting Enter when it is selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TreeNode) SetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (n *TreeNode) SetText(text string) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetText sets the node's text which is displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TreeNode) Walk

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (n *TreeNode) Walk(callback func(node, parent *TreeNode) bool) *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Walk traverses this node's subtree in depth-first, pre-order (NLR) order and calls the provided callback function on each traversed node (which includes this node) with the traversed node and its parent node (nil for this node). The callback returns whether traversal should continue with the traversed node's child nodes (true) or not recurse any deeper (false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TreeView struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	*Box
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TreeView displays tree structures. A tree consists of nodes (TreeNode objects) where each node has zero or more child nodes and exactly one parent node (except for the root node which has no parent node).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The SetRoot() function is used to specify the root of the tree. Other nodes are added locally to the root node or any of its descendents. See the TreeNode documentation for details on node attributes. (You can use SetReference() to store a reference to nodes of your own tree structure.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nodes can be selected by calling SetCurrentNode(). The user can navigate the selection or the tree by using the following keys:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - j, down arrow, right arrow: Move (the selection) down by one node.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - k, up arrow, left arrow: Move (the selection) up by one node.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - g, home: Move (the selection) to the top.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - G, end: Move (the selection) to the bottom.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - J: Move (the selection) up one level.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - K: Move (the selection) down one level (if it is shown).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - Ctrl-F, page down: Move (the selection) down by one page.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - Ctrl-B, page up: Move (the selection) up by one page.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selected nodes can trigger the "selected" callback when the user hits Enter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The root node corresponds to level 0, its children correspond to level 1, their children to level 2, and so on. Per default, the first level that is displayed is 0, i.e. the root node. You can call SetTopLevel() to hide levels.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If graphics are turned on (see SetGraphics()), lines indicate the tree's hierarchy. Alternative (or additionally), you can set different prefixes using SetPrefixes() for different levels, for example to display hierarchical bullet point lists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See https://github.com/rivo/tview/wiki/TreeView for an example.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewTreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewTreeView() *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewTreeView returns a new tree view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TreeView) Draw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TreeView) Draw(screen tcell.Screen)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Draw draws this primitive onto the screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TreeView) GetCurrentNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TreeView) GetCurrentNode() *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetCurrentNode returns the currently selected node or nil of no node is currently selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TreeView) GetRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TreeView) GetRoot() *TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetRoot returns the root node of the tree. If no such node was previously set, nil is returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TreeView) GetRowCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TreeView) GetRowCount() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetRowCount returns the number of "visible" nodes. This includes nodes which fall outside the tree view's box but notably does not include the children of collapsed nodes. Note that this value is only up to date after the tree view has been drawn.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TreeView) GetScrollOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TreeView) GetScrollOffset() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetScrollOffset returns the number of node rows that were skipped at the top of the tree view. Note that when the user navigates the tree view, this value is only updated after the tree view has been redrawn.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TreeView) InputHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TreeView) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive))

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        InputHandler returns the handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TreeView) MouseHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TreeView) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MouseHandler returns the mouse handler for this primitive.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TreeView) SetAlign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TreeView) SetAlign(align bool) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetAlign controls the horizontal alignment of the node texts. If set to true, all texts except that of top-level nodes will be placed in the same column. If set to false, they will indent with the hierarchy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TreeView) SetChangedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TreeView) SetChangedFunc(handler func(node *TreeNode)) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetChangedFunc sets the function which is called when the user navigates to a new tree node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TreeView) SetCurrentNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TreeView) SetCurrentNode(node *TreeNode) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetCurrentNode sets the currently selected node. Provide nil to clear all selections. Selected nodes must be visible and selectable, or else the selection will be changed to the top-most selectable and visible node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This function does NOT trigger the "changed" callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TreeView) SetDoneFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TreeView) SetDoneFunc(handler func(key tcell.Key)) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetDoneFunc sets a handler which is called whenever the user presses the Escape, Tab, or Backtab key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TreeView) SetGraphics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TreeView) SetGraphics(showGraphics bool) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetGraphics sets a flag which determines whether or not line graphics are drawn to illustrate the tree's hierarchy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TreeView) SetGraphicsColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TreeView) SetGraphicsColor(color tcell.Color) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetGraphicsColor sets the colors of the lines used to draw the tree structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TreeView) SetPrefixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TreeView) SetPrefixes(prefixes []string) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetPrefixes defines the strings drawn before the nodes' texts. This is a slice of strings where each element corresponds to a node's hierarchy level, i.e. 0 for the root, 1 for the root's children, and so on (levels will cycle).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For example, to display a hierarchical list with bullet points:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        treeView.SetGraphics(false).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetPrefixes([]string{"* ", "- ", "x "})
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TreeView) SetRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TreeView) SetRoot(root *TreeNode) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetRoot sets the root node of the tree.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TreeView) SetSelectedFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TreeView) SetSelectedFunc(handler func(node *TreeNode)) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetSelectedFunc sets the function which is called when the user selects a node by pressing Enter on the current selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TreeView) SetTopLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TreeView) SetTopLevel(topLevel int) *TreeView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetTopLevel sets the first tree level that is visible with 0 referring to the root, 1 to the root's child nodes, and so on. Nodes above the top level are not displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              demos
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              box
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Box primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Box primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              button
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Button primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Button primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              checkbox
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Checkbox primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Checkbox primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dropdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the DropDown primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the DropDown primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              flex
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Flex primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Flex primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              form
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Form primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Form primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              frame
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Frame primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Frame primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              grid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Grid primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Grid primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              inputfield
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the InputField primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the InputField primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              list
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the List primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the List primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              modal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Modal primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Modal primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pages
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Pages primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Pages primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              presentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A presentation of the tview package, implemented with tview.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A presentation of the tview package, implemented with tview.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              primitive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code which illustrates how to implement your own primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code which illustrates how to implement your own primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              table
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Table primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the Table primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              textview
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the TextView primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the TextView primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              treeview
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the TreeView primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for the TreeView primitive.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unicode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for unicode support (demonstrates wide Chinese characters).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Demo code for unicode support (demonstrates wide Chinese characters).