widgets

type Align ¶

type Align int

Align positions text inside a cell or a line.

const (
	AlignLeft Align = iota
	AlignCenter
	AlignRight
)

type Boundary ¶

type Boundary interface {
	AtEdge(dir Direction) bool
}

Boundary is implemented by components that can tell whether the selection sits at an edge. The shell asks the focused screen before it turns an arrow key into a focus move: Up at the top edge goes to the breadcrumbs, Left at the left edge goes to the menu, and so on. A component that is not a Boundary keeps all arrow keys for itself.

AtEdge is a pure query of the model state, so it is as testable as View.

type Breadcrumbs ¶

type Breadcrumbs struct {
	// KeyMap holds the key bindings.
	KeyMap BreadcrumbsKeyMap
	// contains filtered or unexported fields
}

Breadcrumbs is a one-line navigation trail. Left and Right move the selection along the trail and Enter activates the selected crumb, which is reported with a CrumbSelectedMsg.

The selection rests on the last crumb. When the trail receives focus the selection jumps to the crumb before it, the parent step, so that Enter goes one step back. The trail is a Boundary: Left is at the edge on the first crumb and Right on the last.

func NewBreadcrumbs(id string, crumbs ...Crumb) Breadcrumbs

func (b Breadcrumbs) AtEdge(dir Direction) bool

func (b *Breadcrumbs) Blur()

func (b Breadcrumbs) Crumbs() []Crumb

func (b *Breadcrumbs) Focus()

func (b Breadcrumbs) Focused() bool

func (b Breadcrumbs) Selected() int

func (b *Breadcrumbs) SetCrumbs(crumbs []Crumb)

func (b *Breadcrumbs) SetSeparator(separator string)

func (b *Breadcrumbs) SetSeparatorStart(i int)

func (b *Breadcrumbs) SetSize(width, _ int)

func (b Breadcrumbs) Update(msg tea.Msg) (Breadcrumbs, tea.Cmd)

func (b Breadcrumbs) View() string

type BreadcrumbsKeyMap ¶

type BreadcrumbsKeyMap struct {
	Prev     key.Binding
	Next     key.Binding
	Activate key.Binding
}

BreadcrumbsKeyMap holds the key bindings of Breadcrumbs.

func DefaultBreadcrumbsKeyMap() BreadcrumbsKeyMap

func (k BreadcrumbsKeyMap) FullHelp() [][]key.Binding

func (k BreadcrumbsKeyMap) ShortHelp() []key.Binding

type Button ¶

type Button struct {
	// Label is the caption.
	Label string
	// Shortcut, when not zero, is shown before the label.
	Shortcut rune
	// Focused draws the button highlighted.
	Focused bool
	// Disabled draws the button dimmed.
	Disabled bool
	// Background and Foreground override the colours of an unfocused button.
	Background color.Color
	Foreground color.Color
}

Button is the look of a push button: a label with an optional shortcut hint in front of it, "(l) Login". It is a plain value; components that contain buttons keep the state (which one is focused) and render them with View.

func (b Button) Text() string

func (b Button) View(width int) string

func (b Button) Width() int

type ButtonPressedMsg ¶

type ButtonPressedMsg struct {
	ID       string
	ButtonID string
	Values   map[string]string
}

ButtonPressedMsg reports that an ActionRole button was pressed.

type ButtonRole ¶

type ButtonRole int

ButtonRole says what pressing a FormButton reports.

const (
	// SubmitRole buttons report SubmitMsg.
	SubmitRole ButtonRole = iota
	// CancelRole buttons report CancelMsg.
	CancelRole
	// ActionRole buttons report ButtonPressedMsg.
	ActionRole
)

type CancelMsg ¶

type CancelMsg struct {
	ID       string
	ButtonID string
}

CancelMsg reports that a CancelRole button was pressed, or Esc was, in which case ButtonID is empty.

type Crumb ¶

type Crumb struct {
	// Title is the text of the step.
	Title string
	// Color colours the step; the theme's hotkey colour is used when nil.
	Color color.Color
}

