layout

Documentation

Index

• Variables
• func Attached(layout Layout) *tree.NodeID
• func IsAttached(tree NodeType) bool
• func ValidateTree(tree NodeType) error
• type BarType
• type BorderType
• type Computable
  • func NewComputable(ctx context.Context) *Computable
• type Context
  • func (c *Context) Context() interface{}
  • func (c *Context) SetContext(context interface{})
• type Contextable
• type Layout
  • func Attach(layout Layout, id tree.NodeID) Layout
  • func New(node NodeType) Layout
  • func (l *Layout) MarshalJanet() interface{}
  • func (l *Layout) UnmarshalJanet(value *janet.Value) (err error)
• type Log
  • func NewLog() *Log
  • func (l *Log) SetLogger(log zerolog.Logger)
• type Loggable
• type MarginsType
• type NodeChangeEvent
• type NodeRemoveEvent
• type NodeType
  • func AttachFirst(node NodeType) NodeType
  • func Copy(node NodeType) NodeType
  • func Detach(node NodeType) NodeType
  • func RemoveAttached(node NodeType) NodeType
• type PaneType
• type Reusable
• type SplitType
• type Tab
• type TabsType
  • func (t TabsType) Active() (tab Tab)
  • func (t TabsType) ActiveIndex() int

Variables

var (
	KEYWORD_PANE    = janet.Keyword("pane")
	KEYWORD_SPLIT   = janet.Keyword("split")
	KEYWORD_MARGINS = janet.Keyword("margins")
	KEYWORD_BORDERS = janet.Keyword("borders")
	KEYWORD_TABS    = janet.Keyword("tabs")
	KEYWORD_BAR     = janet.Keyword("bar")
)

Functions

func Attached

func Attached(layout Layout) *tree.NodeID

Attached returns the ID field of the attached pane in the layout.

func IsAttached

func IsAttached(tree NodeType) bool

IsAttached reports whether the node provided leads to a node that is attached.

func ValidateTree

func ValidateTree(tree NodeType) error

ValidateTree inspects a tree and ensures that it conforms to all relevant constraints, namely there should only be one PaneType with Attached=true.

Types

type BarType

type BarType struct {
	Text   *prop.String
	Bottom bool
	Node   NodeType
}

type BorderType

type BorderType struct {
	Title       *prop.String
	TitleBottom *prop.String
	Border      *prop.Border
	BorderFg    *prop.Color
	BorderBg    *prop.Color
	Node        NodeType
}

type Computable

type Computable struct {
	util.Lifetime
	*Log
	*Context
}

func NewComputable

func NewComputable(ctx context.Context) *Computable

type Context

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

func (*Context) Context

func (c *Context) Context() interface{}

func (*Context) SetContext

func (c *Context) SetContext(context interface{})

type Contextable

type Contextable interface {
	SetContext(interface{})
}

Contextable is used for passing in an execution context that will be used when running Janet functions.

type Layout

type Layout struct {
	Root NodeType
}

func Attach

func Attach(layout Layout, id tree.NodeID) Layout

Attach changes the currently attached tree node to the one specified by id.

func New

func New(node NodeType) Layout

func (*Layout) MarshalJanet

func (l *Layout) MarshalJanet() interface{}

func (*Layout) UnmarshalJanet

func (l *Layout) UnmarshalJanet(value *janet.Value) (err error)

type Log

type Log struct {
	zerolog.Logger
}

func NewLog

func NewLog() *Log

func (*Log) SetLogger

func (l *Log) SetLogger(log zerolog.Logger)

type Loggable

type Loggable interface {
	SetLogger(zerolog.Logger)
}

Loggable is used for passing a logger to the Screen when appropriate.

type MarginsType

type MarginsType struct {
	Cols     int
	Rows     int
	Frame    *string
	Border   *prop.Border
	BorderFg *prop.Color
	BorderBg *prop.Color
	Node     NodeType
}

type NodeChangeEvent

type NodeChangeEvent struct {
	Config NodeType
}

type NodeRemoveEvent

type NodeRemoveEvent struct{}

type NodeType

type NodeType interface{}

func AttachFirst

func AttachFirst(node NodeType) NodeType

AttachFirst attaches to the first node it can find.

func Copy

func Copy(node NodeType) NodeType

Copy recursively copies the node. This is so mutations don't affect the original.

func Detach

func Detach(node NodeType) NodeType

Detach returns a copy of node with no attachment points.

func RemoveAttached

func RemoveAttached(node NodeType) NodeType

RemoveAttached removes the attached node by replacing its nearest parent that has more than one child with a parent with that child removed, or the other child if there are no other children.

type PaneType

type PaneType struct {
	Attached     bool
	RemoveOnExit *bool
	ID           *tree.NodeID
}

type Reusable

type Reusable interface {
	mux.Screen
	Apply(NodeType) (bool, error)
}

Reusable is used to describe a Screen that has a configuration that can change. Often a Screen does not actually need to be created from scratch when the corresponding layout node changes; it can just be updated. The reuse function checks whether the Screen can be updated to match the new configuration and updates it if possible.

type SplitType

type SplitType struct {
	Vertical bool
	Percent  *int
	Cells    *int
	Border   *prop.Border
	BorderFg *prop.Color
	BorderBg *prop.Color
	A        NodeType
	B        NodeType
}

type Tab

type Tab struct {
	Active bool
	Name   string
	Node   NodeType
}

type TabsType

type TabsType struct {
	ActiveFg, ActiveBg     *prop.Color
	InactiveFg, InactiveBg *prop.Color
	Bg                     *prop.Color
	Bottom                 bool
	Tabs                   []Tab
}

func (TabsType) Active

func (t TabsType) Active() (tab Tab)

Active returns the Tab config of the currently active tab.

func (TabsType) ActiveIndex

func (t TabsType) ActiveIndex() int

Active returns the index of the currently active tab.