Terminal-based user interface toolkit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

448 lines
9.9 KiB

package cview
import (
"sync"
"github.com/gdamore/tcell/v2"
)
// panel represents a single panel of a Panels object.
type panel struct {
Name string // The panel's name.
Item Primitive // The panel's primitive.
Resize bool // Whether or not to resize the panel when it is drawn.
Visible bool // Whether or not this panel is visible.
}
// Panels is a container for other primitives often used as the application's
// root primitive. It allows to easily switch the visibility of the contained
// primitives.
type Panels struct {
*Box
// The contained panels. (Visible) panels are drawn from back to front.
panels []*panel
// We keep a reference to the function which allows us to set the focus to
// a newly visible panel.
setFocus func(p Primitive)
// An optional handler which is called whenever the visibility or the order of
// panels changes.
changed func()
sync.RWMutex
}
// NewPanels returns a new Panels object.
func NewPanels() *Panels {
p := &Panels{
Box: NewBox(),
}
p.focus = p
return p
}
// SetChangedFunc sets a handler which is called whenever the visibility or the
// order of any visible panels changes. This can be used to redraw the panels.
func (p *Panels) SetChangedFunc(handler func()) {
p.Lock()
defer p.Unlock()
p.changed = handler
}
// GetPanelCount returns the number of panels currently stored in this object.
func (p *Panels) GetPanelCount() int {
p.RLock()
defer p.RUnlock()
return len(p.panels)
}
// AddPanel adds a new panel with the given name and primitive. If there was
// previously a panel 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 panels 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 Panels primitive whenever
// the panels are drawn.
func (p *Panels) AddPanel(name string, item Primitive, resize, visible bool) {
hasFocus := p.HasFocus()
p.Lock()
defer p.Unlock()
var added bool
for i, pg := range p.panels {
if pg.Name == name {
p.panels[i] = &panel{Item: item, Name: name, Resize: resize, Visible: visible}
added = true
break
}
}
if !added {
p.panels = append(p.panels, &panel{Item: item, Name: name, Resize: resize, Visible: visible})
}
if p.changed != nil {
p.Unlock()
p.changed()
p.Lock()
}
if hasFocus {
p.Unlock()
p.Focus(p.setFocus)
p.Lock()
}
}
// RemovePanel removes the panel with the given name. If that panel was the only
// visible panel, visibility is assigned to the last panel.
func (p *Panels) RemovePanel(name string) {
hasFocus := p.HasFocus()
p.Lock()
defer p.Unlock()
var isVisible bool
for index, panel := range p.panels {
if panel.Name == name {
isVisible = panel.Visible
p.panels = append(p.panels[:index], p.panels[index+1:]...)
if panel.Visible && p.changed != nil {
p.Unlock()
p.changed()
p.Lock()
}
break
}
}
if isVisible {
for index, panel := range p.panels {
if index < len(p.panels)-1 {
if panel.Visible {
break // There is a remaining visible panel.
}
} else {
panel.Visible = true // We need at least one visible panel.
}
}
}
if hasFocus {
p.Unlock()
p.Focus(p.setFocus)
p.Lock()
}
}
// HasPanel returns true if a panel with the given name exists in this object.
func (p *Panels) HasPanel(name string) bool {
p.RLock()
defer p.RUnlock()
for _, panel := range p.panels {
if panel.Name == name {
return true
}
}
return false
}
// ShowPanel sets a panel's visibility to "true" (in addition to any other panels
// which are already visible).
func (p *Panels) ShowPanel(name string) {
hasFocus := p.HasFocus()
p.Lock()
defer p.Unlock()
for _, panel := range p.panels {
if panel.Name == name {
panel.Visible = true
if p.changed != nil {
p.Unlock()
p.changed()
p.Lock()
}
break
}
}
if hasFocus {
p.Unlock()
p.Focus(p.setFocus)
p.Lock()
}
}
// HidePanel sets a panel's visibility to "false".
func (p *Panels) HidePanel(name string) {
hasFocus := p.HasFocus()
p.Lock()
defer p.Unlock()
for _, panel := range p.panels {
if panel.Name == name {
panel.Visible = false
if p.changed != nil {
p.Unlock()
p.changed()
p.Lock()
}
break
}
}
if hasFocus {
p.Unlock()
p.Focus(p.setFocus)
p.Lock()
}
}
// SetCurrentPanel sets a panel's visibility to "true" and all other panels'
// visibility to "false".
func (p *Panels) SetCurrentPanel(name string) {
hasFocus := p.HasFocus()
p.Lock()
defer p.Unlock()
for _, panel := range p.panels {
if panel.Name == name {
panel.Visible = true
} else {
panel.Visible = false
}
}
if p.changed != nil {
p.Unlock()
p.changed()
p.Lock()
}
if hasFocus {
p.Unlock()
p.Focus(p.setFocus)
p.Lock()
}
}
// SendToFront changes the order of the panels such that the panel with the given
// name comes last, causing it to be drawn last with the next update (if
// visible).
func (p *Panels) SendToFront(name string) {
hasFocus := p.HasFocus()
p.Lock()
defer p.Unlock()
for index, panel := range p.panels {
if panel.Name == name {
if index < len(p.panels)-1 {
p.panels = append(append(p.panels[:index], p.panels[index+1:]...), panel)
}
if panel.Visible && p.changed != nil {
p.Unlock()
p.changed()
p.Lock()
}
break
}
}
if hasFocus {
p.Unlock()
p.Focus(p.setFocus)
p.Lock()
}
}
// SendToBack changes the order of the panels such that the panel with the given
// name comes first, causing it to be drawn first with the next update (if
// visible).
func (p *Panels) SendToBack(name string) {
hasFocus := p.HasFocus()
p.Lock()
defer p.Unlock()
for index, pg := range p.panels {
if pg.Name == name {
if index > 0 {
p.panels = append(append([]*panel{pg}, p.panels[:index]...), p.panels[index+1:]...)
}
if pg.Visible && p.changed != nil {
p.Unlock()
p.changed()
p.Lock()
}
break
}
}
if hasFocus {
p.Unlock()
p.Focus(p.setFocus)
p.Lock()
}
}
// GetFrontPanel returns the front-most visible panel. If there are no visible
// panels, ("", nil) is returned.
func (p *Panels) GetFrontPanel() (name string, item Primitive) {
p.RLock()
defer p.RUnlock()
for index := len(p.panels) - 1; index >= 0; index-- {
if p.panels[index].Visible {
return p.panels[index].Name, p.panels[index].Item
}
}
return
}
// HasFocus returns whether or not this primitive has focus.
func (p *Panels) HasFocus() bool {
p.RLock()
defer p.RUnlock()
for _, panel := range p.panels {
if panel.Item.GetFocusable().HasFocus() {
return true
}
}
return false
}
// Focus is called by the application when the primitive receives focus.
func (p *Panels) Focus(delegate func(p Primitive)) {
p.Lock()
defer p.Unlock()
if delegate == nil {
return // We cannot delegate so we cannot focus.
}
p.setFocus = delegate
var topItem Primitive
for _, panel := range p.panels {
if panel.Visible {
topItem = panel.Item
}
}
if topItem != nil {
p.Unlock()
delegate(topItem)
p.Lock()
}
}
// Draw draws this primitive onto the screen.
func (p *Panels) Draw(screen tcell.Screen) {
if !p.GetVisible() {
return
}
p.Box.Draw(screen)
p.Lock()
defer p.Unlock()
x, y, width, height := p.GetInnerRect()
for _, panel := range p.panels {
if !panel.Visible {
continue
}
if panel.Resize {
panel.Item.SetRect(x, y, width, height)
}
panel.Item.Draw(screen)
}
}
// MouseHandler returns the mouse handler for this primitive.
func (p *Panels) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive) {
return p.WrapMouseHandler(func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive) {
if !p.InRect(event.Position()) {
return false, nil
}
// Pass mouse events along to the last visible panel item that takes it.
for index := len(p.panels) - 1; index >= 0; index-- {
panel := p.panels[index]
if panel.Visible {
consumed, capture = panel.Item.MouseHandler()(action, event, setFocus)
if consumed {
return
}
}
}
return
})
}
// Support backwards compatibility with Pages.
type page = panel
// Pages is a wrapper around Panels.
//
// Deprecated: This type is provided for backwards compatibility.
// Developers should use Panels instead.
type Pages struct {
*Panels
}
// NewPages returns a new Panels object.
//
// Deprecated: This function is provided for backwards compatibility.
// Developers should use NewPanels instead.
func NewPages() *Pages {
return &Pages{NewPanels()}
}
// GetPageCount returns the number of panels currently stored in this object.
func (p *Pages) GetPageCount() int {
return p.GetPanelCount()
}
// AddPage adds a new panel with the given name and primitive.
func (p *Pages) AddPage(name string, item Primitive, resize, visible bool) {
p.AddPanel(name, item, resize, visible)
}
// AddAndSwitchToPage calls Add(), then SwitchTo() on that newly added panel.
func (p *Pages) AddAndSwitchToPage(name string, item Primitive, resize bool) {
p.AddPanel(name, item, resize, true)
p.SetCurrentPanel(name)
}
// RemovePage removes the panel with the given name.
func (p *Pages) RemovePage(name string) {
p.RemovePanel(name)
}
// HasPage returns true if a panel with the given name exists in this object.
func (p *Pages) HasPage(name string) bool {
return p.HasPanel(name)
}
// ShowPage sets a panel's visibility to "true".
func (p *Pages) ShowPage(name string) {
p.ShowPanel(name)
}
// HidePage sets a panel's visibility to "false".
func (p *Pages) HidePage(name string) {
p.HidePanel(name)
}
// SwitchToPage sets a panel's visibility to "true" and all other panels'
// visibility to "false".
func (p *Pages) SwitchToPage(name string) {
p.SetCurrentPanel(name)
}
// GetFrontPage returns the front-most visible panel.
func (p *Pages) GetFrontPage() (name string, item Primitive) {
return p.GetFrontPanel()
}