Crumb is one step of a navigation trail.

type CrumbSelectedMsg ¶

type CrumbSelectedMsg struct {
	ID    string
	Index int
	Crumb Crumb
}

CrumbSelectedMsg reports that a crumb was activated with the keyboard or the mouse. Index is its position in the trail, 0 being the root.

type Direction ¶

type Direction int

Direction is a direction of navigation.

const (
	Up Direction = iota
	Down
	Left
	Right
)

type Editor ¶

type Editor interface {
	Editing() bool
}

Editor is implemented by components that may currently own a text cursor. While Editing reports true the shell keeps application-wide key bindings out of the way so that text-editing keys keep their meaning.

type Field ¶

type Field struct {
	// ID identifies the field in Value, SetValue and the messages; it must be
	// unique in the form.
	ID string
	// Label is the caption in front of the control.
	Label string
	// Kind selects the control.
	Kind FieldKind
	// Value is the initial text, or for a SelectField the initially chosen
	// option (empty or unknown: nothing chosen).
	Value string
	// Placeholder is shown in an empty text field.
	Placeholder string
	// Width is the width of the control in columns; zero fills the row (text) or
	// fits the value (select).
	Width int
	// Options are the choices of a SelectField.
	Options []string
	// Text is the content of a StaticField; it may carry ANSI styling.
	Text string
	// Accept filters typed and pasted text. It receives the text the field would
	// hold after an insertion and the inserted rune; returning false drops the
	// insertion. It is the one function a Field holds: a pure input filter, that
	// is validation data and not behaviour, so it must not have side effects.
	Accept func(text string, last rune) bool
}

Field describes one labelled row of a Form.

type FieldChangedMsg ¶

type FieldChangedMsg struct {
	ID      string
	FieldID string
	Value   string
}

FieldChangedMsg reports that the user changed the value of a field by typing, deleting, pasting or choosing an option. SetValue does not send it.

type FieldKind ¶

type FieldKind int

FieldKind is the kind of a form field.

const (
	// TextField is a single-line text input.
	TextField FieldKind = iota
	// PasswordField is a text input that hides what is typed.
	PasswordField
	// SelectField is a single choice among Options.
	SelectField
	// StaticField is a read-only line of text that focus skips.
	StaticField
)

type Form ¶

type Form struct {
	// KeyMap holds the key bindings.
	KeyMap FormKeyMap
	// contains filtered or unexported fields
}

Form is a vertical form of labelled fields above a row of buttons. Fields sit one per row with labels right-aligned to the widest one, then a blank row and the buttons, aligned left. When the height is too small the form scrolls so the focused row stays visible.

Text and password fields wrap charm.land/bubbles/v2/textinput (virtual cursor on, blinking off, so no timer messages). Select fields and layout are own code: bubbles has no select, and a form needs the option list to take rows from the layout while it is open (capped at eight, scrolling inside).

Messages: FieldChangedMsg when Update changes a value, SubmitMsg, CancelMsg and ButtonPressedMsg for buttons, and CancelMsg with an empty ButtonID for Esc.

Keys (FormKeyMap): Tab and Down move to the next control, Shift+Tab and Up to the previous one; Enter on a field moves on and on a button presses it; Left and Right move between buttons; Esc cancels. On a closed select Enter, Space and Down open the option list, Up and Down move in it, Enter picks and Esc closes it, and Left and Right step through the options. Ctrl+Q and Ctrl+C are never consumed. Clicks focus a field or press a button.

Boundary: AtEdge(Up) is true on the first control, Down on the buttons (or the last field when there are none), Left when the text cursor is at the start, on the first button, or on a select at its first option, and Right when the cursor is at the end, on the last button, or on a select at its last option. While a select list is open no edge is reached. Form is an Editor while a text or password field is focused.

func NewForm(id string, fields []Field, buttons []FormButton) Form

func (f Form) AtEdge(dir Direction) bool

func (f *Form) Blur()

func (f Form) Editing() bool

func (f *Form) Focus()

