267 lines
5.9 KiB
Go
267 lines
5.9 KiB
Go
package views
|
|
|
|
import (
|
|
"esdi/tui/internal/dom"
|
|
"esdi/tui/internal/events"
|
|
"esdi/tui/internal/models"
|
|
"esdi/tui/internal/ui"
|
|
"fmt"
|
|
|
|
"github.com/gdamore/tcell/v2"
|
|
"github.com/rivo/tview"
|
|
)
|
|
|
|
const (
|
|
LayoutToolFlexID = "layout-tool-flex"
|
|
LayoutToolTreeID = "layout-tool-tree"
|
|
LayoutToolActionPagesID = "layout-tool-action-pages"
|
|
LayoutToolNewWindowID = "new-window-action-form"
|
|
)
|
|
|
|
type windowReference struct {
|
|
ID int16
|
|
Form *dom.UINode
|
|
}
|
|
|
|
func getWindowRefFromNode(node *tview.TreeNode) *windowReference {
|
|
ref := node.GetReference()
|
|
wRef, ok := ref.(*windowReference)
|
|
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
return wRef
|
|
}
|
|
|
|
func FindNodeByID(
|
|
node *tview.TreeNode,
|
|
id int16,
|
|
) *tview.TreeNode {
|
|
if node == nil {
|
|
return nil
|
|
}
|
|
|
|
if ref, ok := node.GetReference().(*windowReference); ok {
|
|
if ref.ID == id {
|
|
return node
|
|
}
|
|
}
|
|
|
|
for _, child := range node.GetChildren() {
|
|
if found := FindNodeByID(child, id); found != nil {
|
|
return found
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func BindWindowEvents(
|
|
bus *events.Bus,
|
|
doc *dom.DOM,
|
|
tree *tview.TreeView,
|
|
) {
|
|
bus.On(ui.WindowDestroyedEv{}, func(e any) {
|
|
root := tree.GetRoot()
|
|
if root == nil {
|
|
bus.Emit(ui.LogEv{Log: "unable to get current tree node"})
|
|
}
|
|
|
|
node := FindNodeByID(root, e.(ui.WindowDestroyedEv).ID)
|
|
if node != nil {
|
|
root.RemoveChild(node)
|
|
}
|
|
|
|
// NODE: add a log here in case it fails so we know whats going on
|
|
bus.Emit(ui.ForceRedraw{})
|
|
})
|
|
|
|
bus.On(ui.ErrorCreateWindowEv{}, func(e any) {
|
|
go func() {
|
|
bus.Emit(ui.LogEv{
|
|
Log: fmt.Sprintf(
|
|
"Error performing action: %s\n", e.(ui.ErrorCreateWindowEv).Error.Error(),
|
|
)})
|
|
}()
|
|
})
|
|
}
|
|
|
|
func getCurNodeRef(tree *tview.TreeView) (*windowReference, error) {
|
|
curNode := tree.GetCurrentNode()
|
|
|
|
if curNode == nil {
|
|
return nil, fmt.Errorf("unable to get current tree node")
|
|
}
|
|
|
|
winRef := getWindowRefFromNode(curNode)
|
|
if winRef == nil {
|
|
return nil, fmt.Errorf("unable to get window reference from tree node")
|
|
}
|
|
|
|
return winRef, nil
|
|
}
|
|
|
|
func layoutToolTreeViewOnSelect(bus *events.Bus) func(node *tview.TreeNode) {
|
|
return func(node *tview.TreeNode) {
|
|
// Get the window reference which will have the ID for the form
|
|
bus.Emit(ui.LogEv{Log: "PRESSED ENTER\n"})
|
|
|
|
ref := node.GetReference()
|
|
if ref == nil {
|
|
bus.Emit(ui.LogEv{Log: "Couldn't find reference for node\n"})
|
|
return
|
|
}
|
|
|
|
nodeWinRef := ref.(*windowReference)
|
|
bus.Emit(ui.ChangeFocusEv{Target: nodeWinRef.Form.Self})
|
|
}
|
|
}
|
|
|
|
type LayoutTreeView struct {
|
|
Tree *tview.TreeView
|
|
InputCapture func(*tcell.EventKey) *tcell.EventKey
|
|
// OnChange func(node *tview.TreeNode)
|
|
// OnSelect func(node *tview.TreeNode)
|
|
}
|
|
|
|
func NewLayoutTreeView() *LayoutTreeView {
|
|
view := &LayoutTreeView{
|
|
InputCapture: blankInputCapture,
|
|
// OnChange: blankTreeViewOnChange,
|
|
// OnSelect: blankTreeViewOnChange,
|
|
}
|
|
|
|
view.Tree = tview.NewTreeView()
|
|
|
|
view.Tree.SetBorder(true).SetTitle("Layout Tree")
|
|
view.Tree.SetInputCapture(view.InputCapture)
|
|
// Inject ChangedFunc
|
|
// Inject SelectedFunc
|
|
|
|
// Create a root element
|
|
rootElem := tview.NewTreeNode(".")
|
|
view.Tree.SetRoot(rootElem).SetCurrentNode(rootElem)
|
|
|
|
return view
|
|
}
|
|
|
|
func (lt *LayoutTreeView) AddWindow(win *models.UIWindow) error {
|
|
root := lt.Tree.GetRoot()
|
|
if root == nil {
|
|
return fmt.Errorf("unable to get root of treeview")
|
|
}
|
|
|
|
// Create this new node
|
|
newWindow := tview.NewTreeNode(
|
|
windowInfoPageTitle(win.WID, win.Data.Title.String()),
|
|
).SetReference(win)
|
|
|
|
root.AddChild(newWindow)
|
|
|
|
return nil
|
|
}
|
|
|
|
type LayoutToolActionView struct {
|
|
Pages *tview.Pages
|
|
CreateWindowView *CreateWindowFormView
|
|
}
|
|
|
|
func NewLayoutToolActionView() *LayoutToolActionView {
|
|
view := &LayoutToolActionView{
|
|
CreateWindowView: nil,
|
|
}
|
|
|
|
// Create an empty page for it
|
|
emptyPage := tview.NewTextView().
|
|
SetTextAlign(tview.AlignCenter).
|
|
SetChangedFunc(func() {}) // Need to hook here
|
|
|
|
emptyPage.SetBorder(true).SetTitle("-- Tool Area --")
|
|
fmt.Fprintf(emptyPage, "No tool selected")
|
|
|
|
view.Pages = tview.NewPages().AddPage(EmptyPageName, emptyPage, true, true)
|
|
|
|
return view
|
|
}
|
|
|
|
type LayoutToolView struct {
|
|
Flex *tview.Flex
|
|
FormQuickAccess map[int16]*WindowFormView
|
|
LayoutTree *LayoutTreeView
|
|
LayoutActions *LayoutToolActionView
|
|
}
|
|
|
|
func NewLayoutToolView() *LayoutToolView {
|
|
view := &LayoutToolView{
|
|
FormQuickAccess: make(map[int16]*WindowFormView),
|
|
}
|
|
|
|
// Want a TreeView at the top
|
|
view.LayoutTree = NewLayoutTreeView()
|
|
|
|
// Want pages below to run actions
|
|
view.LayoutActions = NewLayoutToolActionView()
|
|
|
|
// Create the flex
|
|
view.Flex = tview.NewFlex().SetDirection(tview.FlexRow)
|
|
|
|
view.Flex.
|
|
AddItem(view.LayoutTree.Tree, 0, 2, true).
|
|
AddItem(view.LayoutActions.Pages, 0, 5, false)
|
|
|
|
return view
|
|
}
|
|
|
|
func (ltv *LayoutToolView) WindowCreatedSuccessfuly(win *models.UIWindow) error {
|
|
updateWindowForm := NewWindowFormView(&win.Data)
|
|
|
|
// Update the pages ID
|
|
ltv.LayoutActions.Pages.RemovePage(LayoutToolNewWindowID)
|
|
AddAndShowPage(
|
|
ltv.LayoutActions.Pages,
|
|
windowInfoPageID(win.WID),
|
|
updateWindowForm.Form.Form,
|
|
)
|
|
|
|
// Then set the CreateWindowView pointer to nil
|
|
ltv.LayoutActions.CreateWindowView = nil
|
|
|
|
// Add this form thing to the quick access map
|
|
ltv.FormQuickAccess[win.WID] = updateWindowForm
|
|
|
|
// Add it to the tree view
|
|
return ltv.LayoutTree.AddWindow(win)
|
|
}
|
|
|
|
func (ltv *LayoutToolView) ShowCreateWindowForm() {
|
|
AddAndShowPage(
|
|
ltv.LayoutActions.Pages,
|
|
LayoutToolNewWindowID,
|
|
ltv.LayoutActions.CreateWindowView.Form.Form,
|
|
)
|
|
}
|
|
|
|
func (ltv *LayoutToolView) ShowWindowFormByID(idx int16) {
|
|
AddAndShowPage(
|
|
ltv.LayoutActions.Pages,
|
|
windowInfoPageID(idx),
|
|
nil,
|
|
)
|
|
}
|
|
|
|
func (ltv *LayoutToolView) DeleteWindowByNode(node *tview.TreeNode) {
|
|
root := ltv.LayoutTree.Tree.GetRoot()
|
|
if root == nil {
|
|
// We should do something I guess
|
|
return
|
|
}
|
|
|
|
root.RemoveChild(node)
|
|
|
|
// We have to delete it from the map
|
|
// This isn't very safe now is it?
|
|
delete(ltv.FormQuickAccess, node.GetReference().(*models.UIWindow).WID)
|
|
// Did we delete everything ???
|
|
}
|