hack to identify protobuf tables

Makefile

@@ -19,3 +19,4 @@ toolkitConfig.pb.go: toolkitConfig.proto
 
 clean:
 	rm -f go.* *.pb.go
+	go-mod-clean --purge

action.go

@@ -13,27 +13,28 @@ import (
 // everything from the application goes through here
 func (me *TreeInfo) doAction(a widget.Action) {
 	if a.ActionType == widget.ToolkitInit {
-		log.Log(TREEWARN, "tree.doAction() trapped ToolkitInit finally!")
+		log.Log(TREE, "tree.doAction() trapped ToolkitInit finally!")
 		a.WidgetType = widget.Root
-		n := AddNode(&a)
+		n := addNode(&a)
 		me.Add(n)
-		log.Log(TREEWARN, "tree.doAction() init() me.treeRoot")
-		if me.ToolkitInit != nil {
-			log.Log(TREEWARN, "tree.doAction() doing ToolkitInit()")
-			me.ToolkitInit()
-		} else {
-			log.Log(TREEWARN, "tree.doAction() me.ToolkitInit() == nil")
+		log.Log(TREE, "tree.doAction() init() me.treeRoot")
+		if me.ToolkitInit == nil {
+			log.Log(TREE, "tree.doAction() ToolkitInit() was called before plugin had a chance to initialize")
+			log.Log(TREE, "tree.doAction() TODO: fix channel to pause")
+			return
 		}
+		log.Log(TREE, "tree.doAction() doing ToolkitInit()")
+		me.ToolkitInit()
 		return
 	}
 	if a.TablePB != nil {
-		log.Log(TREEWARN, "tree: got a TablePB")
+		log.Log(TREE, "tree: got a TablePB")
 		me.doTable(a)
 		return
 	}
 	if a.WidgetId == 0 {
 		if treeRoot == nil {
-			log.Log(TREEWARN, "tree.doAction() yes, treeRoot is nil. add here")
+			log.Log(TREE, "tree.doAction() yes, treeRoot is nil. add here")
 		}
 	}
 	n := treeRoot.FindWidgetId(a.WidgetId)
@@ -44,6 +45,11 @@ func (me *TreeInfo) doAction(a widget.Action) {
 			me.Add(n)
 			return
 		}
+		if a.WidgetId == 0 {
+			// this is ok. This is the binary tree base and it's already initialized. This happens on startup
+			return
+		}
+		// this shouldn't really happen. It's good to print a warning so the plugin code can be debugged
 		log.Log(TREEWARN, "attempting to re-add widget", a.WidgetId, a.WidgetType, a.ActionType)
 		return
 	}
@@ -133,8 +139,7 @@ func (me *TreeInfo) doAction(a widget.Action) {
 		} else {
 			me.Hide(n)
 		}
-		log.Info("tree: todo: remove child from parent")
-		n.DeleteNode()
+		me.DeleteNode(n)
 		// now remove the child from the parent
 	default:
 		log.Log(TREEWARN, "tree.Action() unknown action", a.ActionType, "on wId", a.WidgetId)

addNode.go

@@ -6,10 +6,15 @@ import (
 )
 
 func (me *TreeInfo) AddNode(a *widget.Action) *Node {
-	return AddNode(a)
+	if me.TryLock() {
+		defer me.Unlock()
+	} else {
+		log.Log(TREE, "mutex lock was already held before AddNode()")
+	}
+	return addNode(a)
 }
 
-func AddNode(a *widget.Action) *Node {
+func addNode(a *widget.Action) *Node {
 	n := new(Node)
 	n.WidgetType = a.WidgetType
 	n.WidgetId = a.WidgetId
@@ -33,9 +38,9 @@ func AddNode(a *widget.Action) *Node {
 	}
 
 	if treeRoot.FindWidgetId(a.WidgetId) != nil {
-		log.Log(TREEWARN, "AddNode() WidgetId already exists", a.WidgetId)
-		log.Log(TREEWARN, "probably this is a Show() / Hide() issue")
-		log.Log(TREEWARN, "TODO: figure out what to do here")
+		// ignore these errors for now
+		log.Log(TREE, "AddNode() WidgetId already exists", a.WidgetId)
+		log.Log(TREE, "TODO: figure out what to do here probably this is a Show() / Hide() issue")
 		return treeRoot.FindWidgetId(a.WidgetId)
 	}
 
@@ -54,8 +59,15 @@ func AddNode(a *widget.Action) *Node {
 	return n
 }
 
-func (n *Node) DeleteNode() {
+func (me *TreeInfo) DeleteNode(n *Node) {
+	log.Log(TREE, "DeleteNode() before lock n =", n.WidgetId, n.GetProgName())
+	if me.TryLock() {
+		defer me.Unlock()
+	} else {
+		log.Info("TREE: mutex lock was already held before DeleteNode()")
+	}
 	p := n.Parent
+	log.Log(TREE, "DeleteNode() parent =", p.WidgetId, p.GetProgName())
 	for i, child := range p.children {
 		log.Log(TREE, "parent has child:", i, child.WidgetId, child.GetProgName())
 		if n == child {

date.go

@@ -0,0 +1,39 @@
+package tree
+
+import (
+	"time"
+)
+
+// TODO; let the user choose the date format
+func MakeDatestamp(t time.Time) string {
+	/*
+		// Get system locale from the environment
+		locale := os.Getenv("LANG")
+		if locale == "" {
+			locale = "en_US" // Default to English (US) if not set
+		}
+
+		// Parse the language tag
+		tag, err := language.Parse(locale)
+		if err != nil {
+			log.Fatalf("Invalid locale: %v", err)
+		}
+
+		// Create a date formatter
+		formatter := date.NewFormatter(date.OrderDefault, catalog.NewBuilder())
+
+		// Get the current timestamp
+		now := time.Now()
+
+		// Format the date based on the locale
+		p := message.NewPrinter(tag)
+		formattedDate := formatter.Format(tag, now)
+
+		// Print the formatted date
+		fmt.Println("Formatted Date:", formattedDate)
+
+		// Alternative: Use predefined time formats
+		fmt.Println("Localized Date (fallback):", p.Sprintf("%v", now.Format(time.RFC1123)))
+	*/
+	return t.Format(time.RFC1123)
+}

find.go

@@ -0,0 +1,63 @@
+package tree
+
+import "log"
+
+// find things in the tree
+// also verify parent <-> child mappings aren't a lie
+
+// searches the binary tree for a WidgetId
+func FindWidgetId(id int) *Node {
+	return treeRoot.FindWidgetId(id)
+}
+
+func FindWidgetById(id int) *Node {
+	return treeRoot.FindWidgetId(id)
+}
+
+// searches the binary tree for a WidgetId
+func (n *Node) FindWidgetId(id int) *Node {
+	if n == nil {
+		return nil
+	}
+
+	if n.WidgetId == id {
+		return n
+	}
+
+	for _, child := range n.children {
+		newN := child.FindWidgetId(id)
+		if newN != nil {
+			return newN
+		}
+	}
+	return nil
+}
+
+// used for debugging the 'gui' package
+// to make sure things are valid
+// fixes any errors along the way
+func (me *Node) VerifyParentId() bool {
+	return me.verifyParentId(0)
+}
+
+func (n *Node) verifyParentId(parentId int) bool {
+	if n == nil {
+		return false
+	}
+	var ok bool = true
+
+	if n.ParentId != parentId {
+		log.Printf("fixed widgetId %d from %d to %d", n.WidgetId, n.ParentId, parentId)
+		n.ParentId = parentId
+		ok = false
+	}
+
+	for _, child := range n.children {
+		if child.verifyParentId(n.WidgetId) {
+			// everything is ok
+		} else {
+			ok = false
+		}
+	}
+	return ok
+}

init.go

@@ -68,7 +68,30 @@ func (t *TreeInfo) ConfigFind(n string) (string, error) {
 		if n == r.Name {
 			return r.Value, nil
 		}
-		log.Info("toolkit config", r.Plugin, r.Name, r.Value, n)
+		// log.Info("toolkit config no-match on", r.Plugin, r.Name, r.Value, n)
 	}
 	return "", fmt.Errorf("toolkit config %s not found", n)
 }
+
+func (t *TreeInfo) ConfigSave(o *ToolkitConfig) {
+	t.configInsert(o)
+	t.config.configSave()
+}
+
+// update the config option value (or append if new record)
+func (t *TreeInfo) configInsert(newr *ToolkitConfig) {
+	all := t.config.All() // get the list of repos
+	for all.Scan() {
+		r := all.Next()
+		if t.PluginName != r.Plugin {
+			// option isn't for this plugin
+			continue
+		}
+		if newr.Name == r.Name {
+			// found the record!
+			r.Value = newr.Value
+			return
+		}
+	}
+	t.config.Append(newr)
+}

plugin.go

@@ -16,30 +16,6 @@ import (
 	"go.wit.com/widget"
 )
 
-// searches the binary tree for a WidgetId
-func FindWidgetId(id int) *Node {
-	return treeRoot.FindWidgetId(id)
-}
-
-// searches the binary tree for a WidgetId
-func (n *Node) FindWidgetId(id int) *Node {
-	if n == nil {
-		return nil
-	}
-
-	if n.WidgetId == id {
-		return n
-	}
-
-	for _, child := range n.children {
-		newN := child.FindWidgetId(id)
-		if newN != nil {
-			return newN
-		}
-	}
-	return nil
-}
-
 func (me *TreeInfo) InitOK() {
 	me.ok = true
 }

structs.go

@@ -20,29 +20,28 @@ import (
 var treeRoot *Node
 
 type TreeInfo struct {
-	sync.Mutex                       // a lock around the tree to serialize access
-	ok           bool                // indicates the plugin actually initialized
-	PluginName   string              // used to identify the plugin
-	config       *ToolkitConfigs     // protobuf of plugin settings
-	callback     chan widget.Action  // mouse clicks or keyboard events back to the program
-	pluginChan   chan widget.Action  // this is the channel we get requests to make widgets
-	frozenChan   chan widget.Action  // expirement to get fyne to work
-	Add          func(*Node)         // add a new widget
-	AddText      func(*Node, string) // add a string to a dropdown widget
-	SetText      func(*Node, string) // set the text of a widget
-	SetTitle     func(*Node, string) // update the title of a window or tab
-	SetLabel     func(*Node, string) // update the "label" (aka "Name") for a widget
-	SetChecked   func(*Node, bool)   // set the state of a checkbox
-	ToolkitInit  func()              // init the plugin
-	ToolkitClose func()              // shutdown and unload the plugin
-	Show         func(*Node)         // show a widget
-	Hide         func(*Node)         // hide a widget
-	Enable       func(*Node)         // enable a widget
-	Disable      func(*Node)         // disable a widget
-	ShowTable    func(*guipb.Table)  // attempt at sending a whole table
-	// NodeI             interface{} // is an interface useful here?
-	// NodeAction   func(*Node, widget.ActionType) // deprecate
-	currentTables []*guipb.Table
+	sync.Mutex                        // a lock around the tree to serialize access
+	ok            bool                // indicates the plugin actually initialized
+	PluginName    string              // used to identify the plugin
+	config        *ToolkitConfigs     // protobuf of plugin settings
+	callback      chan widget.Action  // mouse clicks or keyboard events back to the program
+	pluginChan    chan widget.Action  // this is the channel we get requests to make widgets
+	frozenChan    chan widget.Action  // expirement to get fyne to work
+	Add           func(*Node)         // add a new widget
+	AddText       func(*Node, string) // add a string to a dropdown widget
+	SetText       func(*Node, string) // set the text of a widget
+	SetTitle      func(*Node, string) // update the title of a window or tab
+	SetLabel      func(*Node, string) // update the "label" (aka "Name") for a widget
+	SetChecked    func(*Node, bool)   // set the state of a checkbox
+	ToolkitInit   func()              // init the plugin
+	ToolkitClose  func()              // shutdown and unload the plugin
+	Show          func(*Node)         // show a widget
+	Hide          func(*Node)         // hide a widget
+	Enable        func(*Node)         // enable a widget
+	Disable       func(*Node)         // disable a widget
+	ShowTable     func(*guipb.Table)  // attempt at sending a whole table
+	currentTables []*guipb.Table      // track the list of tables?
+	Root          *guipb.Tree         // this is the future of this system
 }
 
 type Node struct {

table.go

@@ -17,12 +17,6 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
-// repeated string      order          = 1;
-//
-// repeated StringRow   StringRows     = 2;
-// repeated IntRow      IntRows        = 3;
-// repeated TimeRow     TimeRows       = 4;
-// repeated BoolRow     BoolRows       = 5;
 func (me *TreeInfo) doTable(a widget.Action) {
 	if a.TablePB == nil {
 		log.Log(TREE, "tree: action didn't have a Table PB")
@@ -34,9 +28,7 @@ func (me *TreeInfo) doTable(a widget.Action) {
 		return
 	}
 	log.Info("tree.doTables() start. # of tables:", len(pb.Tables))
-	all := pb.All()
-	for all.Scan() {
-		t := all.Next()
+	for t := range pb.IterAll() {
 		// for i, o := range t.Order {
 		// 	log.Info("got order:", t.Title, i, o)
 		// }
@@ -46,37 +38,34 @@ func (me *TreeInfo) doTable(a widget.Action) {
 		for i, ot := range me.currentTables {
 			// log.Info("TREE already has UUID", i, ot.Uuid)
 			if t.Uuid == ot.Uuid {
-				log.Info("TREE found UUID! update table here", i, ot.Uuid)
+				log.Log(TREE, "TREE found UUID! update table here", i, ot.Uuid)
+				if ot.Grid == nil {
+					log.Log(TREE, "TREE found UUID! ot.grid.Id = nil. need to find grid id here")
+					return
+				} else {
+					log.Log(TREE, "TREE found UUID! grid.Id =", ot.Grid.Id)
+					t.Grid = ot.Grid
+				}
+				if t.Grid == nil {
+					log.Log(TREE, "TREE found UUID! grid.Id = nil. need to find grid id here")
+					return
+				}
+				log.Log(TREE, "TREE found UUID! update table here", i, ot.Uuid, "grid.Id =", t.Grid.Id)
 				me.updateTable(t)
 				return
 			}
 		}
 
 		me.currentTables = append(me.currentTables, t)
+		if t.Grid == nil {
+			log.Log(TREEWARN, "new table error: grid.Id = nil need to set grid id here")
+		} else {
+			// log.Info("NEW TREE: grid.Id =", t.Grid.Id)
+		}
 		me.makeTable(t)
 	}
 }
 
-func makeTableWindow(pb *guipb.Widget) *Node {
-	a := new(widget.Action)
-	a.WidgetType = widget.Window
-	a.WidgetId = int(pb.Id)
-	a.ParentId = 0
-	a.State.Enable = true
-
-	return AddNode(a)
-}
-
-func (win *Node) makeWindowGrid(pb *guipb.Widget) *Node {
-	a := new(widget.Action)
-	a.WidgetType = widget.Grid
-	a.WidgetId = int(pb.Id)
-	a.ParentId = win.WidgetId
-	a.State.Enable = true
-
-	return AddNode(a)
-}
-
 func (grid *Node) makeGridLabel(pb *guipb.Widget, w int, h int) *Node {
 	a := new(widget.Action)
 	a.WidgetType = widget.Label
@@ -89,16 +78,50 @@ func (grid *Node) makeGridLabel(pb *guipb.Widget, w int, h int) *Node {
 	a.State.GridOffset.X = w
 	a.State.GridOffset.Y = h
 	// log.Info("makeGridLabel()", a.State)
-	return AddNode(a)
+	return addNode(a)
+}
+
+func (grid *Node) makeGridButton(pb *guipb.Widget, w int, h int) *Node {
+	a := new(widget.Action)
+	a.WidgetType = widget.Button
+	a.WidgetId = int(pb.Id)
+	a.ParentId = grid.WidgetId
+	a.State.Enable = true
+	a.State.Label = pb.Name
+	a.State.AtW = w
+	a.State.AtH = h
+	a.State.GridOffset.X = w
+	a.State.GridOffset.Y = h
+	// log.Info("makeGridLabel()", a.State)
+	return addNode(a)
 }
 
 func (me *TreeInfo) updateTable(t *guipb.Table) {
-	// log.Info("todo: compare table here...")
+	grid := FindWidgetId(int(t.Grid.Id))
+	if grid == nil {
+		log.Info("tree: updateTable() failed to make grid")
+		return
+	}
+	// delete the existing table
+	me.DeleteNode(grid)
+
+	// remake the table
+	me.Add(grid)
+	var h int = 0
+	var w int = 0
 	for _, name := range t.Order {
-		me.updateRow(t, name)
+		// log.Info("got order:", t.Title, name)
+		if me.addTableRow(t, grid, name, w) {
+			// log.Info("tree:row() COLUMN GOOD", t.Title, name, w, h)
+		} else {
+			log.Info("tree:row() COLOMN FAIL", t.Title, name, w, h)
+		}
+
+		w += 1
 	}
 }
 
+/*
 func (me *TreeInfo) updateRow(t *guipb.Table, name string) {
 	for _, r := range t.StringRows {
 		if name == r.Header.Name {
@@ -160,29 +183,25 @@ func (me *TreeInfo) updateRow(t *guipb.Table, name string) {
 		return
 	}
 }
+*/
 
 func (me *TreeInfo) makeTable(t *guipb.Table) {
 	var grid *Node
-	if t.Window != nil {
-		// deprecate this early hack
-		win := makeTableWindow(t.Window)
-		me.Add(win)
-		win.makeWindowGrid(t.Grid)
-	}
 	if t.Parent != nil {
 		a := new(widget.Action)
 		a.WidgetType = widget.Grid
 		a.WidgetId = int(t.Grid.Id)
 		a.ParentId = int(t.Parent.Id)
 		a.State.Enable = true
-		grid = AddNode(a)
+		grid = addNode(a)
 	}
 	if grid == nil {
-		log.Info("tree: makeTable() failed to make grid")
+		log.Log(TREEWARN, "tree: makeTable() failed to make grid")
 		return
 	}
 	me.Add(grid)
-	log.Info("tree: makeTable() finished add win & grid")
+	grid.State.ProgName = "TableGridPB"
+	// log.Info("tree: makeTable() finished add win & grid")
 	var h int = 0
 	var w int = 0
 	for _, name := range t.Order {
@@ -190,23 +209,11 @@ func (me *TreeInfo) makeTable(t *guipb.Table) {
 		if me.addTableRow(t, grid, name, w) {
 			// log.Info("tree:row() COLUMN GOOD", t.Title, name, w, h)
 		} else {
-			log.Info("tree:row() COLOMN FAIL", t.Title, name, w, h)
+			log.Log(TREEWARN, "tree:row() COLOMN FAIL", t.Title, name, w, h)
 		}
 
 		w += 1
 	}
-
-	/*
-		for i, r := range t.StringRows {
-			log.Info("got string row:", t.Title, i, r.Header, r.Vals)
-			for _, v := range r.Widgets {
-				log.Info("tree: add to grid here", v.Id, v.Name)
-				lab := grid.makeGridLabel(v, w, h)
-				me.Add(lab)
-				h += 1
-			}
-		}
-	*/
 }
 
 func (me *TreeInfo) addTableRow(t *guipb.Table, grid *Node, name string, w int) bool {
@@ -229,6 +236,24 @@ func (me *TreeInfo) addTableRow(t *guipb.Table, grid *Node, name string, w int)
 		return true
 	}
 
+	for _, r := range t.ButtonRows {
+		if name != r.Header.Name {
+			// log.Info("skip string row:", r.Header.Name, "!=", name)
+			continue
+		}
+		// log.Info("tree: Add()ing to grid here", r.Header.Id, r.Header.Name, w, h)
+		head := grid.makeGridLabel(r.Header, w, h)
+		me.Add(head)
+		h += 1
+		for _, v := range r.Widgets {
+			// log.Info("tree: Add()ing to grid here", v.Id, v.Name, w, h)
+			lab := grid.makeGridButton(v, w, h)
+			me.Add(lab)
+			h += 1
+		}
+		return true
+	}
+
 	for _, r := range t.IntRows {
 		if name != r.Header.Name {
 			// log.Info("skip sint row:", r.Header.Name, "!=", name)
@@ -283,6 +308,22 @@ func (me *TreeInfo) addTableRow(t *guipb.Table, grid *Node, name string, w int)
 	return false
 }
 
+// returns true if widget is in a table
+func (n *Node) InTable() bool {
+	// log.Info("InTable() parent id =", n.ParentId)
+	grid := FindWidgetById(int(n.ParentId))
+	if grid != nil {
+		if grid.WidgetType == widget.Grid {
+			if grid.State.ProgName == "TableGridPB" {
+				// this is a protobuf table
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
 func dumpTable(t *guipb.Table) {
 	for i, o := range t.Order {
 		log.Info("got order:", t.Title, i, o)

toolkitConfig.proto

@@ -7,8 +7,8 @@ package forgepb;
 import "google/protobuf/timestamp.proto"; // Import the well-known type for Timestamp
 
 message ToolkitConfig {                                   //
-        string                   plugin             = 1;  // 'gocui', 'andlabs', etc
-        string                   name               = 2;  // variable name 'fullscreen'
+        string                   plugin             = 1;  // 'gocui', 'andlabs', etc `autogenpb:unique`
+        string                   name               = 2;  // variable name 'fullscreen' `autogenpb:unique`
         string                   value              = 3;  // value "true"
 }