func (f *Form) FocusField(id string) bool

func (f Form) Focused() bool

func (f *Form) SetButtons(buttons []FormButton)

func (f *Form) SetFields(fields []Field)

func (f *Form) SetSize(width, height int)

func (f *Form) SetValue(id, value string)

func (f Form) Update(msg tea.Msg) (Form, tea.Cmd)

func (f Form) Value(id string) string

func (f Form) Values() map[string]string

func (f Form) View() string

type FormButton ¶

type FormButton struct {
	// ID identifies the button in the messages.
	ID string
	// Label is the caption.
	Label string
	// Role selects the message a press reports.
	Role ButtonRole
}

FormButton is a push button below the fields of a Form.

type FormKeyMap ¶

type FormKeyMap struct {
	Next   key.Binding
	Prev   key.Binding
	Submit key.Binding
	Cancel key.Binding
	Left   key.Binding
	Right  key.Binding
	// Open opens a closed select.
	Open key.Binding
	// Press presses the focused button.
	Press key.Binding
}

FormKeyMap holds the key bindings of Form.

func DefaultFormKeyMap() FormKeyMap

func (k FormKeyMap) FullHelp() [][]key.Binding

func (k FormKeyMap) ShortHelp() []key.Binding

type Frame ¶

type Frame struct {
	// Title is drawn in the top border.
	Title string
	// Focused selects the focused border colour.
	Focused bool
	// Borders draws the border; without it the content fills the whole rectangle.
	Borders bool
	// Padding is the space between the border and the content.
	Padding Padding
	// TitleAlign positions the title along the top border.
	TitleAlign Align
}

Frame is the bordered, titled box a panel is drawn in. The border takes the theme's focused colour while Focused is true and its blurred colour otherwise. Frame is a plain value: With... methods return a modified copy, and Render is a pure function of the frame and its arguments.

frame := widgets.NewFrame().WithTitle("Projects").WithFocus(true)
out := frame.Render(list.View(), 40, 12)

func NewFrame() Frame

func (f Frame) Inner(width, height int) (w, h int)

func (f Frame) Origin() (x, y int)

func (f Frame) Render(content string, width, height int) string

func (f Frame) WithFocus(focused bool) Frame

func (f Frame) WithPadding(top, right, bottom, left int) Frame

func (f Frame) WithTitle(title string) Frame

func (f Frame) WithTitleAlign(align Align) Frame

func (f Frame) WithoutBorders() Frame

type ItemHighlightedMsg ¶

type ItemHighlightedMsg struct {
	ID    string
	Index int
	Item  list.Item
}

ItemHighlightedMsg reports that the highlighted item of a List changed because of a message passed to Update. Index is the position among the visible items (those matching the filter, when there is one).

type ItemSelectedMsg ¶

type ItemSelectedMsg struct {
	ID    string
	Index int
	Item  list.Item
}

ItemSelectedMsg reports that the highlighted item of a List was chosen with Enter, with its shortcut key, or by a click on the already highlighted row.

type List ¶

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

List is a compact vertical menu built on bubbles' list.Model, which supplies the cursor movement, paging and optional filtering. The wrapper turns off the title, status bar, help and pagination dots, draws its own theme-coloured rows, and reports what happens with messages.

Rows are one line high, or two when some item has a detail. The highlighted row is drawn across the full width in the theme's selected style. bubbles pages the list instead of scrolling it: moving past the last row of a page shows the next page.

Messages, returned as commands by Update:

• ItemHighlightedMsg when a key, a click or the wheel changes the highlighted item; SetItems and Select are setters and never emit
• ItemSelectedMsg on Enter, on the shortcut key of a MenuItem (after an ItemHighlightedMsg when that moved the highlight), and on a left click on the row that is already highlighted; a click on another row only highlights it

Keys, while focused: up, down, home, end, pgup and pgdown, all without wrapping around, and Enter. Letters are free for shortcuts. Unfocused, keys are ignored. Mouse clicks and the wheel work regardless of focus, with coordinates relative to the top-left cell; the wheel moves the highlight one row per notch.

