chanding the architecure, removing the views ability to emit or listen to events

I liked my idea better but I recon I will hit less obstacles this way
This commit is contained in:
2026-02-24 23:22:19 +00:00
parent f40894577d
commit e64b1c31b9
12 changed files with 274 additions and 262 deletions
-30
View File
@@ -1,30 +0,0 @@
// Package controllers
package controllers
import (
"esdi/tui/internal/events"
)
type LayoutController struct {
EvBus *events.Bus
}
func NewLayoutController(bus *events.Bus) *LayoutController {
lc := &LayoutController{
EvBus: bus,
}
return lc
}
// func (lc *LayoutController) createWindow(win models.Window) {
// lc.EvBus.Emit(ui.LogEv{
// Log: fmt.Sprintf("x : %d\n"+
// "y : %d\n"+
// "width : %d\n"+
// "height: %d\n"+
// "title : %s\n", win.X, win.Y, win.Width, win.Height, win.Title),
// })
//
// lc.EvBus.Emit(ui.WindowCreatedEv{})
// }
@@ -0,0 +1,5 @@
package controllers
type LayoutController struct {
LayoutToolView any
}
+146 -34
View File
@@ -8,10 +8,12 @@ import (
"esdi/tui/internal/dom" "esdi/tui/internal/dom"
"esdi/tui/internal/events" "esdi/tui/internal/events"
"esdi/tui/internal/ui" "esdi/tui/internal/ui"
"esdi/tui/internal/views"
"fmt" "fmt"
"io" "io"
"log/slog" "log/slog"
"github.com/gdamore/tcell/v2"
"github.com/rivo/tview" "github.com/rivo/tview"
) )
@@ -22,18 +24,18 @@ func mcLog(msg string, args ...any) {
} }
type Ctrls struct { type Ctrls struct {
MC *MainController MC *MainController
WindowingController *LayoutController
} }
type MainController struct { type MainController struct {
Logger *slog.Logger DeviceAPIView *views.DeviceAPIView
App *tview.Application Logger *slog.Logger
Dom *dom.DOM App *tview.Application
EvBus *events.Bus Dom *dom.DOM
DevClerk *peripheral.PeripheralDeviceClerk EvBus *events.Bus
CDash *cdashdisplay.CDashDisplay DevClerk *peripheral.PeripheralDeviceClerk
StreamStrl *StreamingCtrl CDash *cdashdisplay.CDashDisplay
StreamStrl *StreamingCtrl
} }
func NewMainController(logger *slog.Logger) *MainController { func NewMainController(logger *slog.Logger) *MainController {
@@ -48,10 +50,12 @@ func NewMainController(logger *slog.Logger) *MainController {
} }
mc.EvBus.On(ui.RedrawEv{}, func(e any) { mc.EvBus.On(ui.RedrawEv{}, func(e any) {
rev := e.(ui.RedrawEv) go func() {
if rev.Fn != nil { rev := e.(ui.RedrawEv)
mc.App.QueueUpdateDraw(e.(ui.RedrawEv).Fn) if rev.Fn != nil {
} mc.App.QueueUpdateDraw(e.(ui.RedrawEv).Fn)
}
}()
}) })
mc.EvBus.On(ui.ChangeFocusEv{}, func(e any) { mc.EvBus.On(ui.ChangeFocusEv{}, func(e any) {
@@ -59,7 +63,11 @@ func NewMainController(logger *slog.Logger) *MainController {
}) })
mc.EvBus.On(ui.LogEv{}, func(e any) { mc.EvBus.On(ui.LogEv{}, func(e any) {
mc.EvBus.Emit(ui.PrintLogEv{Log: e.(ui.LogEv).Log}) go func() {
mc.App.QueueUpdateDraw(func() {
mc.EvBus.Emit(ui.PrintLogEv{Log: e.(ui.LogEv).Log})
})
}()
}) })
mc.EvBus.On(ui.CreateWindowEv{}, func(e any) { mc.EvBus.On(ui.CreateWindowEv{}, func(e any) {
@@ -166,26 +174,6 @@ func NewMainController(logger *slog.Logger) *MainController {
mc.EvBus.Emit(ui.RegisterLoadedLayout{*mc.CDash.State.Layout}) mc.EvBus.Emit(ui.RegisterLoadedLayout{*mc.CDash.State.Layout})
}) })
mc.EvBus.On(ui.FindCDashDisplay{}, func(e any) {
go func() {
mc.EvBus.Emit(ui.PrintLogEv{Log: "looking for cdash display\n"})
pLogger.Info("Looking for CDashDisplay")
cdashdisplay.SetLogger(pLogger.With("[device]", "cdashdisplay"))
display, err := cdashdisplay.NewCDashDisplay()
if err != nil {
pLogger.Info("didn't find cdashdisplay")
mc.EvBus.Emit(ui.PrintLogEv{Log: "didn't find cdash display\n"})
return
}
mc.CDash = display
pLogger.Info("found cdashdisplay on: " + display.WT.Cfg.Name)
mc.EvBus.Emit(ui.PrintLogEv{Log: "found cdashdisplay on: " + display.WT.Cfg.Name + "\n"})
}()
})
mc.EvBus.On(ui.ForceRedraw{}, func(e any) { mc.EvBus.On(ui.ForceRedraw{}, func(e any) {
// mc.App.QueueUpdateDraw(func() {}) // mc.App.QueueUpdateDraw(func() {})
mc.App.Draw() mc.App.Draw()
@@ -201,3 +189,127 @@ func NewMainController(logger *slog.Logger) *MainController {
return mc return mc
} }
func (mc *MainController) PrintToOutputWindow(msg string) {
mc.App.QueueUpdateDraw(func() {
fmt.Fprintf(mc.DeviceAPIView.OutputWindow.TextArea,
"%s", msg)
})
}
func (mc *MainController) findCDashDisplay() {
mc.PrintToOutputWindow("looking for cdash display\n")
pLogger.Info("Looking for CDashDisplay")
cdashdisplay.SetLogger(pLogger.With("[device]", "cdashdisplay"))
display, err := cdashdisplay.NewCDashDisplay()
if err != nil {
pLogger.Info("didn't find cdashdisplay")
mc.PrintToOutputWindow("didn't find cdash display\n")
return
}
mc.CDash = display
pLogger.Info("found cdashdisplay on: " + display.WT.Cfg.Name)
mc.PrintToOutputWindow("found cdashdisplay on: " + display.WT.Cfg.Name + "\n")
}
func (mc *MainController) setAppEventCapture() {
mc.App.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
if event.Key() == tcell.KeyCtrlC || event.Rune() == 'q' {
mc.App.Stop()
return nil
}
return event
})
}
func (mc *MainController) setDeviceAPIViewEvents() {
mc.DeviceAPIView.MainFlex.
SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey {
switch ev.Rune() {
case 'r':
go mc.findCDashDisplay()
}
return ev
})
}
func (mc *MainController) AddDeviceAPIListItems() {
mc.DeviceAPIView.DevAPIList.AddItem("layout", "build a layout for CDashDisplay",
func() {
var err error
// Get the api pages
apiToolPages := mc.DeviceAPIView.DevAPIToolView
layoutToolUINode := doc.GetNodeByID(views.LayoutToolFlexID)
if layoutToolUINode == nil {
layoutToolUINode, err = buildLayoutFlexComponent(bus, doc)
if err != nil {
bus.Emit(ui.LogEv{
Log: fmt.Sprintf(" Failed to build layout tool UI: %s\n", err.Error()),
})
}
}
err = views.AddAndShowPage(bus, doc, apiToolPages, layoutToolUINode, true)
if err == nil {
mc.App.SetFocus(e.(ui.ChangeFocusEv).Target)
}
// Set focus to our new tool
// if changeFocus {
// bus.Emit(ui.ChangeFocusEv{Target: page.Self})
// }
})
}
func layoutToolUIOnSelect(bus *events.Bus, doc *dom.DOM) {
}
func (mc *MainController) mainUI() error {
// Set the main view
deviceAPIView, err := views.NewDeviceAPIView(mc.Dom)
if err != nil {
return err
}
mc.setDeviceAPIViewEvents()
// Add the API things to the deviceAPIListView
mc.AddDeviceAPIListItems()
rootNode, err := mc.Dom.NewUINode("root", nil, deviceAPIView.MainFlex)
if err != nil {
return err
}
mc.DeviceAPIView = deviceAPIView
mc.Dom.SetRoot(rootNode)
return nil
}
func (mc *MainController) Main() error {
mc.setAppEventCapture()
err := mc.mainUI()
// First focused element
firstFocus := mc.Dom.GetElemByID(views.DeviceAPIListID)
if firstFocus == nil {
return err
}
// Star the app
err = mc.App.SetRoot(mc.Dom.GetRootElem(), true).SetFocus(firstFocus).Run()
if err != nil {
return err
}
return err
}
-54
View File
@@ -1,54 +0,0 @@
// Package tui
package tui
import (
"esdi/tui/internal/controllers"
"esdi/tui/internal/views"
"fmt"
"log/slog"
"github.com/gdamore/tcell/v2"
)
func Start(logger *slog.Logger) error {
// The app starts running here!
//
// Set the event capture for the global app itself here
mc := controllers.NewMainController(logger.With("[ctrl]", "main"))
mc.App.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
if event.Key() == tcell.KeyCtrlC || event.Rune() == 'q' {
mc.App.Stop()
return nil
}
return event
})
controllers.NewLayoutController(mc.EvBus)
// Set the main view
mainUINode, err := views.BuildMainFlex(mc.EvBus, mc.Dom)
if err != nil {
panic(fmt.Errorf("failed to build main flex - %s", err.Error()))
}
rootNode, err := mc.Dom.NewUINode("root", nil, mainUINode)
if err != nil {
panic(fmt.Errorf("failed to create root node - %s", err.Error()))
}
mc.Dom.SetRoot(rootNode)
firstFocus := mc.Dom.GetElemByID("device-api-list")
if firstFocus == nil {
panic(fmt.Errorf("`list-window` isn't registered"))
}
// Star the app
err = mc.App.SetRoot(mc.Dom.GetRootElem(), true).SetFocus(firstFocus).Run()
if err != nil {
return err
}
return nil
}
-9
View File
@@ -2,16 +2,12 @@ package views
import ( import (
"esdi/tui/internal/dom" "esdi/tui/internal/dom"
"esdi/tui/internal/events"
"esdi/tui/internal/ui"
"slices" "slices"
"github.com/rivo/tview" "github.com/rivo/tview"
) )
func AddAndShowPage( func AddAndShowPage(
bus *events.Bus,
doc *dom.DOM,
pages *tview.Pages, pages *tview.Pages,
page *dom.UINode, page *dom.UINode,
changeFocus bool, changeFocus bool,
@@ -23,11 +19,6 @@ func AddAndShowPage(
pages.SwitchToPage(page.ID) pages.SwitchToPage(page.ID)
} }
// Set focus to our new tool
if changeFocus {
bus.Emit(ui.ChangeFocusEv{Target: page.Self})
}
return nil return nil
} }
+16 -38
View File
@@ -12,9 +12,9 @@ import (
) )
const ( const (
layoutToolFlexID = "layout-tool-flex" LayoutToolFlexID = "layout-tool-flex"
layoutToolTreeID = "layout-tool-tree" LayoutToolTreeID = "layout-tool-tree"
layoutToolActionPagesID = "layout-tool-action-pages" LayoutToolActionPagesID = "layout-tool-action-pages"
) )
type windowReference struct { type windowReference struct {
@@ -155,7 +155,7 @@ func layoutToolTreeViewEvCapture(bus *events.Bus, doc *dom.DOM,
return func(event *tcell.EventKey) *tcell.EventKey { return func(event *tcell.EventKey) *tcell.EventKey {
switch event.Key() { switch event.Key() {
case tcell.KeyEsc: case tcell.KeyEsc:
bus.Emit(ui.ChangeFocusEv{Target: doc.GetElemByID(deviceAPIListID)}) bus.Emit(ui.ChangeFocusEv{Target: doc.GetElemByID(DeviceAPIListID)})
} }
switch event.Rune() { switch event.Rune() {
@@ -198,34 +198,12 @@ func layoutToolTreeViewEvCapture(bus *events.Bus, doc *dom.DOM,
} }
} }
func layoutToolUIOnSelect(bus *events.Bus, doc *dom.DOM) {
bus.Emit(ui.LogEv{Log: "Opening layout tool UI\n"})
var err error
// Get the api pages
apiToolPages := doc.GetElemByID(apiToolPagesID).(*tview.Pages)
if apiToolPages == nil {
bus.Emit(ui.LogEv{Log: " Failed to retrive apiToolPages UI\n"})
return
}
bus.Emit(ui.LogEv{
Log: fmt.Sprintf(" Checking if `%s` UINode already exists\n", layoutToolFlexID),
})
layoutToolUINode := doc.GetNodeByID(layoutToolFlexID)
if layoutToolUINode == nil {
layoutToolUINode, err = buildLayoutFlexComponent(bus, doc)
if err != nil {
bus.Emit(ui.LogEv{
Log: fmt.Sprintf(" Failed to build layout tool UI: %s\n", err.Error()),
})
}
}
AddAndShowPage(bus, doc, apiToolPages, layoutToolUINode, true)
}
func layoutToolTreeViewOnChange(bus *events.Bus, doc *dom.DOM) func(node *tview.TreeNode) { func layoutToolTreeViewOnChange(bus *events.Bus, doc *dom.DOM) func(node *tview.TreeNode) {
// Set focus to our new tool
// if changeFocus {
// bus.Emit(ui.ChangeFocusEv{Target: page.Self})
// }
return func(node *tview.TreeNode) { return func(node *tview.TreeNode) {
// Here we want to change the current existing form on the action pages // Here we want to change the current existing form on the action pages
nodeRef := node.GetReference() nodeRef := node.GetReference()
@@ -240,7 +218,7 @@ func layoutToolTreeViewOnChange(bus *events.Bus, doc *dom.DOM) func(node *tview.
Log: fmt.Sprintf("changing to -> %d | %s\n", nodeWinRef.ID, nodeWinRef.Form.ID), Log: fmt.Sprintf("changing to -> %d | %s\n", nodeWinRef.ID, nodeWinRef.Form.ID),
}) })
pages := doc.GetElemByID(layoutToolActionPagesID) pages := doc.GetElemByID(LayoutToolActionPagesID)
AddAndShowPage(bus, doc, pages.(*tview.Pages), nodeWinRef.Form, false) AddAndShowPage(bus, doc, pages.(*tview.Pages), nodeWinRef.Form, false)
} }
} }
@@ -270,8 +248,8 @@ func buildLayoutTreeComponent(bus *events.Bus, doc *dom.DOM) (*dom.UINode, error
layoutTree.SetChangedFunc(layoutToolTreeViewOnChange(bus, doc)) layoutTree.SetChangedFunc(layoutToolTreeViewOnChange(bus, doc))
layoutTree.SetSelectedFunc(layoutToolTreeViewOnSelect(bus)) layoutTree.SetSelectedFunc(layoutToolTreeViewOnSelect(bus))
layoutTreeUINode, err := doc.NewUINode(layoutToolTreeID, layoutTreeUINode, err := doc.NewUINode(LayoutToolTreeID,
doc.GetElemByID(rightFlexID), layoutTree) doc.GetElemByID(RightFlexID), layoutTree)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -296,9 +274,9 @@ func buildLayoutActionPagesComponent(bus *events.Bus, doc *dom.DOM) (*dom.UINode
emptyPage.SetBorder(true).SetTitle("-- Tool Area --") emptyPage.SetBorder(true).SetTitle("-- Tool Area --")
fmt.Fprintf(emptyPage, "No tool selected") fmt.Fprintf(emptyPage, "No tool selected")
actionPages := tview.NewPages().AddPage(emptyPageName, emptyPage, true, true) actionPages := tview.NewPages().AddPage(EmptyPageName, emptyPage, true, true)
actionPagesUINode, err := doc.NewUINode(layoutToolActionPagesID, actionPagesUINode, err := doc.NewUINode(LayoutToolActionPagesID,
doc.GetElemByID("right-flex"), actionPages) doc.GetElemByID("right-flex"), actionPages)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -321,8 +299,8 @@ func buildLayoutFlexComponent(bus *events.Bus, doc *dom.DOM) (*dom.UINode, error
} }
layoutToolFlex := tview.NewFlex().SetDirection(tview.FlexRow) layoutToolFlex := tview.NewFlex().SetDirection(tview.FlexRow)
layoutToolFlexNode, err := doc.NewUINode(layoutToolFlexID, layoutToolFlexNode, err := doc.NewUINode(LayoutToolFlexID,
doc.GetElemByID(apiToolPagesID), layoutToolFlex) doc.GetElemByID(APIToolPagesID), layoutToolFlex)
if err != nil { if err != nil {
return nil, err return nil, err
} }
+5 -5
View File
@@ -128,7 +128,7 @@ func createNewWindowForm(bus *events.Bus, doc *dom.DOM) {
SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey { SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey {
switch ev.Key() { switch ev.Key() {
case tcell.KeyEscape: case tcell.KeyEscape:
bus.Emit(ui.ChangeFocusEv{Target: doc.GetElemByID(layoutToolFlexID)}) bus.Emit(ui.ChangeFocusEv{Target: doc.GetElemByID(LayoutToolFlexID)})
} }
return ev return ev
@@ -138,13 +138,13 @@ func createNewWindowForm(bus *events.Bus, doc *dom.DOM) {
formNode = doc.GetNodeByID("new-window-form") formNode = doc.GetNodeByID("new-window-form")
if formNode == nil { if formNode == nil {
formNode, err = doc.NewUINode("new-window-form", formNode, err = doc.NewUINode("new-window-form",
doc.GetElemByID(layoutToolActionPagesID), form) doc.GetElemByID(LayoutToolActionPagesID), form)
if err != nil { if err != nil {
panic("failed to create UI node for the new window form: " + err.Error()) panic("failed to create UI node for the new window form: " + err.Error())
} }
} }
AddAndShowPage(bus, doc, doc.GetElemByID(layoutToolActionPagesID).(*tview.Pages), AddAndShowPage(bus, doc, doc.GetElemByID(LayoutToolActionPagesID).(*tview.Pages),
formNode, true) formNode, true)
} }
@@ -234,7 +234,7 @@ func windowInfoForm(bus *events.Bus, doc *dom.DOM, idx int16,
SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey { SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey {
switch ev.Key() { switch ev.Key() {
case tcell.KeyEscape: case tcell.KeyEscape:
bus.Emit(ui.ChangeFocusEv{Target: doc.GetElemByID(layoutToolTreeID)}) bus.Emit(ui.ChangeFocusEv{Target: doc.GetElemByID(LayoutToolTreeID)})
} }
return ev return ev
@@ -264,7 +264,7 @@ func windowInfoForm(bus *events.Bus, doc *dom.DOM, idx int16,
var formNode *dom.UINode var formNode *dom.UINode
elemID := windowInfoPageID(idx) elemID := windowInfoPageID(idx)
formNode = doc.GetNodeByID(elemID) formNode = doc.GetNodeByID(elemID)
layoutToolActionPagesElem := doc.GetElemByID(layoutToolActionPagesID) layoutToolActionPagesElem := doc.GetElemByID(LayoutToolActionPagesID)
if formNode == nil { if formNode == nil {
formNode, err = doc.NewUINode(elemID, layoutToolActionPagesElem, form) formNode, err = doc.NewUINode(elemID, layoutToolActionPagesElem, form)
if err != nil { if err != nil {
@@ -104,7 +104,7 @@ func windowManipulationEvCapture(
switch ev.Key() { switch ev.Key() {
case tcell.KeyEscape: case tcell.KeyEscape:
bus.Emit(ui.ChangeFocusEv{ bus.Emit(ui.ChangeFocusEv{
Target: doc.GetElemByID(layoutToolFlexID), Target: doc.GetElemByID(LayoutToolFlexID),
}) })
return ev return ev
} }
@@ -144,7 +144,7 @@ func windowManipulationTool(bus *events.Bus, doc *dom.DOM, idx int16) {
var boxNode *dom.UINode var boxNode *dom.UINode
// delete the currently existing move-window-box // delete the currently existing move-window-box
actionPages := doc.GetElemByID(layoutToolActionPagesID).(*tview.Pages) actionPages := doc.GetElemByID(LayoutToolActionPagesID).(*tview.Pages)
actionPages.RemovePage("move-window-box") actionPages.RemovePage("move-window-box")
boxNode = doc.GetNodeByID("move-window-box") boxNode = doc.GetNodeByID("move-window-box")
@@ -154,7 +154,7 @@ func windowManipulationTool(bus *events.Bus, doc *dom.DOM, idx int16) {
boxNode, err = doc.NewUINode( boxNode, err = doc.NewUINode(
"move-window-box", "move-window-box",
doc.GetElemByID(layoutToolActionPagesID), doc.GetElemByID(LayoutToolActionPagesID),
box, box,
) )
+66 -63
View File
@@ -5,113 +5,111 @@ import (
"fmt" "fmt"
"esdi/tui/internal/dom" "esdi/tui/internal/dom"
"esdi/tui/internal/events"
"esdi/tui/internal/ui"
"github.com/gdamore/tcell/v2" "github.com/gdamore/tcell/v2"
"github.com/rivo/tview" "github.com/rivo/tview"
) )
const ( const (
mainFlexID = "main-flex" MainFlexID = "main-flex"
apiToolPagesID = "api-tool-pages" APIToolPagesID = "api-tool-pages"
rightFlexID = "right-flex" RightFlexID = "right-flex"
outputPaneID = "output-window" OutputPaneID = "output-window"
deviceAPIListID = "device-api-list" DeviceAPIListID = "device-api-list"
) )
const ( const (
emptyPageName = "empty-page" EmptyPageName = "empty-page"
) )
func buildRightSidePages(bus *events.Bus, doc *dom.DOM) (*dom.UINode, error) { type DeviceAPIToolView struct {
Pages *tview.Pages
ChangedFn func()
}
func NewDeviceAPIToolView() *DeviceAPIToolView {
// We need to build a set of pages with an empty page // We need to build a set of pages with an empty page
emptyPage := tview.NewTextView(). emptyPage := tview.NewTextView().
SetTextAlign(tview.AlignCenter). SetTextAlign(tview.AlignCenter).
SetChangedFunc(func() { SetChangedFunc(func() {
bus.Emit(ui.RedrawEv{}) // bus.Emit(ui.RedrawEv{})
}) })
emptyPage.SetBorder(true).SetTitle("-- Tool Area --") emptyPage.SetBorder(true).SetTitle("-- Tool Area --")
fmt.Fprintf(emptyPage, "No Tool Selected") fmt.Fprintf(emptyPage, "No Tool Selected")
apiToolPages := tview.NewPages().AddPage(emptyPageName, emptyPage, true, true) apiToolPages := tview.NewPages().AddPage(EmptyPageName, emptyPage, true, true)
apiToolPagesNode, err := doc.NewUINode(apiToolPagesID, doc.GetElemByID(rightFlexID), return &DeviceAPIToolView{
apiToolPages) Pages: apiToolPages,
if err != nil { ChangedFn: func() {}, // blank function to be hooked on
return nil, err
} }
return apiToolPagesNode, nil
} }
func buildRightSideFlex(bus *events.Bus, doc *dom.DOM) (*dom.UINode, error) { type DeviceAPIListView struct {
apiToolPagesNode, err := buildRightSidePages(bus, doc) List *tview.List
if err != nil { InputCapture func(*tcell.EventKey) *tcell.EventKey
return nil, err ItemOnSelect func()
}
// This will be the right side flex
flex := tview.NewFlex().SetDirection(tview.FlexRow)
flexNode, err := doc.NewUINode(rightFlexID, doc.GetElemByID(mainFlexID), flex)
if err != nil {
return nil, err
}
// outputWin := doc.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(bus *events.Bus, doc *dom.DOM) (*tview.Flex, error) { func NewDeviceAPIListView() *DeviceAPIListView {
deviceAPIList := tview.NewList().
AddItem("layout", "build a layout for CDashDisplay", 0, func() {
// layoutToolUIOnSelect(bus, doc)
})
deviceAPIList.SetBorder(true).SetTitle("list")
return &DeviceAPIListView{
List: deviceAPIList,
InputCapture: func(ev *tcell.EventKey) *tcell.EventKey { return ev },
ItemOnSelect: func() {}, // blank functions, they have to be hooked on by the controller
}
}
type DeviceAPIView struct {
MainFlex *tview.Flex
DevAPIList *DeviceAPIListView
DevAPIToolView *DeviceAPIToolView
OutputWindow *OutputWinView
}
func (dl *DeviceAPIListView) AddItem(name, description string, onSelect func()) {
dl.List.AddItem(name, description, 0, onSelect)
}
func NewDeviceAPIView(doc *dom.DOM) (*DeviceAPIView, error) {
// To build the main view we must set the DOM root // To build the main view we must set the DOM root
mainFlex := tview.NewFlex().SetDirection(tview.FlexColumn) mainFlex := tview.NewFlex().SetDirection(tview.FlexColumn)
mainFlexUINode, err := doc.NewUINode(mainFlexID, nil, mainFlex) mainFlexUINode, err := doc.NewUINode(MainFlexID, nil, mainFlex)
if err != nil { if err != nil {
return nil, err return nil, err
} }
doc.SetRoot(mainFlexUINode) doc.SetRoot(mainFlexUINode)
deviceAPIList := tview.NewList(). deviceAPIList := NewDeviceAPIListView()
AddItem("layout", "build a layout for CDashDisplay", 0, func() { apiListWindowUINode, err := doc.NewUINode(DeviceAPIListID, doc.GetRootElem(),
layoutToolUIOnSelect(bus, doc) deviceAPIList.List)
})
deviceAPIList.SetBorder(true).SetTitle("list").
SetInputCapture(func(ev *tcell.EventKey) *tcell.EventKey {
switch ev.Rune() {
case 'r':
bus.Emit(ui.FindCDashDisplay{})
}
return ev
})
apiListWindowUINode, err := doc.NewUINode(deviceAPIListID, doc.GetRootElem(),
deviceAPIList)
if err != nil { if err != nil {
return nil, err return nil, err
} }
rightSideFlex, err := buildRightSideFlex(bus, doc) apiToolPages := NewDeviceAPIToolView()
apiToolPagesNode, err := doc.NewUINode(APIToolPagesID, doc.GetElemByID(RightFlexID),
apiToolPages.Pages)
if err != nil { if err != nil {
return nil, err return nil, err
} }
mainFlex. mainFlex.
AddItem(apiListWindowUINode.Self, 0, 1, false). AddItem(apiListWindowUINode.Self, 0, 1, false).
AddItem(rightSideFlex.Self, 0, 4, false) AddItem(apiToolPagesNode.Self, 0, 4, false)
// Output window // Output window
err = BuildOutputWindow(bus, doc)
outputWin := NewOutputWinView()
_, err = doc.NewUINode("output-window", nil, outputWin.TextArea)
if err != nil { if err != nil {
panic("failed to create output window") return nil, err
} }
// Flex with debug window // Flex with debug window
@@ -119,8 +117,13 @@ func BuildMainFlex(bus *events.Bus, doc *dom.DOM) (*tview.Flex, error) {
flexWithOutputWindow := tview.NewFlex().SetDirection(tview.FlexRow) flexWithOutputWindow := tview.NewFlex().SetDirection(tview.FlexRow)
flexWithOutputWindow. flexWithOutputWindow.
AddItem(mainFlex, 0, 5, true). AddItem(mainFlex, 0, 5, true).
AddItem(doc.GetElemByID(outputPaneID), 0, 2, false) AddItem(doc.GetElemByID(OutputPaneID), 0, 2, false)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
return flexWithOutputWindow, nil return &DeviceAPIView{
MainFlex: flexWithOutputWindow,
DevAPIList: deviceAPIList,
DevAPIToolView: apiToolPages,
OutputWindow: outputWin,
}, nil
} }
+16 -22
View File
@@ -1,38 +1,32 @@
package views package views
import ( import (
"esdi/tui/internal/dom"
"esdi/tui/internal/events"
"esdi/tui/internal/ui"
"fmt"
"github.com/rivo/tview" "github.com/rivo/tview"
) )
func bindOutputWindowEvents( // func bindOutputWindowEvents(
bus *events.Bus, // bus *events.Bus,
output *tview.TextView, // output *tview.TextView,
) { // ) {
bus.On(ui.PrintLogEv{}, func(e any) { // bus.On(ui.PrintLogEv{}, func(e any) {
le, _ := e.(ui.PrintLogEv) // le, _ := e.(ui.PrintLogEv)
fmt.Fprintf(output, le.Log) // fmt.Fprintf(output, le.Log)
}) // })
// }
type OutputWinView struct {
TextArea *tview.TextView
} }
func BuildOutputWindow(bus *events.Bus, doc *dom.DOM) error { func NewOutputWinView() *OutputWinView {
var outputWin *tview.TextView var outputWin *tview.TextView
outputWin = tview.NewTextView().SetChangedFunc(func() { outputWin = tview.NewTextView().SetChangedFunc(func() {
bus.Emit(ui.RedrawEv{})
outputWin.ScrollToEnd() outputWin.ScrollToEnd()
}) })
outputWin.SetBorder(true).SetTitle("DebugWindow") outputWin.SetBorder(true).SetTitle("DebugWindow")
_, err := doc.NewUINode("output-window", nil, outputWin)
if err != nil { return &OutputWinView{
return err TextArea: outputWin,
} }
bindOutputWindowEvents(bus, outputWin)
return nil
} }
+2 -2
View File
@@ -42,7 +42,7 @@ func streamingWindow(bus *events.Bus, doc *dom.DOM) {
var boxNode *dom.UINode var boxNode *dom.UINode
// delete the currently existing streaming-box // delete the currently existing streaming-box
actionPages := doc.GetElemByID(layoutToolActionPagesID).(*tview.Pages) actionPages := doc.GetElemByID(LayoutToolActionPagesID).(*tview.Pages)
actionPages.RemovePage(streamingBoxID) actionPages.RemovePage(streamingBoxID)
// Get the currently exisiting streaming box in the dom so we can delete it // Get the currently exisiting streaming box in the dom so we can delete it
@@ -54,7 +54,7 @@ func streamingWindow(bus *events.Bus, doc *dom.DOM) {
// Register this streaming box as an UINode // Register this streaming box as an UINode
boxNode, err = doc.NewUINode( boxNode, err = doc.NewUINode(
streamingBoxID, streamingBoxID,
doc.GetElemByID(layoutToolActionPagesID), doc.GetElemByID(LayoutToolActionPagesID),
box, box,
) )
if err != nil { if err != nil {
+15 -2
View File
@@ -2,10 +2,23 @@
package tui package tui
import ( import (
t "esdi/tui/internal/tui" ctrls "esdi/tui/internal/controllers"
"log/slog" "log/slog"
) )
func Run(logger *slog.Logger) error { func Run(logger *slog.Logger) error {
return t.Start(logger) // // Call the main controller and let the program start!
// return ctrl.Init(logger)
// The app starts running here!
//
// Set the event capture for the global app itself here
mc := ctrls.NewMainController(logger.With("[ctrl]", "main"))
err := mc.Main()
if err != nil {
return err
}
return nil
} }