removing the old test UI codes

This commit is contained in:
2026-01-12 20:03:32 +00:00
parent 3d52caeb04
commit e7bfc5c81f
21 changed files with 30 additions and 395 deletions
+5
View File
@@ -0,0 +1,5 @@
// Package controllers defines our controller layer
package controllers
type MainController struct {
}
+55
View File
@@ -0,0 +1,55 @@
// Package controllers
package controllers
import (
"esdi/tui/internal/events"
"esdi/tui/internal/models"
"esdi/tui/internal/ui"
"strconv"
)
type WindowingController struct {
Ctx *ui.UIContext
Events *events.Bus
}
func (wc *WindowingController) CreateWindow(x, y,
width, height, title string) {
wc.Ctx.Log("x : %s\n", x)
wc.Ctx.Log("y : %s\n", y)
wc.Ctx.Log("width : %s\n", width)
wc.Ctx.Log("height: %s\n", height)
wc.Ctx.Log("title : %s\n", title)
// newWindow := tview.NewTreeNode(title)
xValue, err := strconv.ParseUint(x, 10, 64)
if err != nil {
wc.Events.Emit(events.Error{Error: err})
return
}
yValue, err := strconv.ParseUint(y, 10, 64)
if err != nil {
wc.Events.Emit(events.Error{Error: err})
return
}
widthValue, err := strconv.ParseUint(width, 10, 64)
if err != nil {
wc.Events.Emit(events.Error{Error: err})
return
}
heightValue, err := strconv.ParseUint(height, 10, 64)
if err != nil {
wc.Events.Emit(events.Error{Error: err})
return
}
window := models.Window{
X: uint16(xValue),
Y: uint16(yValue),
Width: uint16(widthValue),
Height: uint16(heightValue),
Title: title,
}
wc.Events.Emit(events.WindowCreated{Window: window})
}
+114
View File
@@ -0,0 +1,114 @@
// Package dom will be used to handle the multiple elements of an UI
package dom
import (
"fmt"
"io"
"github.com/rivo/tview"
)
// ErrElementAlreadyRegistered defines the error scenario of the user trying
// to register an element to the DOM with an already registered ID
type ErrElementAlreadyRegistered struct{}
func (e *ErrElementAlreadyRegistered) Error() string {
return "an element with that ID has already been registered in the DOM"
}
type DOM struct {
Root *UINode
elements map[string]*UINode
}
// NewDOM constructs a new DOM
func NewDOM() *DOM {
return &DOM{
Root: nil,
elements: make(map[string]*UINode),
}
}
// Debugging
func (d *DOM) ListRegisteredUINodes(io io.Writer) {
fmt.Printf("Registered Nodes:\n")
for key := range d.elements {
fmt.Fprintf(io, " %s\n", key)
}
}
// Private
func (d *DOM) idIsRegistered(ID string) bool {
_, ok := d.elements[ID]
return ok
}
// registerElem register a new element to the DOM
// should verify that the ID doesn't yet exist and thats it so far
func (d *DOM) registerElem(elem *UINode) error {
if d.idIsRegistered(elem.ID) {
return &ErrElementAlreadyRegistered{}
}
d.elements[elem.ID] = elem
return nil
}
// Public
// SetRoot defines the root element for the DOM
func (d *DOM) SetRoot(r *UINode) *DOM {
d.Root = r
return d
}
// NewUINode creates and registers a UI Node
func (d *DOM) NewUINode(ID string, parent, root tview.Primitive) (*UINode, error) {
newNode := &UINode{
ID: ID,
Self: root,
Children: make(map[string]*UINode),
}
err := d.registerElem(newNode)
if err != nil {
return nil, err
}
return newNode, nil
}
// GetRoot fetches the root UINode of the DOM
func (d *DOM) GetRoot(r *UINode) *UINode {
return d.Root
}
// GetRootElem fetches the root primitive of the dom
func (d *DOM) GetRootElem() tview.Primitive {
return d.Root.Self
}
// GetElemByID returns the primitive of a UINode given its ID
// returns nil if the Node isn't registered
func (d *DOM) GetElemByID(ID string) tview.Primitive {
if d.idIsRegistered(ID) {
return d.elements[ID].Self
}
return nil
}
// GetNodeByID returns a UINode given its ID
// returns nil if the Node isn't registered
func (d *DOM) GetNodeByID(ID string) *UINode {
if d.idIsRegistered(ID) {
return d.elements[ID]
}
return nil
}
// AppendElem adds a new UINode to a given UINode
func (d *DOM) AppendElem(root *UINode, elem *UINode) error {
return root.AppendItem(elem)
}
+28
View File
@@ -0,0 +1,28 @@
// Package dom
package dom
import (
"github.com/rivo/tview"
)
type UINode struct {
ID string
Self tview.Primitive
Parent tview.Primitive
Children map[string]*UINode
}
func newUINode(ID string, parent, root tview.Primitive) *UINode {
return &UINode{
ID: ID,
Self: root,
Children: make(map[string]*UINode),
}
}
func (l *UINode) AppendItem(item *UINode) error {
// Its not necessary to verify if this ID is already a child of this Node
// because we do that at the UI level
l.Children[item.ID] = item
return nil
}
+38
View File
@@ -0,0 +1,38 @@
// Package events defines a simple event handler system
package events
import "sync"
type Handler func(event any)
type Bus struct {
mu sync.RWMutex
handlers map[string][]Handler
}
func NewBus() *Bus {
return &Bus{
handlers: make(map[string][]Handler),
}
}
func (b *Bus) On(eventType any, h Handler) {
key := typeKey(eventType)
b.mu.Lock()
defer b.mu.Unlock()
b.handlers[key] = append(b.handlers[key], h)
}
func (b *Bus) Emit(event any) {
key := typeKey(event)
b.mu.RLock()
handlers := append([]Handler{}, b.handlers[key]...)
b.mu.RUnlock()
for _, h := range handlers {
h(event)
}
}
+13
View File
@@ -0,0 +1,13 @@
package events
import (
"esdi/tui/internal/models"
)
type Error struct {
Error error
}
type WindowCreated struct {
Window models.Window
}
+7
View File
@@ -0,0 +1,7 @@
package events
import "fmt"
func typeKey(v any) string {
return fmt.Sprintf("%T", v)
}
+10
View File
@@ -0,0 +1,10 @@
// Package models
package models
type Window struct {
X uint16
Y uint16
Width uint16
Height uint16
Title string
}
+96
View File
@@ -0,0 +1,96 @@
// Package tui
package tui
import (
"esdi/tui/internal/controllers"
"esdi/tui/internal/dom"
"esdi/tui/internal/events"
"esdi/tui/internal/ui"
"esdi/tui/internal/views"
"fmt"
"github.com/gdamore/tcell/v2"
"github.com/rivo/tview"
)
type TUI struct {
App *tview.Application
Dom *dom.DOM
Events *events.Bus
}
func NewTUI() *TUI {
return &TUI{
App: tview.NewApplication(),
Dom: dom.NewDOM(),
Events: events.NewBus(),
}
}
func (t *TUI) log(formatter string, args ...any) {
outputWin := t.Dom.GetElemByID("output-window").(*tview.TextView)
fmt.Fprintf(outputWin, formatter, args...)
}
func (t *TUI) Start() error {
// The app starts running here!
//
// Set the event capture for the global app itself here
t.App.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
if event.Key() == tcell.KeyCtrlC || event.Rune() == 'q' {
t.App.Stop()
return nil
}
return event
})
ctx := &ui.UIContext{
Redraw: func() {
t.App.QueueUpdateDraw(func() {})
},
Log: func(formatter string, args ...any) {
t.log(formatter, args...)
},
ChangeFocus: func(p tview.Primitive) {
t.App.SetFocus(p)
},
}
// Create the controllers
windowingController := &controllers.WindowingController{
Events: t.Events,
Ctx: ctx,
}
// Make the output window
err := views.BuildOutputWindow(t.Dom, ctx)
if err != nil {
panic("failed to create output window")
}
// Set the main view
mainUINode, err := views.BuildMainFlex(t.Dom, ctx, windowingController)
if err != nil {
panic(fmt.Errorf("failed to build main flex - %s", err.Error()))
}
rootNode, err := t.Dom.NewUINode("root", nil, mainUINode)
if err != nil {
panic(fmt.Errorf("failed to create root node - %s", err.Error()))
}
t.Dom.SetRoot(rootNode)
firstFocus := t.Dom.GetElemByID("device-api-list")
if firstFocus == nil {
panic(fmt.Errorf("`list-window` isn't registered"))
}
// Star the app
err = t.App.SetRoot(t.Dom.GetRootElem(), true).SetFocus(firstFocus).Run()
if err != nil {
return err
}
return nil
}
+10
View File
@@ -0,0 +1,10 @@
// Package ui
package ui
import "github.com/rivo/tview"
type UIContext struct {
Redraw func()
Log func(formatter string, args ...any)
ChangeFocus func(p tview.Primitive)
}
+28
View File
@@ -0,0 +1,28 @@
package views
import (
"esdi/tui/internal/dom"
"esdi/tui/internal/ui"
"slices"
"github.com/rivo/tview"
)
func AddAndShowPage(root *dom.DOM, ctx *ui.UIContext,
pages *tview.Pages, page *dom.UINode) error {
if !slices.Contains(pages.GetPageNames(false), page.ID) {
pages.AddAndSwitchToPage(page.ID, page.Self, true)
} else {
// Only change to page
pages.SwitchToPage(page.ID)
}
// Set focus to our new tool
ctx.ChangeFocus(page.Self)
return nil
}
// func PageExists(pages *tview.Pages, needle string) bool {
// return slices.Contains(pages.GetPageNames(false), needle)
// }
+232
View File
@@ -0,0 +1,232 @@
package views
import (
"esdi/tui/internal/controllers"
"esdi/tui/internal/dom"
"esdi/tui/internal/events"
"esdi/tui/internal/ui"
"github.com/gdamore/tcell/v2"
"github.com/rivo/tview"
)
const (
layoutToolFlexID = "layout-tool-flex"
layoutToolTreeID = "layout-tool-tree"
layoutToolActionPagesID = "layout-tool-action-pages"
)
func BindWindowEvents(
ctx *ui.UIContext,
bus *events.Bus,
tree *tview.TreeView,
) {
// I recon I have to change this for some type os event system that
// triggers directly on the UINodes I want them to be triggered on
bus.On(events.WindowCreated{}, func(e any) {
ctx.Log("Received a window created event\n")
if tree == nil {
ctx.Log("tree view is nil")
return
}
root := tree.GetRoot()
if root == nil {
ctx.Log("unable to get root of tree view")
return
}
newWindow := tview.NewTreeNode(e.(events.WindowCreated).Window.Title)
root.AddChild(newWindow)
})
bus.On(events.Error{}, func(e any) {
ctx.Log("Error performing action: %s\n", e.(events.Error).Error.Error())
})
}
func layoutToolTreeViewEvents(root *dom.DOM, ctx *ui.UIContext,
tree *tview.TreeView, wc *controllers.WindowingController) func(
event *tcell.EventKey) *tcell.EventKey {
return func(event *tcell.EventKey) *tcell.EventKey {
switch event.Key() {
case tcell.KeyEsc:
ctx.ChangeFocus(root.GetElemByID(deviceAPIListID))
}
switch event.Rune() {
case 'N':
// Create a new screen
// I think I will leave this one for later
case 'n':
// Create a new window
ctx.Log("calling new window form\n")
createNewWindowForm(root, ctx, wc)
case 'x':
// Delete selected window
ctx.Log("calling delete window\n")
curNode := tree.GetCurrentNode()
if curNode == nil {
ctx.Log("unable to get current tree node")
break
}
root := tree.GetRoot()
if root == nil {
ctx.Log("unable to get current tree node")
break
}
root.RemoveChild(curNode)
case 'm':
// Go into move mode
case 'e':
// Go into edit mode
}
return event
}
}
func layoutToolUIOnSelect(root *dom.DOM, ctx *ui.UIContext, wc *controllers.WindowingController) {
ctx.Log("Opening layout tool UI\n")
var err error
// Get the api pages
apiToolPages := root.GetElemByID(apiToolPagesID).(*tview.Pages)
if apiToolPages == nil {
ctx.Log(" Failed to retrive apiToolPages UI\n")
return
}
ctx.Log(" Checking if `%s` UINode already exists\n", layoutToolFlexID)
layoutToolUINode := root.GetNodeByID(layoutToolFlexID)
if layoutToolUINode == nil {
layoutToolUINode, err = buildLayoutFlexComponent(root, ctx, wc)
if err != nil {
ctx.Log(" Failed to build layout tool UI: %s\n", err.Error())
}
}
AddAndShowPage(root, ctx, apiToolPages, layoutToolUINode)
}
func buildLayoutTreeComponent(doc *dom.DOM, ctx *ui.UIContext,
wc *controllers.WindowingController) (*dom.UINode, error) {
layoutTree := tview.NewTreeView()
layoutTree.SetBorder(true).SetTitle("Layout Tree").
SetInputCapture(layoutToolTreeViewEvents(doc, ctx, layoutTree, wc))
layoutTreeUINode, err := doc.NewUINode(layoutToolTreeID,
doc.GetElemByID(rightFlexID), layoutTree)
if err != nil {
return nil, err
}
// Bind the events for the treeview
BindWindowEvents(ctx, wc.Events, layoutTreeUINode.Self.(*tview.TreeView))
// Create a root element
rootElem := tview.NewTreeNode(".")
layoutTree.SetRoot(rootElem).SetCurrentNode(rootElem)
return layoutTreeUINode, nil
}
func buildLayoutActionPagesComponent(doc *dom.DOM, _ *ui.UIContext,
_ *controllers.WindowingController) (*dom.UINode, error) {
actionPages := tview.NewPages()
actionPages.SetBorder(true).SetTitle("Action Page")
actionPagesUINode, err := doc.NewUINode(layoutToolActionPagesID,
doc.GetElemByID("right-flex"), actionPages)
if err != nil {
return nil, err
}
return actionPagesUINode, nil
}
func buildLayoutFlexComponent(root *dom.DOM, ctx *ui.UIContext,
wc *controllers.WindowingController) (*dom.UINode, error) {
// Want a TreeView at the top
layoutTreeUINode, err := buildLayoutTreeComponent(root, ctx, wc)
if err != nil {
return nil, err
}
// Want pages below to run actions
actionPagesUINode, err := buildLayoutActionPagesComponent(root, ctx, wc)
if err != nil {
return nil, err
}
layoutToolFlex := tview.NewFlex().SetDirection(tview.FlexRow)
layoutToolFlexNode, err := root.NewUINode(layoutToolFlexID,
root.GetElemByID(apiToolPagesID), layoutToolFlex)
if err != nil {
return nil, err
}
layoutToolFlex.
AddItem(layoutTreeUINode.Self, 0, 2, true).
AddItem(actionPagesUINode.Self, 0, 5, false)
return layoutToolFlexNode, nil
}
// Layout tool actions
func createNewWindowForm(root *dom.DOM, ctx *ui.UIContext,
wc *controllers.WindowingController) {
var err error
x0 := tview.NewInputField().SetLabel("x")
y0 := tview.NewInputField().SetLabel("y")
width := tview.NewInputField().SetLabel("width")
height := tview.NewInputField().SetLabel("height")
title := tview.NewInputField().SetLabel("title")
form := tview.NewForm().
AddFormItem(x0).
AddFormItem(y0).
AddFormItem(width).
AddFormItem(height).
AddFormItem(title).
AddButton("Create", func() {
wc.CreateWindow(
x0.GetText(),
y0.GetText(),
width.GetText(),
height.GetText(),
title.GetText(),
)
})
form.SetBorder(true).
SetTitle("new window form").
SetTitleAlign(tview.AlignLeft).
SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey {
switch ev.Key() {
case tcell.KeyEscape:
ctx.ChangeFocus(root.GetElemByID(layoutToolFlexID))
}
return ev
})
var formNode *dom.UINode
formNode = root.GetNodeByID("new-window-form")
if formNode == nil {
formNode, err = root.NewUINode("new-window-form",
root.GetElemByID(layoutToolActionPagesID), form)
if err != nil {
panic("failed to create UI node for the new window form: " + err.Error())
}
}
AddAndShowPage(root, ctx, root.GetElemByID(layoutToolActionPagesID).(*tview.Pages),
formNode)
}
+107
View File
@@ -0,0 +1,107 @@
// Package views
package views
import (
"fmt"
"esdi/tui/internal/controllers"
"esdi/tui/internal/dom"
"esdi/tui/internal/ui"
"github.com/rivo/tview"
)
const (
mainFlexID = "main-flex"
apiToolPagesID = "api-tool-pages"
rightFlexID = "right-flex"
outputPaneID = "output-window"
deviceAPIListID = "device-api-list"
)
const (
pageName = "empty-page"
)
func buildRightSidePages(root *dom.DOM, ctx *ui.UIContext) (*dom.UINode, error) {
// We need to build a set of pages with an empty page
emptyPage := tview.NewTextView().
SetTextAlign(tview.AlignCenter).
SetChangedFunc(func() {
ctx.Redraw()
})
emptyPage.SetBorder(true).SetTitle("-- Tool Area --")
fmt.Fprintf(emptyPage, "No Tool Selected")
apiToolPages := tview.NewPages().
AddPage(pageName, emptyPage, true, true)
apiToolPagesNode, err := root.NewUINode(apiToolPagesID, root.GetElemByID(rightFlexID),
apiToolPages)
if err != nil {
return nil, err
}
return apiToolPagesNode, nil
}
func buildRightSideFlex(root *dom.DOM, ctx *ui.UIContext) (*dom.UINode, error) {
apiToolPagesNode, err := buildRightSidePages(root, ctx)
if err != nil {
return nil, err
}
// This will be the right side flex
flex := tview.NewFlex().SetDirection(tview.FlexRow)
flexNode, err := root.NewUINode(rightFlexID, root.GetElemByID(mainFlexID), flex)
if err != nil {
return nil, err
}
outputWin := root.GetElemByID(outputPaneID)
if outputWin == nil {
panic("failed to attach output win to UI")
}
flex.
AddItem(apiToolPagesNode.Self, 0, 5, false).
AddItem(outputWin, 0, 2, false)
return flexNode, nil
}
func BuildMainFlex(root *dom.DOM, ctx *ui.UIContext,
wc *controllers.WindowingController) (*tview.Flex, error) {
// To build the main view we must set the DOM root
mainFlex := tview.NewFlex().SetDirection(tview.FlexColumn)
mainFlexUINode, err := root.NewUINode(mainFlexID, nil, mainFlex)
if err != nil {
return nil, err
}
root.SetRoot(mainFlexUINode)
deviceAPIList := tview.NewList().
AddItem("layout", "build a layout for CDashDisplay", 0, func() {
layoutToolUIOnSelect(root, ctx, wc)
})
deviceAPIList.SetBorder(true).SetTitle("list")
apiListWindowUINode, err := root.NewUINode(deviceAPIListID, root.GetRootElem(),
deviceAPIList)
if err != nil {
return nil, err
}
rightSideFlex, err := buildRightSideFlex(root, ctx)
if err != nil {
return nil, err
}
mainFlex.
AddItem(apiListWindowUINode.Self, 0, 1, false).
AddItem(rightSideFlex.Self, 0, 4, false)
return mainFlex, nil
}
+24
View File
@@ -0,0 +1,24 @@
package views
import (
"esdi/tui/internal/dom"
"esdi/tui/internal/ui"
"github.com/rivo/tview"
)
func BuildOutputWindow(root *dom.DOM, ctx *ui.UIContext) error {
var outputWin *tview.TextView
outputWin = tview.NewTextView().SetChangedFunc(func() {
ctx.Redraw()
outputWin.ScrollToEnd()
})
outputWin.SetBorder(true).SetTitle("DebugWindow")
_, err := root.NewUINode("output-window", nil, outputWin)
if err != nil {
return err
}
return nil
}