Filtering is off until SetFilteringEnabled(true); then "/" starts it, and while the filter input is active the list is an Editor: Editing reports true and every key goes to bubbles unmodified. The parent must pass all messages, not only keys, to Update while filtering, because bubbles delivers the matches asynchronously. Enabling filtering costs one row for the filter input.

List is a Boundary: Up is at the edge when the first item is highlighted (or there are no items), Down when the last one is, and Left and Right always.

func NewList(id string, items ...list.Item) List

func (l List) AtEdge(dir Direction) bool

func (l *List) Blur()

func (l List) Editing() bool

func (l List) FilteringEnabled() bool

func (l *List) Focus()

func (l List) Focused() bool

func (l List) FullHelp() [][]key.Binding

func (l List) Index() int

func (l List) Items() []list.Item

func (l List) KeyMap() list.KeyMap

func (l *List) Select(index int)

func (l List) SelectedItem() list.Item

func (l *List) SetFilteringEnabled(enabled bool)

func (l *List) SetItems(items ...list.Item)

func (l *List) SetKeyMap(km list.KeyMap)

func (l *List) SetSize(width, height int)

func (l List) ShortHelp() []key.Binding

func (l List) Update(msg tea.Msg) (List, tea.Cmd)

func (l List) View() string

type MenuItem ¶

type MenuItem struct {
	// ID identifies the item for the parent.
	ID string
	// Label is the first line of the item.
	Label string
	// Detail, when not empty, is shown muted on a second line.
	Detail string
	// Shortcut, when not zero, is drawn as "(x) " before the label and selects
	// the item when the key is typed.
	Shortcut rune
	// Ref is any value the parent wants to get back with the item.
	Ref any
}

MenuItem is a ready-made list item: a label, an optional second line of detail, an optional shortcut key and an opaque reference the parent can use to find out what the item stands for.

func (i MenuItem) Description() string

func (i MenuItem) FilterValue() string

func (i MenuItem) Title() string

type Modal ¶

type Modal struct {
	// KeyMap holds the key bindings.
	KeyMap ModalKeyMap
	// contains filtered or unexported fields
}

Modal is a dialog: a bordered box with a title in its border, wrapped text and a row of buttons drawn with Button. View returns the box only, at its natural size; the shell overlays it on the screen with Center, so the modal need not know what is behind it. bubbles has no dialog, and Frame draws neither a background nor a custom border colour, so the box is drawn here.

A modal owns the input, so it is always focused and has no Focus or Blur: Left, Right, Tab and Shift+Tab move between the buttons (wrapping around), Enter presses the focused button, Esc answers with index -1, and every other key press is swallowed. Only Ctrl+C and Ctrl+Q are left alone, Update returning the model and no command, so that the shell can quit. A left click on a button presses it and every other click is swallowed. Mouse coordinates are relative to the top-left corner of the box, which is where the shell puts the box's top-left cell.

Messages: ModalDoneMsg. A tea.WindowSizeMsg sets the space the box must fit in, like SetMaxSize. Modal is neither a Boundary nor an Editor.

func NewModal(id string) Modal

func (m Modal) Active() int

func (m Modal) FullHelp() [][]key.Binding

func (m *Modal) SetButtons(labels ...string)

func (m *Modal) SetColors(colors ModalColors)

func (m *Modal) SetMaxSize(maxWidth, maxHeight int)

func (m *Modal) SetText(text string)

func (m *Modal) SetTitle(title string)

func (m Modal) ShortHelp() []key.Binding

func (m Modal) Size() (w, h int)

func (m Modal) Update(msg tea.Msg) (Modal, tea.Cmd)

func (m Modal) View() string

type ModalColors ¶

type ModalColors struct {
	Background       color.Color
	Text             color.Color
	Border           color.Color
	ButtonBackground color.Color
	ButtonText       color.Color
}

ModalColors overrides the colours of a Modal. A nil colour uses the theme's: the focus colour for the border, the text colour for the text, no background, and the default look for unfocused buttons.

