common tree package for toolkitsv0.12.4

    This update provides *lots* of toolkit updates. This will allow
        the next step of debugging the gocui toolkit to make it work
        again. There are new common routines for handling the plugin
        channel communication

Signed-off-by: Jeff Carr <[email protected]>

1 files changed, 218 insertions, 1 deletions

diff --git a/gocui/common.go b/gocui/common.go
index 35417a1..3c67133 120000..100644
--- a/gocui/common.go
+++ b/gocui/common.go
@@ -1 +1,218 @@
-../nocui/common.go
\ No newline at end of file
+package main
+
+/*
+	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 (
+	"go.wit.com/log"
+	"go.wit.com/gui/widget"
+)
+
+// this is the channel we send user events like
+// mouse clicks or keyboard events back to the program
+var callback chan widget.Action
+
+// this is the channel we get requests to make widgets
+var pluginChan chan widget.Action
+
+type node struct {
+	parent	*node
+	children []*node
+
+	WidgetId	int	// widget ID
+	WidgetType	widget.WidgetType
+	ParentId	int	// parent ID
+
+	state	widget.State
+
+	// a reference name for programming and debuggign. Must be unique
+	progname   string
+
+	// the text used for button labesl, window titles, checkbox names, etc
+	label   string
+
+	// horizontal  means layout widgets like books on a bookshelf
+	// vertical    means layout widgets like books in a stack
+	// direction widget.Orientation
+	direction widget.Orientation
+
+	// This is how the values are passed back and forth
+	// values from things like checkboxes & dropdown's
+	value any
+
+	strings []string
+
+	// This is used for things like a slider(0,100)
+	X      int
+	Y      int
+
+	// This is for the grid size & widget position
+	W      int
+	H      int
+	AtW    int
+	AtH    int
+
+	vals []string // dropdown menu items
+
+	// horizontal bool `default:false`
+
+	hasTabs bool // does the window have tabs?
+	currentTab bool // the visible tab
+
+	// the internal plugin toolkit structure
+	// in the gtk plugin, it has gtk things like margin & border settings
+	// in the text console one, it has text console things like colors for menus & buttons
+	tk *guiWidget
+}
+
+// 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 (n *node) doUserEvent() {
+	if (callback == nil) {
+		log.Log(ERROR, "doUserEvent() callback == nil", n.WidgetId)
+		return
+	}
+	var a widget.Action
+	a.WidgetId = n.WidgetId
+	a.Value = n.value
+	a.ActionType = widget.User
+	log.Log(INFO, "doUserEvent() START: send a user event to the callback channel")
+	callback <- a
+	log.Log(INFO, "doUserEvent() END:   sent a user event to the callback channel")
+	return
+}
+
+// Other goroutines must use this to access the GUI
+//
+// You can not acess / process the GUI thread directly from
+// other goroutines. This is due to the nature of how
+// Linux, MacOS and Windows work (they all work differently. suprise. surprise.)
+//
+// this sets the channel to send user events back from the plugin
+func Callback(guiCallback chan widget.Action) {
+	callback = guiCallback
+}
+
+func PluginChannel() chan widget.Action {
+	return pluginChan
+}
+
+/*
+func convertString(val any) string {
+	switch v := val.(type) {
+	case bool:
+		n.B = val.(bool)
+	case string:
+		n.label = val.(string)
+		n.S = val.(string)
+	case int:
+		n.I = val.(int)
+	default:
+		log.Error(errors.New("Set() unknown type"), "v =", v)
+	}
+}
+*/
+
+/*
+// this is in common.go, do not move it
+func getString(A any) string {
+	if A == nil {
+		log.Warn("getString() got nil")
+		return ""
+	}
+	var k reflect.Kind
+	k = reflect.TypeOf(A).Kind()
+
+	switch k {
+	case reflect.Int:
+		var i int
+		i = A.(int)
+		return string(i)
+	case reflect.String:
+		return A.(string)
+	case reflect.Bool:
+		if A.(bool) == true {
+			return "true"
+		} else {
+			return "false"
+		}
+	default:
+		log.Warn("getString uknown kind", k, "value =", A)
+		return ""
+	}
+	return ""
+}
+*/
+
+// this is in common.go, do not move it
+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
+
+	// copy the data from the action message
+	n.progname = a.ProgName
+	n.value = a.Value
+	n.direction = a.Direction
+	n.strings = a.Strings
+
+	// TODO: these need to be rethought
+	n.X = a.X
+	n.Y = a.Y
+	n.W = a.W
+	n.H = a.H
+	n.AtW = a.AtW
+	n.AtH = a.AtH
+
+	// store the internal toolkit information
+	n.tk = initWidget(n)
+	// n.tk = new(guiWidget)
+
+	if (a.WidgetType == widget.Root) {
+		log.Log(INFO, "addNode() Root")
+		return n
+	}
+
+	if (me.rootNode.findWidgetId(a.WidgetId) != nil) {
+		log.Log(ERROR, "addNode() WidgetId already exists", a.WidgetId)
+		return me.rootNode.findWidgetId(a.WidgetId)
+	}
+
+	// add this new widget on the binary tree
+	n.parent = me.rootNode.findWidgetId(a.ParentId)
+	if n.parent != nil {
+		n.parent.children = append(n.parent.children, n)
+		//w := n.tk
+		//w.parent = n.parent.tk
+		//w.parent.children = append(w.parent.children, w)
+	}
+	return n
+}