.gitignore

@@ -1,4 +0,0 @@
-*.swp
-go.sum
-go.mod
-*.pb.go

LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Makefile

@@ -1,8 +1,7 @@
-redo: proto goimports vet
+all:
-
+	@echo
-vet:
+	@echo "Run: make redomod    # to remake the go files"
-	@GO111MODULE=off go vet
+	@echo
-	@echo this go library builds okay
 
 redomod: goimports
 	rm -f go.*
@@ -11,12 +10,3 @@ redomod: goimports
 
 goimports:
 	goimports -w *.go
-
-proto: toolkitConfig.pb.go
-
-toolkitConfig.pb.go: toolkitConfig.proto
-	autogenpb --proto toolkitConfig.proto
-
-clean:
-	rm -f go.* *.pb.go
-	go-mod-clean --purge

action.go

@@ -1,166 +0,0 @@
-// Although most code from WIT.COM Inc is under the GPL
-// This code is more generic because it must be able
-// to be used in any GUI plugin
-
-package tree
-
-import (
-	"go.wit.com/lib/protobuf/guipb"
-	"go.wit.com/log"
-	"go.wit.com/widget"
-)
-
-// everything from the application goes through here
-func (me *TreeInfo) doAction(a widget.Action) {
-	if a.ActionType == widget.ToolkitInit {
-		log.Log(TREE, "tree.doAction() trapped ToolkitInit finally!")
-		a.WidgetType = widget.Root
-		n := addNode(&a)
-		me.Add(n)
-		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(TREE, "tree: got a TablePB")
-		me.doTable(a)
-		return
-	}
-	if a.WidgetId == 0 {
-		if treeRoot == nil {
-			log.Log(TREE, "tree.doAction() yes, treeRoot is nil. add here")
-		}
-	}
-	n := treeRoot.FindWidgetId(a.WidgetId)
-	switch a.ActionType {
-	case widget.Add:
-		if n == nil {
-			n := me.AddNode(&a)
-			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
-	}
-	if n == nil {
-		// log.Log(TREEWARN, "tree.FindWidgetId() n == nil", a.WidgetId, a.WidgetType, a.ActionType)
-		// log.Log(TREEWARN, "tree.FindWidgetId() n == nil", a.State.CurrentS)
-		// log.Log(TREEWARN, "tree.FindWidgetId() n == nil. A bug in your application?")
-		log.Log(TREEWARN, "tree.doAction() bug in gui. trying to do action", a.ActionType, "before widget init() wId =", a.WidgetId)
-		if a.WidgetId == 0 {
-			log.Log(TREEWARN, "tree.doAction() bug in gui. on wId zero. is treeRoot nil?")
-			if treeRoot == nil {
-				log.Log(TREEWARN, "tree.doAction() yes, treeRoot is nil")
-			}
-		}
-		return
-	}
-
-	switch a.ActionType {
-	case widget.SetText:
-		log.Log(TREE, "tree.SetText() a.State.CurrentS =", a.State.CurrentS)
-		log.Log(TREE, "tree.SetText() a.State.DefaultS =", a.State.DefaultS)
-		log.Log(TREE, "tree.SetText() a.State.NewString =", a.State.NewString)
-		switch n.WidgetType {
-		case widget.Dropdown:
-			me.SetText(n, a.State.NewString)
-		case widget.Combobox:
-			me.SetText(n, a.State.NewString)
-		case widget.Textbox:
-			me.SetText(n, a.State.NewString)
-		case widget.Window:
-			me.SetTitle(n, a.State.Label)
-		default:
-			// buttons, checkboxes, groups, etc
-			me.SetLabel(n, a.State.Label)
-		}
-	case widget.AddText:
-		switch n.WidgetType {
-		case widget.Dropdown:
-			n.ddStrings = append(n.ddStrings, a.State.NewString)
-			me.AddText(n, a.State.NewString)
-		case widget.Combobox:
-			n.ddStrings = append(n.ddStrings, a.State.NewString)
-			me.AddText(n, a.State.NewString)
-		default:
-			log.Log(TREEWARN, "AddText() not supported on widget", n.WidgetType, n.String())
-		}
-	case widget.Checked:
-		switch n.WidgetType {
-		case widget.Checkbox:
-			if me.SetChecked == nil {
-				log.Log(TREEWARN, "SetChecked() == nil in toolkit", me.PluginName)
-			} else {
-				me.SetChecked(n, a.State.Checked)
-			}
-		default:
-			log.Log(TREEWARN, "SetChecked() not supported on widget", n.WidgetType, n.String())
-		}
-	case widget.Show:
-		if n.WidgetType == widget.Table {
-			t, err := loadTable(&a)
-			if err != nil {
-				log.Info("unmarshal data failed", err)
-				return
-			}
-			if t == nil {
-				log.Info("unmarshal data failed table == nil")
-			} else {
-				me.ShowTable(nil)
-			}
-		} else {
-			n.State.Hidden = false
-			me.Show(n)
-		}
-	case widget.Hide:
-		n.State.Hidden = true
-		me.Hide(n)
-		log.Info("tree: doing hide here on", a.WidgetId, n.WidgetType)
-	case widget.Enable:
-		n.State.Enable = true
-		me.Enable(n)
-	case widget.Disable:
-		n.State.Enable = false
-		me.Disable(n)
-	case widget.Delete:
-		if me.Hide == nil {
-			log.Info("toolkit doesn't know how to Hide() widgets")
-		} else {
-			me.Hide(n)
-		}
-		me.DeleteNode(n)
-		// now remove the child from the parent
-	default:
-		log.Log(TREEWARN, "tree.Action() unknown action", a.ActionType, "on wId", a.WidgetId)
-		// me.NodeAction(n, a.ActionType)
-	}
-}
-
-func loadTable(a *widget.Action) (*guipb.Tables, error) {
-	var t *guipb.Tables
-	err := t.Unmarshal(a.TablePB)
-	/*
-		test := NewRepos()
-		if test.Uuid != all.Uuid {
-			log.Log(WARN, "uuids do not match", test.Uuid, all.Uuid)
-			deleteProtobufFile(cfgname)
-		}
-		if test.Version != all.Version {
-			log.Log(WARN, "versions do not match", test.Version, all.Version)
-			deleteProtobufFile(cfgname)
-		}
-	*/
-	// log.Log(INFO, cfgname, "protobuf versions and uuid match", all.Uuid, all.Version)
-	return t, err
-}

addNode.go

@@ -5,47 +5,32 @@ import (
 	"go.wit.com/widget"
 )
 
+// this is in common.go, do not move it
 func (me *TreeInfo) AddNode(a *widget.Action) *Node {
-	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 {
 	n := new(Node)
 	n.WidgetType = a.WidgetType
 	n.WidgetId = a.WidgetId
 	n.ParentId = a.ParentId
 
 	n.State = a.State
-	n.State.Enable = a.State.Enable
+	n.Strings = make(map[string]int)
-	// n.Strings = make(map[string]int)
-	// slices.Reverse(lines)
-	// dropdown strings
-	n.ddStrings = make([]string, 0)
-	for _, s := range a.State.Strings {
-		n.ddStrings = append(n.ddStrings, s)
-	}
 
 	if a.WidgetType == widget.Root {
 		log.Log(TREE, "AddNode() Root")
 		n.Parent = n
-		treeRoot = n
+		me.treeRoot = n
 		return n
 	}
 
-	if treeRoot.FindWidgetId(a.WidgetId) != nil {
+	if me.treeRoot.FindWidgetId(a.WidgetId) != nil {
-		// ignore these errors for now
+		log.Warn("AddNode() WidgetId already exists", a.WidgetId)
-		log.Log(TREE, "AddNode() WidgetId already exists", a.WidgetId)
+		log.Warn("probably this is a Show() / Hide() issue")
-		log.Log(TREE, "TODO: figure out what to do here probably this is a Show() / Hide() issue")
+		log.Warn("TODO: figure out what to do here")
-		return treeRoot.FindWidgetId(a.WidgetId)
+		return me.treeRoot.FindWidgetId(a.WidgetId)
 	}
 
 	// add this new widget on the binary tree
-	p := treeRoot.FindWidgetId(a.ParentId)
+	p := me.treeRoot.FindWidgetId(a.ParentId)
 	n.Parent = p
 	if n.Parent == nil {
 		log.Log(TREEWARN, "AddNode() ERROR n.Parent == nil n =", n.WidgetId, n.WidgetType, n.GetProgName())
@@ -59,15 +44,8 @@ func addNode(a *widget.Action) *Node {
 	return n
 }
 
-func (me *TreeInfo) DeleteNode(n *Node) {
+func (n *Node) DeleteNode() {
-	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 {

common.go

@@ -1,7 +1,6 @@
 package tree
 
 import (
-	"go.wit.com/log"
 	"go.wit.com/widget"
 )
 
@@ -9,83 +8,27 @@ func (n *Node) GetProgName() string {
 	return n.State.ProgName
 }
 
-/*
 func (n *Node) GetValue() any {
 	return n.State.Value
 }
-*/
 
 func (n *Node) Bool() bool {
-	return false // widget.GetBool(n.State.Value)
+	return widget.GetBool(n.State.Value)
-}
-
-func (n *Node) CurrentS() string {
-	return n.State.CurrentS
-}
-
-func (n *Node) Strings() []string {
-	return n.ddStrings
 }
 
 func (n *Node) String() string {
-	switch n.WidgetType {
+	return widget.GetString(n.State.Value)
-	case widget.Button:
-		return n.State.Label
-	case widget.Window:
-		return n.State.Label
-	case widget.Checkbox:
-		return n.State.Label
-	case widget.Group:
-		return n.State.Label
-	case widget.Label:
-		return n.State.Label
-	case widget.Dropdown:
-		return n.State.CurrentS
-	case widget.Combobox:
-		return n.State.CurrentS
-	}
-	log.Log(TREE, "do not know how to do String() on widget type", n.WidgetType)
-	return ""
-}
-
-func (n *Node) ProgName() string {
-	return n.State.ProgName
-}
-
-func (n *Node) Hidden() bool {
-	/*
-		if n.Parent == nil {
-			return n.Hidden()
-		}
-		if n.Parent.WidgetId == 0 {
-			return n.Hidden()
-		}
-		if n.Parent.Hidden() {
-			return true
-		}
-	*/
-	return n.State.Hidden
-}
-
-func (n *Node) IsEnabled() bool {
-	return n.State.Enable
 }
 
 /* avoid this function name as confusing
-func (n *Node) GetText() string { // BAD
+func (n *Node) GetText() string {
 	return widget.GetString(n.State.Value)
 }
 */
 
-/*
+func (n *Node) SetValue(a any) {
-func (n *Node) SetValue(a any) { // BAD
 	n.State.Value = a
 }
-*/
-
-func (n *Node) SetCurrentS(s string) {
-	n.State.CurrentS = s
-}
 
 func (n *Node) GetLabel() string {
 	return n.State.Label

date.go

@@ -1,39 +0,0 @@
-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)
-}

debug.go

@@ -1,16 +1,10 @@
 package tree
 
 import (
-	"fmt"
-
 	"go.wit.com/log"
 	"go.wit.com/widget"
 )
 
-func ShowButtons() {
-	treeRoot.ShowButtons()
-}
-
 func (n *Node) ShowButtons() {
 	if n.WidgetType == widget.Button {
 		n.DumpWidget("Button:")
@@ -22,37 +16,16 @@ func (n *Node) ShowButtons() {
 }
 
 func (n *Node) DumpWidget(pad string) {
-	s := n.GetProgName()
+	log.Warn("node:", pad, n.WidgetId, ",", n.WidgetType, ",", n.GetProgName())
-	if s == "" {
-		s = n.CurrentS()
-	}
-	if s == "" {
-		s = n.String()
-	}
-	if s == "" {
-		s = n.ProgName()
-	}
-	if s == "" {
-		s = n.GetLabel()
-	}
-	if s == "" {
-		s = n.State.NewString
-	}
-	end := fmt.Sprintf("%d,%-9s .%s.", n.WidgetId, n.WidgetType, s)
-	log.Log(TREEWARN, "node:", pad, end)
 }
 
 var depth int = 0
 
-func ListWidgets() {
-	treeRoot.ListWidgets()
-}
-
 func (n *Node) ListWidgets() {
 	if n == nil {
-		log.Log(TREEWARN, "ERRRORRRR: n == nil in ListWidgets()")
+		log.Warn("ERRRORRRR: n == nil in ListWidgets()")
-		log.Log(TREEWARN, "ERRRORRRR: n == nil in ListWidgets()")
+		log.Warn("ERRRORRRR: n == nil in ListWidgets()")
-		log.Log(TREEWARN, "ERRRORRRR: n == nil in ListWidgets()")
+		log.Warn("ERRRORRRR: n == nil in ListWidgets()")
 		return
 	}
 

event.go

@@ -18,7 +18,7 @@ import (
 
 func (me *TreeInfo) SendEnableDebugger() {
 	if me.callback == nil {
-		log.Log(TREEWARN, "SendEnableDebugger() callback == nil")
+		log.Warn("SendUserEvent() toolkit panic() callback == nil")
 		return
 	}
 	var a widget.Action
@@ -30,74 +30,61 @@ func (me *TreeInfo) SendEnableDebugger() {
 
 func (me *TreeInfo) SendToolkitLoad(s string) {
 	if me.callback == nil {
-		log.Log(TREEWARN, "SendToolkitLoad() callback == nil")
+		log.Warn("SendUserEvent() toolkit load callback == nil")
 		return
 	}
-	log.Log(TREEWARN, "SendToolkitLoad() START: toolkit load", s)
 	var a widget.Action
 	a.ActionType = widget.ToolkitLoad
-	a.Value = s
 	a.ProgName = me.PluginName
+	a.Value = s
+	log.Warn("SendUserEvent() START: toolkit load", s)
 	me.callback <- a
-	log.Log(TREEWARN, "SendToolkitLoad() END:   toolkit load", s)
+	log.Warn("SendUserEvent() END:   toolkit load", s)
 	return
 }
 
 func (me *TreeInfo) SendToolkitPanic() {
 	if me.callback == nil {
-		log.Log(TREEWARN, "SendToolkitPanic() callback == nil")
+		log.Warn("SendUserEvent() toolkit panic() callback == nil")
 		return
 	}
-	log.Log(TREEWARN, "SendToolkitPanic() START")
 	var a widget.Action
 	a.ActionType = widget.ToolkitPanic
 	a.ProgName = me.PluginName
+	log.Log(TREE, "SendUserEvent() START: toolkit panic()")
 	me.callback <- a
-	log.Log(TREEWARN, "SendToolkitPanic() END")
+	log.Log(TREE, "SendUserEvent() END:   toolkit panic()")
 	return
 }
 
 func (me *TreeInfo) SendWindowCloseEvent(n *Node) {
 	if me.callback == nil {
-		log.Log(TREEWARN, "SendWindowClose() callback == nil", n.WidgetId)
+		log.Warn("SendUserEvent() callback == nil", n.WidgetId)
 		return
 	}
-	log.Log(TREE, "SendWindowClose() START: user closed the window", n.GetProgName())
 	var a widget.Action
 	a.WidgetId = n.WidgetId
 	a.ActionType = widget.CloseWindow
-	a.ProgName = me.PluginName
+	log.Log(TREE, "SendUserEvent() START: user closed the window", n.GetProgName())
 	me.callback <- a
-	log.Log(TREE, "SendWindowClose() END:   user closed the window", n.GetProgName())
+	log.Log(TREE, "SendUserEvent() END:   user closed the window", n.GetProgName())
 	return
 }
 
-// this name is better, but I can't use it
-// is multiple toolkit support worth this sacrifice?
-// func (n *Node) SendWidgetEvent() {
-// }
-
-// The user clicked on something. Or typed something
-func (me *TreeInfo) SendWidgetEvent(n *Node) {
-	me.SendUserEvent(n)
-}
-
-func (me *TreeInfo) SendFromUser(n *Node) {
-	me.SendUserEvent(n)
-}
-
 // Other goroutines must use this to access the GUI
 func (me *TreeInfo) SendUserEvent(n *Node) {
 	if me.callback == nil {
-		log.Log(TREEWARN, "SendUserEvent() callback == nil", n.WidgetId)
+		log.Warn("SendUserEvent() callback == nil", n.WidgetId)
 		return
 	}
-	log.Log(TREE, "SendUserEvent() START: send a user event to the callback channel")
 	var a widget.Action
 	a.WidgetId = n.WidgetId
-	a.State = n.State
+	a.Value = n.State.Value
 	a.ActionType = widget.User
-	a.ProgName = me.PluginName
+	if n.WidgetType == widget.Checkbox {
+		log.Log(TREE, "SendUserEvent() checkbox going to send:", a.Value)
+	}
+	log.Log(TREE, "SendUserEvent() START: send a user event to the callback channel")
 	me.callback <- a
 	log.Log(TREE, "SendUserEvent() END:   sent a user event to the callback channel")
 	return

find.go

@@ -1,63 +0,0 @@
-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
-}

go.mod

@@ -0,0 +1,10 @@
+module go.wit.com/toolkits/tree
+
+go 1.21.4
+
+require (
+	go.wit.com/log v0.13.18
+	go.wit.com/widget v1.1.10
+)
+
+require go.wit.com/dev/davecgh/spew v1.1.4 // indirect

go.sum

@@ -0,0 +1,6 @@
+go.wit.com/dev/davecgh/spew v1.1.4 h1:C9hj/rjlUpdK+E6aroyLjCbS5MFcyNUOuP1ICLWdNek=
+go.wit.com/dev/davecgh/spew v1.1.4/go.mod h1:sihvWmnQ/09FWplnEmozt90CCVqBtGuPXM811tgfhFA=
+go.wit.com/log v0.13.18 h1:XJNaQWX+8m12p3mH+kYih3zNjb0kScZDFpJa4c2TvKE=
+go.wit.com/log v0.13.18/go.mod h1:BaJBfHFqcJSJLXGQ9RHi3XVhPgsStxSMZRlaRxW4kAo=
+go.wit.com/widget v1.1.10 h1:bdEqqNZMlLc+T4dHKlkQG1c1N5I+x2RUewOlrn2GWng=
+go.wit.com/widget v1.1.10/go.mod h1:I8tnD3x3ECbB/CRNnLCdC+uoyk7rK0AEkzK1bQYSqoQ=

init.go

@@ -1,13 +1,7 @@
-// Although most code from WIT.COM Inc is under the GPL
-// This code is more generic because it must be able
-// to be used in any GUI plugin
-
 package tree
 
 import (
-	"fmt"
+	"errors"
-	"os"
-	"runtime/debug"
 	"sync"
 
 	"go.wit.com/log"
@@ -19,14 +13,9 @@ var muAction sync.Mutex
 func (me *TreeInfo) catchActionChannel() {
 	defer func() {
 		if r := recover(); r != nil {
-			log.Log(TREEWARN, "YAHOOOO. Recovered in tree.catchActionChannel()", r)
+			log.Warn(me.PluginName, "tree YAHOOOO Recovered in simpleStdin()", r)
-			log.Log(TREEWARN, "YAHOOOO. Recovered in tree.catchActionChannel() Plugin:", me.PluginName)
 			me.SendToolkitPanic()
-			debug.PrintStack()
+			panic(-1)
-			me.ToolkitClose()
-			if me.PluginName == "nocui" {
-				os.Exit(-1)
-			}
 		}
 	}()
 	log.Log(TREE, "catchActionChannel() START")
@@ -36,11 +25,12 @@ func (me *TreeInfo) catchActionChannel() {
 		case a := <-me.pluginChan:
 			log.Verbose("catchActionChannel() on ", a.WidgetId, a.WidgetType, a.ProgName)
 			muAction.Lock()
-			me.WaitOK()
+			if me.ActionFromChannel == nil {
-			// time.Sleep(10 * time.Millisecond)
+				log.Error(errors.New("toolkit ActionFromChannel == nil"), a.WidgetId, a.ActionType, a.WidgetType)
-			me.Lock()
+			} else {
-			me.doAction(a)
+				// send this to the toolkit
-			me.Unlock()
+				me.ActionFromChannel(a)
+			}
 			muAction.Unlock()
 		}
 	}
@@ -49,49 +39,15 @@ func (me *TreeInfo) catchActionChannel() {
 func New() *TreeInfo {
 	me := new(TreeInfo)
 	me.pluginChan = make(chan widget.Action, 1)
-	me.frozenChan = make(chan widget.Action, 1)
+
-	me.config = configLoad()
+	/*
+		full := "go.wit.com/gui"
+		short := "gui"
+		TREE = log.NewFlag("TREE", true, full, short, "treeRoot info")
+	*/
 
 	log.Log(TREE, "Init() start channel reciever")
 	go me.catchActionChannel()
 	log.Log(TREE, "Init() END")
 	return me
 }
-
-func (t *TreeInfo) ConfigFind(n string) (string, error) {
-	all := t.config.All() // get the list of repos
-	for all.Scan() {
-		r := all.Next()
-		if t.PluginName != r.Plugin {
-			continue
-		}
-		if n == r.Name {
-			return r.Value, nil
-		}
-		// 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)
-}

json.go

@@ -51,7 +51,7 @@ func (n *Node) Json() []string {
 	case widget.Window:
 		tmp := fmt.Sprint("{ WidgetType :", n.WidgetType, "}")
 		all = append(all, tmp)
-		log.Log(TREEWARN, tmp)
+		log.Warn(tmp)
 		return all
 	default:
 		log.Log(TREE, "doUserEvent() type =", n.WidgetType)

plugin.go

@@ -6,35 +6,32 @@ package tree
 	There are some helper functions that are probably going to be
 	the same everywhere. Mostly due to handling the binary tree structure
 	and the channel communication
+
+	For now, it's just a symlink to the 'master' version in
+	./toolkit/nocui/common.go
 */
 
 import (
-	"os"
-	"time"
-
-	"go.wit.com/log"
 	"go.wit.com/widget"
 )
 
-func (me *TreeInfo) InitOK() {
+// searches the binary tree for a WidgetId
-	me.ok = true
+func (n *Node) FindWidgetId(id int) *Node {
-}
+	if n == nil {
+		return nil
+	}
 
-// this hack is to wait for the application to send something
+	if n.WidgetId == id {
-// before trying to do anything. todo: rethink this someday
+		return n
-func (me *TreeInfo) WaitOK() {
-	for {
-		if me == nil {
-			log.Info("WaitOK lied. me == nil but returned anyway")
-			log.Info("WaitOK lied. me == nil but returned anyway")
-			log.Info("WaitOK lied. me == nil but returned anyway")
-			os.Exit(-1)
 	}
-		if me.ok {
+
-			return
+	for _, child := range n.children {
+		newN := child.FindWidgetId(id)
+		if newN != nil {
+			return newN
 		}
-		time.Sleep(10 * time.Millisecond)
 	}
+	return nil
 }
 
 // Other goroutines must use this to access the GUI
@@ -48,13 +45,6 @@ func (me *TreeInfo) Callback(guiCallback chan widget.Action) {
 	me.callback = guiCallback
 }
 
-// this is the function that receives things from the application
 func (me *TreeInfo) PluginChannel() chan widget.Action {
-	me.WaitOK()
 	return me.pluginChan
 }
-
-// this is the function that receives things from the application
-func (me *TreeInfo) FrozenChannel() chan widget.Action {
-	return me.frozenChan
-}

structs.go

@@ -1,47 +1,35 @@
 package tree
 
 /*
+	These code should be common to all gui plugins
+
 	There are some helper functions that are probably going to be
 	the same everywhere. Mostly due to handling the binary tree structure
 	and the channel communication
+
+	For now, it's just a symlink to the 'master' version in
+	./toolkit/nocui/common.go
 */
 
 import (
-	"sync"
+	// "go.wit.com/log"
-
-	"go.wit.com/lib/protobuf/guipb"
 	"go.wit.com/widget"
 )
 
-// TODO: use protocol buffers
+// var me *TreeInfo
-
-// this is the root node of the binary tree
-// There is only one of these per application
-var treeRoot *Node
 
 type TreeInfo struct {
-	sync.Mutex                        // a lock around the tree to serialize access
+	// this is the channel we send user events like
-	ok            bool                // indicates the plugin actually initialized
+	// mouse clicks or keyboard events back to the program
-	PluginName    string              // used to identify the plugin
+	callback chan widget.Action
-	config        *ToolkitConfigs     // protobuf of plugin settings
+
-	callback      chan widget.Action  // mouse clicks or keyboard events back to the program
+	// this is the channel we get requests to make widgets
-	pluginChan    chan widget.Action  // this is the channel we get requests to make widgets
+	pluginChan chan widget.Action
-	frozenChan    chan widget.Action  // expirement to get fyne to work
+
-	Add           func(*Node)         // add a new widget
+	treeRoot          *Node
-	AddText       func(*Node, string) // add a string to a dropdown widget
+	NodeI             interface{}
-	SetText       func(*Node, string) // set the text of a widget
+	ActionFromChannel func(widget.Action)
-	SetTitle      func(*Node, string) // update the title of a window or tab
+	PluginName        string
-	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 {
@@ -54,7 +42,7 @@ type Node struct {
 
 	State widget.State
 
-	ddStrings []string
+	Strings map[string]int
 
 	// the internal plugin toolkit structure
 	// in the gtk plugin, it has gtk things like margin & border settings

table.go

@@ -1,352 +0,0 @@
-// Although most code from WIT.COM Inc is under the GPL
-// This code is more generic because it must be able
-// to be used in any GUI plugin
-
-package tree
-
-import (
-	"fmt"
-	"time"
-
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/guipb"
-	"go.wit.com/log"
-	"go.wit.com/widget"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/types/known/anypb"
-	"google.golang.org/protobuf/types/known/timestamppb"
-)
-
-func (me *TreeInfo) doTable(a widget.Action) {
-	if a.TablePB == nil {
-		log.Log(TREE, "tree: action didn't have a Table PB")
-		return
-	}
-	pb := guipb.NewTables()
-	if err := pb.Unmarshal(a.TablePB); err != nil {
-		log.Info("unmarshal error", err, "data len =", len(a.TablePB))
-		return
-	}
-	log.Info("tree.doTables() start. # of tables:", len(pb.Tables))
-	for t := range pb.IterAll() {
-		// for i, o := range t.Order {
-		// 	log.Info("got order:", t.Title, i, o)
-		// }
-		// dumpTable(t)
-		// me.ShowTable(t)
-		// log.Info("TREE FOUND TABLE UUID", t.Uuid)
-		for i, ot := range me.currentTables {
-			// log.Info("TREE already has UUID", i, ot.Uuid)
-			if t.Uuid == 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 (grid *Node) makeGridLabel(pb *guipb.Widget, w int, h int) *Node {
-	a := new(widget.Action)
-	a.WidgetType = widget.Label
-	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 (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) {
-	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 {
-		// 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 {
-			// debugging code
-			// id := r.Header.Id
-			// n := treeRoot.FindWidgetId(int(id))
-			// if n == nil {
-			// 	log.Info("could not find widget id", id)
-			// }
-			log.Info("tree.updateRow(string)", r.Header, "len =", len(r.Widgets))
-			// if r.Header.Name == "Hostname" {
-			// }
-			// log.Info("tree.updateRow() found Hostnames", r.Vals)
-			for i, v := range r.Vals {
-				// log.Info("tree: Hostname Widget", i, v, w.Name)
-				w := r.Widgets[i]
-				if v != w.Name {
-					log.Info("tree: need to update:", i, v, "vs", w.Name, w.Id)
-					n := treeRoot.FindWidgetId(int(w.Id))
-					if n == nil {
-						log.Info("tree.TableUpdate() err n == nil ", w.Id, w.Name)
-						continue
-					}
-					me.SetText(n, v)
-				}
-				if r.Header.Name == "CurrentBranchName" {
-					log.Info("tree: check:", i, v, "vs", w.Name, w.Id)
-				}
-			}
-			return
-		}
-	}
-
-	for _, r := range t.TimeRows {
-		if name != r.Header.Name {
-			continue
-		}
-		log.Info("tree.updateRow(time)", r.Header, "len =", len(r.Widgets))
-		for i, _ := range r.Vals {
-			// log.Info("tree: Hostname Widget", i, v, w.Name)
-			w := r.Widgets[i]
-			n := treeRoot.FindWidgetId(int(w.Id))
-			if n == nil {
-				log.Info("tree.TableUpdate() err n == nil ", w.Id, w.Name)
-				continue
-			}
-			msg, err := anypb.UnmarshalNew(w.Val, proto.UnmarshalOptions{})
-			if err != nil {
-				log.Fatalf("failed to unmarshal: %v", err)
-			}
-
-			switch v := msg.(type) {
-			case *timestamppb.Timestamp:
-				me.SetText(n, shell.FormatDuration(time.Since(v.AsTime())))
-			default:
-				me.SetText(n, fmt.Sprintf("%v", v))
-			}
-		}
-		return
-	}
-}
-*/
-
-func (me *TreeInfo) makeTable(t *guipb.Table) {
-	var grid *Node
-	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)
-	}
-	if grid == nil {
-		log.Log(TREEWARN, "tree: makeTable() failed to make grid")
-		return
-	}
-	me.Add(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 {
-		// 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.Log(TREEWARN, "tree:row() COLOMN FAIL", t.Title, name, w, h)
-		}
-
-		w += 1
-	}
-}
-
-func (me *TreeInfo) addTableRow(t *guipb.Table, grid *Node, name string, w int) bool {
-	var h int = 0
-	for _, r := range t.StringRows {
-		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.makeGridLabel(v, w, h)
-			me.Add(lab)
-			h += 1
-		}
-		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)
-			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 {
-			v.Name = fmt.Sprintf("%d", v.Size)
-			// log.Info("tree: Add()ing to grid here", v.Id, v.Name, w, h)
-			lab := grid.makeGridLabel(v, w, h)
-			me.Add(lab)
-			h += 1
-		}
-		return true
-	}
-
-	for _, r := range t.TimeRows {
-		if name != r.Header.Name {
-			// log.Info("skip sint 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 _, widg := range r.Widgets {
-			msg, err := anypb.UnmarshalNew(widg.Val, proto.UnmarshalOptions{})
-			if err != nil {
-				log.Fatalf("failed to unmarshal: %v", err)
-			}
-
-			switch v := msg.(type) {
-			case *timestamppb.Timestamp:
-				// fmt.Println("Unpacked Timestamp:", shell.FormatDuration(time.Since(v.AsTime())))
-				widg.Name = shell.FormatDuration(time.Since(v.AsTime()))
-			default:
-				fmt.Println("Unknown type:", v)
-				widg.Name = fmt.Sprintf("%v", v)
-			}
-
-			// log.Info("tree: Add()ing to grid here", widg.Id, widg.Name, w, h)
-			lab := grid.makeGridLabel(widg, w, h)
-			me.Add(lab)
-			h += 1
-		}
-		return true
-	}
-
-	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)
-	}
-	for i, r := range t.StringRows {
-		log.Info("got string row:", t.Title, i, r.Header.Name, r.Vals)
-		for _, v := range r.Widgets {
-			log.Info("tree: got string widget:", v.Id, v.Name)
-		}
-	}
-	for i, r := range t.IntRows {
-		log.Info("got int row:", t.Title, i, r.Header.Name, r.Vals)
-		for _, v := range r.Widgets {
-			log.Info("tree: got int widget:", v.Id, v.Size)
-		}
-	}
-}
-
-type TreeTable struct {
-	PB *guipb.Table
-	/*
-		hostnames []string
-		columns   []*gui.NodeColumn
-		order     []*gui.NodeColumn
-	*/
-}

toolkitConfig.proto

@@ -1,19 +0,0 @@
-// Copyright 2025 WIT.COM Inc Licensed GPL 3.0
-
-syntax = "proto3";
-
-package forgepb;
-
-import "google/protobuf/timestamp.proto"; // Import the well-known type for Timestamp
-
-message ToolkitConfig {                                   //
-        string                   plugin             = 1;  // 'gocui', 'andlabs', etc `autogenpb:unique`
-        string                   name               = 2;  // variable name 'fullscreen' `autogenpb:unique`
-        string                   value              = 3;  // value "true"
-}
-
-message ToolkitConfigs {                                  // `autogenpb:marshal` `autogenpb:nomutex`
-        string                   uuid               = 1;  // `autogenpb:uuid:d7886d47-a3b9-43b9-b0f6-17074a9844e6`
-        string                   version            = 2;  // `autogenpb:version:v0.0.1`
-        repeated ToolkitConfig   ToolkitConfigs     = 3;
-}

toolkitConfig.save.go

@@ -1,116 +0,0 @@
-// Copyright 2025 WIT.COM Inc Licensed GPL 3.0
-
-package tree
-
-// functions to import and export the protobuf
-// data to and from config files
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"go.wit.com/log"
-)
-
-// load the ~/.config/forge/ files
-func configLoad() *ToolkitConfigs {
-	if os.Getenv("FORGE_CONFIG") == "" {
-		homeDir, _ := os.UserHomeDir()
-		fullpath := filepath.Join(homeDir, ".config/forge")
-		os.Setenv("FORGE_CONFIG", fullpath)
-	}
-
-	c, err := loadText()
-	if err != nil {
-		log.Info("gui toolkit configLoad() error", err)
-	}
-	if c != nil {
-		return c
-	}
-
-	// first time user. make a template config file
-	c = sampleConfig()
-	return c
-}
-
-// makes a sample config (and saves it)
-func sampleConfig() *ToolkitConfigs {
-	all := NewToolkitConfigs()
-	new1 := new(ToolkitConfig)
-	new1.Plugin = "tree"
-	new1.Name = "test"
-	new1.Value = "apple"
-	all.Append(new1)
-
-	all.configSave()
-
-	fmt.Println("first time user. adding an example config file with", len(all.ToolkitConfigs), "repos")
-	return all
-}
-
-// write to ~/.config/forge/ unless ENV{FORGE_CONFIG} is set
-func (c *ToolkitConfigs) configSave() error {
-	s := c.FormatTEXT()
-	configWrite("toolkit.text", []byte(s))
-	return nil
-}
-
-func loadText() (*ToolkitConfigs, error) {
-	// this lets the user hand edit the config
-	data, err := loadFile("toolkit.text")
-	if err != nil {
-		return nil, err
-	}
-	if data == nil {
-		return nil, fmt.Errorf("toolkit.text data was nil")
-	}
-	if len(data) == 0 {
-		return nil, fmt.Errorf("toolkit.text was empty")
-	}
-
-	c := new(ToolkitConfigs)
-
-	// attempt to marshal toolkit.text
-	if err := c.UnmarshalTEXT(data); err != nil {
-		return nil, err
-	}
-	log.Log(TREE, "ConfigLoad()", len(c.ToolkitConfigs), "entries in ~/.config/forge")
-	return c, nil
-}
-
-func loadFile(filename string) ([]byte, error) {
-	fullname := filepath.Join(os.Getenv("FORGE_CONFIG"), filename)
-	data, err := os.ReadFile(fullname)
-	if errors.Is(err, os.ErrNotExist) {
-		// if file does not exist, just return nil. this
-		// will cause ConfigLoad() to try the next config file like "toolkit.text"
-		// because the user might want to edit the .config by hand
-		return nil, nil
-	}
-	if err != nil {
-		// log.Info("open config file :", err)
-		return nil, err
-	}
-	return data, nil
-}
-
-func configWrite(filename string, data []byte) error {
-	fullname := filepath.Join(os.Getenv("FORGE_CONFIG"), filename)
-
-	cfgfile, err := os.OpenFile(fullname, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
-	defer cfgfile.Close()
-	if err != nil {
-		log.Warn("open config file :", err)
-		return err
-	}
-	if filename == "toolkit.text" {
-		// add header
-		cfgfile.Write([]byte("\n"))
-		cfgfile.Write([]byte("# you can customize your GUI toolkit user settings here\n"))
-		cfgfile.Write([]byte("\n"))
-	}
-	cfgfile.Write(data)
-	return nil
-}