type ModalDoneMsg ¶

type ModalDoneMsg struct {
	ID    string
	Index int
	Label string
}

ModalDoneMsg reports that the modal was answered: a button was pressed with Enter or a click, or Esc was pressed, in which case Index is -1 and Label is empty. The parent removes the modal when it receives it.

type ModalKeyMap ¶

type ModalKeyMap struct {
	Prev    key.Binding
	Next    key.Binding
	Confirm key.Binding
	Cancel  key.Binding
}

ModalKeyMap holds the key bindings of Modal.

func DefaultModalKeyMap() ModalKeyMap

func (k ModalKeyMap) FullHelp() [][]key.Binding

func (k ModalKeyMap) ShortHelp() []key.Binding

type NodeHighlightedMsg ¶

type NodeHighlightedMsg struct {
	ID   string
	Node TreeNode
}

NodeHighlightedMsg reports that the cursor moved to a node because of a key or a click. It is not sent for changes made with Select, SetRoots or SetChildren.

type NodeSelectedMsg ¶

type NodeSelectedMsg struct {
	ID   string
	Node TreeNode
}

NodeSelectedMsg reports that a node was activated: Enter on the cursor node, or a click on the node that already holds the cursor. The node is never changed by the message itself; Enter afterwards toggles a node that has children.

type Padding ¶

type Padding struct{ Top, Right, Bottom, Left int }

Padding is a space in rows and columns.

type Size ¶

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

Size is the share of a length one part of a layout takes: a fixed number of cells, or a weight in what remains.

func Fill(weight int) Size

func Fixed(n int) Size

type SubmitMsg ¶

type SubmitMsg struct {
	ID       string
	ButtonID string
	Values   map[string]string
}

SubmitMsg reports that a SubmitRole button was pressed.

type Tab ¶

type Tab struct {
	// ID identifies the tab for the parent.
	ID string
	// Title is the text shown in the strip.
	Title string
	// Closable adds a close mark to the tab.
	Closable bool
}

Tab is one entry of the tab strip.

type TabChangedMsg ¶

type TabChangedMsg struct {
	ID    string
	Index int
	Tab   Tab
}

TabChangedMsg reports that the active tab changed because of a key press or a click. Index is the position of the new active tab.

type TabCloseMsg ¶

type TabCloseMsg struct {
	ID    string
	Index int
	Tab   Tab
}

TabCloseMsg reports a click on the close mark of a closable tab. The parent decides whether to call RemoveTab.

type Tabs ¶

type Tabs struct {
	// KeyMap holds the key bindings.
	KeyMap TabsKeyMap
	// contains filtered or unexported fields
}

Tabs is a one-row strip of tab titles, optionally preceded by a label. It draws the strip only: the parent keeps the pages and shows the content of the active tab itself, following TabChangedMsg. bubbles has no tab strip, so the rendering is our own.

Left and Right switch tabs (no wrapping) and Alt+1 to Alt+9 jump to a tab, while focused. A click on a tab activates it, and a click on the close mark of a closable tab reports it. The active tab is drawn in the theme's selected style when the strip is focused and bold when it is not; inactive tabs are muted, and underlined in the Underscore style. When the strip is wider than the space it is scrolled so that the active tab is visible.

Messages: TabChangedMsg when the active tab changes through Update (never for SetActive, AddTab or RemoveTab, which are setters), and TabCloseMsg on a click on a close mark. Mouse clicks work regardless of focus, with the x coordinate relative to the left edge of the strip and y 0.

Tabs is a Boundary: Left is at the edge when the first tab is active, Right when the last one is, and Up and Down always. It is not an Editor.

func NewTabs(id string, style TabsStyle, tabs ...Tab) Tabs

func (t Tabs) Active() int

func (t *Tabs) AddTab(tab Tab)

func (t Tabs) AtEdge(dir Direction) bool

func (t *Tabs) Blur()

func (t *Tabs) Focus()

func (t Tabs) Focused() bool

func (t Tabs) FullHelp() [][]key.Binding

func (t *Tabs) RemoveTab(index int)

func (t *Tabs) SetActive(index int)

func (t *Tabs) SetLabel(label string)

func (t *Tabs) SetSize(width, _ int)

func (t Tabs) ShortHelp() []key.Binding

func (t Tabs) Tabs() []Tab

func (t Tabs) Update(msg tea.Msg) (Tabs, tea.Cmd)

func (t Tabs) View() string

type TabsKeyMap ¶

type TabsKeyMap struct {
	Prev key.Binding
	Next key.Binding
	// Jump activates tab n with alt+n, for n from 1 to 9.
	Jump key.Binding
}

TabsKeyMap holds the key bindings of Tabs.

func DefaultTabsKeyMap() TabsKeyMap

func (k TabsKeyMap) FullHelp() [][]key.Binding

func (k TabsKeyMap) ShortHelp() []key.Binding

type TabsStyle ¶

type TabsStyle struct {
	// Radio prefixes each tab with a filled circle when active, an empty one
	// otherwise.
	Radio bool
	// Underscore underlines the inactive tabs.
	Underscore bool
}

TabsStyle selects how the tab strip is drawn; the theme supplies colours.

type TextPane ¶

type TextPane struct {
	// KeyMap holds the key bindings.
	KeyMap TextPaneKeyMap
	// contains filtered or unexported fields
}

TextPane shows scrollable, optionally wrapped text and is built on bubbles' viewport, which does the scrolling, the soft wrapping and the horizontal cropping. The wrapper adds the key map (arrows, page keys, home and end; letters are not bound), a default text colour, the Boundary queries, and the exact-size View.

The content may carry ANSI styling (lipgloss output, theme.RedText, highlight output). Styling survives soft wrapping because the viewport cuts every wrapped row out of the styled line with ansi.Cut, which re-opens the styles that are active at the start of the row and closes them at its end (the tests verify this). A style that stays open across a line break, which the viewport would otherwise lose on the next line, is closed at the end of the line and re-opened at the start of the next by carryStyles when the content is set.

Wrapping is on by default and breaks lines at exactly the width (the viewport does not break at word boundaries). With SetWrap(false), Left and Right scroll horizontally. The wheel scrolls three lines. The vertical position is kept when the pane is resized and clamped to the text; SetContent scrolls to the top and AppendContent keeps the position.

TextPane sends no messages. It is a Boundary: Up is at the edge when scrolled to the top, Down at the bottom, Left when scrolled fully left (always while wrapping) and Right when scrolled fully right (always while wrapping). It is not an Editor.

func NewTextPane(id string) TextPane

func (t *TextPane) AppendContent(s string)

func (t TextPane) AtEdge(dir Direction) bool

func (t *TextPane) Blur()

func (t TextPane) Content() string

func (t *TextPane) Focus()

func (t TextPane) Focused() bool

func (t TextPane) FullHelp() [][]key.Binding

func (t *TextPane) GotoBottom()

func (t *TextPane) GotoTop()

func (t TextPane) ID() string

func (t TextPane) LineCount() int

func (t *TextPane) ScrollTo(y, x int)

func (t *TextPane) SetContent(s string)

func (t *TextPane) SetSize(width, height int)

func (t *TextPane) SetTextColor(c color.Color)

func (t *TextPane) SetWrap(wrap bool)

func (t TextPane) ShortHelp() []key.Binding

func (t TextPane) Update(msg tea.Msg) (TextPane, tea.Cmd)

func (t TextPane) View() string

func (t TextPane) XOffset() int

func (t TextPane) YOffset() int

type TextPaneKeyMap ¶

type TextPaneKeyMap struct {
	Up       key.Binding
	Down     key.Binding
	PageUp   key.Binding
	PageDown key.Binding
	Top      key.Binding
	Bottom   key.Binding
	Left     key.Binding
	Right    key.Binding
}

TextPaneKeyMap holds the key bindings of TextPane. Letters are not bound.

func DefaultTextPaneKeyMap() TextPaneKeyMap

func (k TextPaneKeyMap) FullHelp() [][]key.Binding

func (k TextPaneKeyMap) ShortHelp() []key.Binding

type Tree ¶

type Tree struct {
	// KeyMap holds the key bindings.
	KeyMap TreeKeyMap
	// contains filtered or unexported fields
}

Tree is a scrollable, data-driven hierarchy of TreeNode values. Several roots give the "hidden root" layout: they are drawn at the left edge.

Keys: Up, Down, PageUp, PageDown, Home and End move the cursor between visible selectable nodes. Right expands a collapsed node, or moves to the first selectable child of an expanded one. Left collapses an expanded node below the top level, or moves to its selectable parent; on a top-level node it does nothing. Enter reports NodeSelectedMsg and then toggles a node that has children, Space only toggles. A click selects the row (NodeSelectedMsg when it already held the cursor) and a click on the expand marker toggles it; the wheel scrolls without moving the cursor. Cursor moves made by Update are reported with NodeHighlightedMsg.

Boundary: AtEdge(Up) is true on the first selectable visible node, Down on the last, Left when Left would do nothing (a top-level node, or a node whose parent is a group header and that cannot collapse) and Right when Right would do nothing (a leaf, or an expanded node without a selectable child). Tree is not an Editor.

Why it does not wrap charm.land/bubbles/v2/tree: that component is built on a mutable *Node graph whose Open and Close mutate shared nodes, has no unselectable nodes, keys expansion by pointer rather than by ID, has no per-node colour, and renders the whole tree into a viewport on every move instead of exactly width x height rows. Tree needs all of those, so it draws the rows itself (with the guides and markers below) and reuses only key and help from bubbles.

func NewTree(id string, roots ...TreeNode) Tree

func (t Tree) AtEdge(dir Direction) bool

func (t *Tree) Blur()

func (t *Tree) Collapse(id string)

func (t *Tree) CollapseAll()

func (t Tree) Current() (TreeNode, bool)

func (t *Tree) Expand(id string)

func (t *Tree) ExpandAll()

func (t Tree) Expanded(id string) bool

func (t *Tree) Focus()

func (t Tree) Focused() bool

func (t Tree) Roots() []TreeNode

func (t *Tree) Select(id string) bool

func (t *Tree) SetChildren(id string, children []TreeNode) bool

func (t *Tree) SetExpanded(id string, open bool) bool

func (t *Tree) SetRoots(roots ...TreeNode)

func (t *Tree) SetSize(width, height int)

func (t Tree) Update(msg tea.Msg) (Tree, tea.Cmd)

func (t Tree) View() string

type TreeKeyMap ¶

type TreeKeyMap struct {
	Up       key.Binding
	Down     key.Binding
	PageUp   key.Binding
	PageDown key.Binding
	Home     key.Binding
	End      key.Binding
	Expand   key.Binding
	Collapse key.Binding
	Activate key.Binding
	Toggle   key.Binding
}

TreeKeyMap holds the key bindings of Tree.

func DefaultTreeKeyMap() TreeKeyMap

func (k TreeKeyMap) FullHelp() [][]key.Binding

func (k TreeKeyMap) ShortHelp() []key.Binding

type TreeNode ¶

type TreeNode struct {
	// ID identifies the node and must be unique in the tree.
	ID string
	// Text is the caption; it may carry ANSI styling and emoji.
	Text string
	// Ref is an arbitrary value the application attaches to the node.
	Ref any
	// Color colours the caption when the node is not the selected row; nil keeps
	// the terminal default.
	Color color.Color
	// Children are the nodes below this one.
	Children []TreeNode
	// Unselectable marks a group header: it is drawn (and can be expanded with
	// SetExpanded, ExpandAll or a click on its marker) but the cursor never rests
	// on it.
	Unselectable bool
}

TreeNode is one node of a Tree. Nodes are plain data: the tree keeps no pointers into them, and expansion and the cursor are tracked by ID.