starting to try safe chan and goroutines

fix tab title's
    right before attempting to add chan goroutines
    removed "where" widget pointer
    box added to tab
    experiement with log as it's own repo

Signed-off-by: Jeff Carr <jcarr@wit.com>

README-goreadme.md

@@ -107,42 +107,6 @@ external things which might be useful
 * [GO Style Guide]
 ```
 
-version v1.3
-
-I like things to be easy.
-
-this means all the log settings are in one place. it should allow
-things to be over-ridden externally to the library
-but still allow command line --args to pass debugging settings
-
-## I also have a generic sleep() and exit() in here because it's simple
-
-Usage:
-
-log("something", foo, bar)
-var DEBUG bool = true
-log(DEBUG, "something else", someOtherVariable)  # if DEBUG == false, return doing nothing
-log(SPEW, "something else", someOtherVariable)   # this get's sent to spew.Dump(). Very useful for debugging!
-
-## Variables
-
-```golang
-var INFO bool
-```
-
-```golang
-var LOGOFF bool = false // turn this off, all logging stops
-
-```
-
-```golang
-var SPEW spewt
-```
-
-```golang
-var WARN bool
-```
-
 ## Functions
 
 ### func [DebugWidgetWindow](/debugWidget.go#L52)
@@ -293,6 +257,8 @@ You get a window
 
 ## Sub Packages
 
+* [log](./log)
+
 * [toolkit](./toolkit)
 
 ---

button.go

@@ -6,11 +6,14 @@ func (n *Node) NewButton(name string, custom func()) *Node {
 	newNode := n.New(name, toolkit.Button, custom)
 
 	var a toolkit.Action
+	a.Title = name
 	a.Type = toolkit.Add
-	// a.Widget = &newNode.widget
+	a.Callback = callback
-	// a.Where = &n.widget
-	// action(&a)
 	newaction(&a, newNode, n)
 
 	return newNode
 }
+
+func callback(i int) {
+	log(debugError, "button callback() i =", i)
+}

chan.go

@@ -22,6 +22,7 @@ func makeConc() {
 func startTheThing(wg *conc.WaitGroup) {
 	wg.Go(func() {
 		log(debugNow, "startTheThing()")
+		panic("test conc.WaitGroup")
 	})
 }
 

cmds/textbox/main.go

@@ -68,10 +68,10 @@ func addDemoTab(window *gui.Node, title string) {
 	dd.AddDropdownName("more 2")
 	dd.AddDropdownName("more 3")
 
-	g.SetNext(3,1)
+	// g.SetNext(3,1)
-	g1.NewLabel("label (3,1)")
+	// g1.NewLabel("label (3,1)")
-	g.SetNext(3,2)
+	// g.SetNext(3,2)
-	g1.NewLabel("label (3,2)")
+	// g1.NewLabel("label (3,2)")
 
 	g2 := newNode.NewGroup("group 2")
 	tb := g2.NewTextbox("tb")

debugWidget.go

@@ -188,8 +188,7 @@ func (n *Node) debugAddWidgetButtons() {
 	n.NewButton("Dropdown", func () {
 		a := activeWidget.NewDropdown("tmp dropdown")
 		a.AddText("this is better than tcl/tk")
-		a.AddText("make something for tim")
+		a.AddText("make something for tim for qflow")
-		a.AddText("for qflow")
 		a.AddText("and for riscv")
 		a.Custom = func () {
 			log("custom dropdown() a =", a.widget.Name, a.widget.S, "id=", a.id)
@@ -198,7 +197,7 @@ func (n *Node) debugAddWidgetButtons() {
 	n.NewButton("Combobox", func () {
 		a := activeWidget.NewCombobox("tmp combobox")
 		a.AddText("mirrors.wit.com")
-		a.AddText("go.wit.org")
+		a.AddText("go.wit.com")
 		a.Custom = func () {
 			log("custom combobox() a =", a.widget.Name, a.widget.S, "id=", a.id)
 		}
@@ -213,12 +212,14 @@ func (n *Node) debugAddWidgetButtons() {
 		// SetDebug(true)
 		debugGrid = activeWidget.NewGrid("tmp grid", 2, 3)
 		debugGridLabel = debugGrid.NewLabel("mirrors.wit.com")
+		/*
 		debugGrid.SetNext(0,1)
 		debugGrid.NewLabel("foo (0,1)")
 		debugGrid.SetNext(1,1)
 		debugGrid.NewLabel("foo (1,1)")
 		debugGrid.SetNext(2,1)
 		debugGrid.NewLabel("foo (2,1)")
+		*/
 		// SetDebug(false)
 		DebugWidgetWindow(debugGrid)
 	})

debugWindow.go

@@ -83,6 +83,10 @@ func (n *Node) DebugTab(title string) *Node {
 		activeWidget.ListChildren(true)
 	})
 
+	g2.NewButton("test conc", func () {
+		makeConc()
+	})
+
 	return newN
 }
 

grid.go

@@ -39,6 +39,7 @@ func (n *Node) NewBox(name string, b bool) *Node {
 
 	var a toolkit.Action
 	a.Type = toolkit.Add
+	a.Title = name
 	a.B = b
 	newaction(&a, newNode, n)
 

log.go

@@ -1,125 +1,29 @@
-//
-// version v1.3
-//
-// I like things to be easy.
-//
-// this means all the log settings are in one place. it should allow
-// things to be over-ridden externally to the library
-// but still allow command line --args to pass debugging settings
-//
-// I also have a generic sleep() and exit() in here because it's simple
-//
-// Usage:
-//
-// log("something", foo, bar)
-// var DEBUG bool = true
-// log(DEBUG, "something else", someOtherVariable)  # if DEBUG == false, return doing nothing
-// log(SPEW, "something else", someOtherVariable)   # this get's sent to spew.Dump(). Very useful for debugging!
-//
 package gui
 
 import 	(
-	"os"
+	witlog "git.wit.org/wit/gui/log"
-	"runtime"
-	"runtime/pprof"
-	golog "log"
-	"time"
-	"reflect"
-	"github.com/davecgh/go-spew/spew"
-	// "net"
 )
 
-var 	LOGOFF	bool	= false	// turn this off, all logging stops
+// various debugging flags
-var	WARN	bool
+var logNow bool = true	// useful for active development
-var 	INFO	bool
+var logError bool = true
+var logWarn bool = false
+var logInfo bool = false
+var logVerbose bool = false
 
-type spewt struct {
+// var log interface{}
-	a bool
-}
-
-var SPEW spewt
-
-
-/*
-	sleep()		# you know what this does? sleeps for 1 second. yep. dump. easy.
-	sleep(.1)	# you know what this does? yes, it sleeps for 1/10th of a second
-*/
-func sleep(a ...any) {
-	if (a == nil) {
-		time.Sleep(time.Second)
-		return
-	}
-
-	log("sleep", a[0])
-
-	switch a[0].(type) {
-	case int:
-		time.Sleep(time.Duration(a[0].(int)) * time.Second)
-	case float64:
-		time.Sleep(time.Duration(a[0].(float64) * 1000) * time.Millisecond)
-	default:
-		log("sleep a[0], type = ", a[0], reflect.TypeOf(a[0]))
-	}
-}
-
-/*
-	exit()		# yep. exits. I guess everything must be fine
-	exit(3)		# I guess 3 it is then
-	exit("dont like apples")	# ok. I'll make a note of that
-*/
-func exit(a ...any) {
-	log("exit", a)
-	//if (a) {
-	//	os.Exit(a)
-	//}
-	os.Exit(0)
-}
-
-/*
-	I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
-	I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
-	implementation is probably faster than all of those because you just set one bool to FALSE
-	and it all stops.
-	Sometimes I need to capture to stdout, sometimes stdout can't
-	work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread
-	over 8 million references in every .go file. I'm tapping out and putting
-	it in one place. here it is. Also, this makes having debug levels really fucking easy.
-	You can define whatever level of logging you want from anywhere (command line) etc.
-
-	log()		# doesn't do anything
-	log(stuff)	# sends it to whatever log you define in a single place. here is the place
-*/
 
 func log(a ...any) {
-	if (LOGOFF) {
+	witlog.Where = "wit/gui"
-		return
+	witlog.Log(a...)
 }
 
-	if (a == nil) {
+func sleep(a ...any) {
-		return
+	witlog.Sleep(a...)
 }
 
-	var tbool bool
+func exit(a ...any) {
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(tbool)) {
+	witlog.Exit(a...)
-		// golog.Println("\t a[0] = bool")
-		if (a[0] == false) {
-			return
-		}
-		a[0] = "WIT/GUI"
-	}
-
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(SPEW)) {
-		a = a[1:]
-		spew.Dump(a)
-		return
-	}
-
-	golog.Println(a...)
-}
-
-func loggo() {
-	pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
-	golog.Println("runtime.NumGoroutine() = ", runtime.NumGoroutine())
 }
 
 // b bool, print if true
@@ -135,5 +39,5 @@ func logindent(b bool, depth int, format string, a ...any) {
 	// array prepend(). Why isn't this a standard function. It should be:
 	// a.prepend(debugGui, newFormat)
 	a = append([]any{b, newFormat}, a...)
-	log(a...)
+	witlog.Log(a...)
 }

log/log.go

@@ -0,0 +1,142 @@
+package witlog
+//
+// version v1.2
+//
+// I like things to be easy.
+//
+// this means all the log settings are in one place. it should allow
+// things to be over-ridden externally to the library
+// but still allow command line --args to pass debugging settings
+//
+// I also have a generic sleep() and exit() in here because it's simple
+//
+// Usage:
+//
+// log("something", foo, bar)
+// var DEBUG bool = true
+// log(DEBUG, "something else", someOtherVariable)  # if DEBUG == false, return doing nothing
+// log(SPEW, "something else", someOtherVariable)   # this get's sent to spew.Dump(). Very useful for debugging!
+//
+
+import 	(
+	"os"
+	"runtime"
+	"runtime/pprof"
+	golog "log"
+	"time"
+	"reflect"
+	"github.com/davecgh/go-spew/spew"
+	// "net"
+)
+
+var LOGOFF bool = false // turn this off, all logging stops
+var debugToolkit bool = false // does spew stuff?
+
+var Where string = "gui/log"
+
+type spewt struct {
+	a bool
+}
+
+var SPEW spewt
+
+
+/*
+	sleep()		# you know what this does? sleeps for 1 second. yep. dump. easy.
+	sleep(.1)	# you know what this does? yes, it sleeps for 1/10th of a second
+*/
+func Sleep(a ...any) {
+	if (a == nil) {
+		time.Sleep(time.Second)
+		return
+	}
+
+	Log(true, "sleep", a[0])
+
+	switch a[0].(type) {
+	case int:
+		time.Sleep(time.Duration(a[0].(int)) * time.Second)
+	case float64:
+		time.Sleep(time.Duration(a[0].(float64) * 1000) * time.Millisecond)
+	default:
+		Log("sleep a[0], type = ", a[0], reflect.TypeOf(a[0]))
+	}
+}
+
+/*
+	exit()		# yep. exits. I guess everything must be fine
+	exit(3)		# I guess 3 it is then
+	exit("dont like apples")	# ok. I'll make a note of that
+*/
+func Exit(a ...any) {
+	Log(true, "exit", a)
+	//if (a) {
+	//	os.Exit(a)
+	//}
+	os.Exit(0)
+}
+
+/*
+	I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
+	I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
+	implementation is probably faster than all of those because you just set one bool to FALSE
+	and it all stops.
+	Sometimes I need to capture to stdout, sometimes stdout can't
+	work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread
+	over 8 million references in every .go file. I'm tapping out and putting
+	it in one place. here it is. Also, this makes having debug levels really fucking easy.
+	You can define whatever level of logging you want from anywhere (command line) etc.
+
+	log()		# doesn't do anything
+	log(stuff)	# sends it to whatever log you define in a single place. here is the place
+*/
+
+func Log(a ...any) {
+	if (LOGOFF) {
+		return
+	}
+
+	if (a == nil) {
+		return
+	}
+	var tbool bool
+	if (reflect.TypeOf(a[0]) == reflect.TypeOf(tbool)) {
+		if (a[0] == false) {
+			return
+		}
+		a[0] = Where
+	}
+
+	if (reflect.TypeOf(a[0]) == reflect.TypeOf(SPEW)) {
+		// a = a[1:]
+		a[0] = Where
+		if (debugToolkit) {
+			scs := spew.ConfigState{MaxDepth: 1}
+			scs.Dump(a)
+			// spew.Dump(a)
+		}
+		return
+	}
+
+	golog.Println(a...)
+}
+
+func loggo() {
+	pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
+	golog.Println("runtime.NumGoroutine() = ", runtime.NumGoroutine())
+}
+
+func logindent(depth int, format string, a ...interface{}) {
+	var tabs string
+	for i := 0; i < depth; i++ {
+		tabs = tabs + format
+	}
+
+	// newFormat := tabs + strconv.Itoa(depth) + " " + format
+	newFormat := tabs + format
+	Log(debugToolkit, newFormat, a)
+}
+
+func SetOutput(f *os.File) {
+	golog.SetOutput(f)
+}

plugin.go

@@ -79,11 +79,6 @@ func LoadToolkit(name string) bool {
 	// unload the plugin and restore state
 	newPlug.Quit = loadFuncE(&newPlug, "Quit")
 
-	// Sends a widget (button, checkbox, etc) and it's parent widget
-	// This includes instructions like "Add", "Delete", "Disable", etc
-//	newPlug.Send = loadFunc2(&newPlug, "Send")
-
-	// This should replace Send()
 	// Sends instructions like "Add", "Delete", "Disable", etc
 	// Sends a widget (button, checkbox, etc) and it's parent widget
 	newPlug.Action = loadFuncA(&newPlug, "Action")
@@ -230,36 +225,6 @@ func loadfile(filename string) *plugin.Plugin {
 	return plug
 }
 
-/*
-// Sends a widget and what to do with it to the plugin
-// parent = n, child = c
-func send(p *Node, c *Node) {
-	for _, aplug := range allPlugins {
-		log(debugPlugin, "Send() aplug =", aplug.name, "type=", c.widget.Type, "action=", c.widget.Action, "name=", c.widget.Name)
-		if (aplug.Send == nil) {
-			log(debugPlugin, "Failed. Send() == nil for", aplug.name)
-			continue
-		}
-		aplug.Send(&c.parent.widget, &c.widget)
-	}
-}
-*/
-
-// Sends a widget and what to do with it to the plugin
-// parent = n, child = c
-/*
-func action(a *toolkit.Action) {
-	for _, aplug := range allPlugins {
-		log(debugPlugin, "Action() aplug =", aplug.name, "Action type=", a.Type)
-		if (aplug.Action == nil) {
-			log(debugPlugin, "Failed Action() == nil for", aplug.name)
-			continue
-		}
-		aplug.Action(a)
-	}
-}
-*/
-
 // Sends a widget and what to do with it to the plugin
 // parent = n, child = c
 
@@ -268,16 +233,19 @@ func action(a *toolkit.Action) {
 func newaction(a *toolkit.Action, n *Node, where *Node) {
 	if (n != nil) {
 		a.Widget = &n.widget
+		a.WidgetId = n.id
+		a.WidgetT = n.widget.Type
 	}
 	// action(&a, newNode, n)
 	// newaction(&a, newNode, n)
 
 	if (where != nil) {
 		log(debugGui, "Action() START on where X,Y, Next X,Y =", where.Name, where.X, where.Y, where.NextX, where.NextY)
-		a.Where = &where.widget
+		// a.Where = &where.widget
+		a.WhereId = where.id
 		switch where.widget.Type {
 		case toolkit.Grid:
-			where.Dump(true)
+			// where.Dump(true)
 			log(debugGui, "Action() START on Grid (X,Y)", where.X, where.Y, "put next thing at (X,Y) =", where.NextX, where.NextY)
 			//
 			// fix values here if they are invalid. Index starts at 1
@@ -288,8 +256,8 @@ func newaction(a *toolkit.Action, n *Node, where *Node) {
 				where.NextY = 1
 			}
 			//
-			a.Where.X = where.NextX
+			a.X = where.NextX
-			a.Where.Y = where.NextY
+			a.Y = where.NextY
 			log(debugGui, "Action() END   on Grid (X,Y)", where.X, where.Y, "put next thing at (X,Y) =", where.NextX, where.NextY)
 		default:
 		}
@@ -307,19 +275,19 @@ func newaction(a *toolkit.Action, n *Node, where *Node) {
 	if (where != nil) {
 		switch where.widget.Type {
 		case toolkit.Grid:
-			log(debugNow, "Action() START size (X,Y)", where.X, where.Y, "put next thing at (X,Y) =", where.NextX, where.NextY)
+			log(logInfo, "Action() START size (X,Y)", where.X, where.Y, "put next thing at (X,Y) =", where.NextX, where.NextY)
 			where.NextY += 1
 			if (where.NextY > where.Y) {
 				where.NextX += 1
 				where.NextY = 1
 			}
-			log(debugNow, "Action() END size (X,Y)", where.X, where.Y, "put next thing at (X,Y) =", where.NextX, where.NextY)
+			log(logInfo, "Action() END size (X,Y)", where.X, where.Y, "put next thing at (X,Y) =", where.NextX, where.NextY)
 			where.Name = "jwc gridlaksdfjkl"
 			where.Width = 320
 			where.Height = 240
 			// where.NextX = 5
 			// where.NextY = 7
-			where.Dump(true)
+			// where.Dump(logInfo)
 		default:
 		}
 	}

tab.go

@@ -12,7 +12,9 @@ func (n *Node) NewTab(text string) *Node {
 
 	var a toolkit.Action
 	a.Type = toolkit.Add
+	a.Title = text
 	newaction(&a, newNode, n)
 
-	return newNode
+	newBox := newNode.NewBox(text, true)
+	return newBox
 }

toolkit/andlabs/action.go

@@ -4,40 +4,40 @@ import (
 	"git.wit.org/wit/gui/toolkit"
 )
 
-func show(w *toolkit.Widget) {
+func show(a *toolkit.Action) {
-	if (w == nil) {
+	if (a == nil) {
 		log(debugError, "nil is probably already hidden")
 		return
 	}
-	log(debugError, "show()", w.Name)
+	log(debugError, "show()", a.WidgetId)
 
-	t := mapToolkits[w]
+	t := andlabs[a.WidgetId]
 	if (t == nil) {
-		log(debugToolkit, "show() toolkit struct == nil. for", w.Name)
+		log(debugError, "show() toolkit struct == nil. for", a.WidgetId)
 		return
 	}
 
-	if (w.B) {
+	if (a.B) {
 		t.uiControl.Show()
 	} else {
 		t.uiControl.Hide()
 	}
 }
 
-func enable(w *toolkit.Widget) {
+func enable(a *toolkit.Action) {
-	if (w == nil) {
+	if (a == nil) {
 		log(debugError, "nil is probably already hidden")
 		return
 	}
-	log(debugError, "enable()", w.Name)
+	log(debugError, "enable() name =", a.WidgetId)
 
-	t := mapToolkits[w]
+	t := andlabs[a.WidgetId]
 	if (t == nil) {
-		log(debugToolkit, "enable() toolkit struct == nil. for", w.Name)
+		log(debugToolkit, "enable() toolkit struct == nil. for id =", a.WidgetId)
 		return
 	}
 
-	if (w.B) {
+	if (a.B) {
 		t.uiControl.Enable()
 	} else {
 		t.uiControl.Disable()
@@ -45,19 +45,19 @@ func enable(w *toolkit.Widget) {
 }
 
 func pad(a *toolkit.Action) {
-	if (a.Widget == nil) {
+	if (a == nil) {
 		log(debugError, "pad() ERROR: nil is probably already hidden")
 		return
 	}
-	log(debugError, "pad()", a.Widget.Name)
+	log(debugError, "pad()")
 
-	t := mapToolkits[a.Widget]
+	t := andlabs[a.WidgetId]
 	if (t == nil) {
-		log(debugToolkit, "pad() toolkit struct == nil. for", a.Widget.Name)
+		log(debugError, "pad() toolkit struct == nil. for", a.WidgetId)
 		return
 	}
 
-	switch a.Widget.Type {
+	switch t.Type {
 	case toolkit.Group:
 		switch a.Type {
 		case toolkit.Margin:
@@ -124,29 +124,21 @@ func pad(a *toolkit.Action) {
 }
 
 func move(a *toolkit.Action) {
-	if (a.Where == nil) {
+	log(debugNow, "move()", a.WidgetId, "to", a.WhereId)
-		log(debugError, "move() ERROR: can not move to nil")
-		return
-	}
-	if (a.Widget == nil) {
-		log(debugError, "move() ERROR: can not move nil")
-		return
-	}
-	log(debugNow, "move()", a.Widget.Name, "to", a.Where.Name)
 
-	tWidget := mapToolkits[a.Widget]
+	tWidget := andlabs[a.WidgetId]
 	if (tWidget == nil) {
-		log(debugError, "move() ERROR: toolkit struct == nil. for", a.Widget.Name)
+		log(debugError, "move() ERROR: toolkit struct == nil. for", a.WidgetId)
 		return
 	}
 
-	tWhere := mapToolkits[a.Where]
+	tWhere := andlabs[a.WhereId]
 	if (tWhere == nil) {
-		log(debugError, "move() ERROR: toolkit struct == nil. for", a.Where.Name)
+		log(debugError, "move() ERROR: toolkit struct == nil. for", a.WhereId)
 		return
 	}
 
-	switch a.Where.Type {
+	switch tWhere.Type {
 	case toolkit.Group:
 		switch a.Type {
 		case toolkit.Margin:
@@ -169,8 +161,8 @@ func move(a *toolkit.Action) {
 		}
 	case toolkit.Box:
 		log(debugNow, "TODO: move() for a =", a.Type)
-		log(debugNow, "TODO: move() where =", a.Where.Type)
+		log(debugNow, "TODO: move() where =", a.WhereId)
-		log(debugNow, "TODO: move() for widget =", a.Widget.Type)
+		log(debugNow, "TODO: move() for widget =", a.WidgetId)
 
 		stretchy = true
 		tWhere.uiBox.Append(tWidget.uiControl, stretchy)
@@ -182,35 +174,35 @@ func move(a *toolkit.Action) {
 		// sleep(.8)
 	default:
 		log(debugError, "TODO: need to implement move() for a =", a.Type)
-		log(debugError, "TODO: need to implement move() for where =", a.Where.Type)
+		log(debugError, "TODO: need to implement move() for where =", a.WhereId)
-		log(debugError, "TODO: need to implement move() for widget =", a.Widget.Type)
+		log(debugError, "TODO: need to implement move() for widget =", a.WidgetId)
 	}
 }
 
 func uiDelete(a *toolkit.Action) {
-	if (a.Where == nil) {
+	if (andlabs[a.WhereId] == nil) {
 		log(debugError, "uiDelete() ERROR: can not uiDelete to nil")
 		return
 	}
-	if (a.Widget == nil) {
+	if (andlabs[a.WidgetId] == nil) {
 		log(debugError, "uiDelete() ERROR: can not uiDelete nil")
 		return
 	}
-	log(debugNow, "uiDelete()", a.Widget.Name, "to", a.Where.Name)
+	log(debugNow, "uiDelete()", a.WidgetId, "to", a.WhereId)
 
-	tWidget := mapToolkits[a.Widget]
+	tWidget := andlabs[a.WidgetId]
 	if (tWidget == nil) {
-		log(debugError, "uiDelete() ERROR: toolkit struct == nil. for", a.Widget.Name)
+		log(debugError, "uiDelete() ERROR: toolkit struct == nil. for", a.WidgetId)
 		return
 	}
 
-	tWhere := mapToolkits[a.Where]
+	tWhere := andlabs[a.WhereId]
 	if (tWhere == nil) {
-		log(debugError, "uiDelete() ERROR: toolkit struct == nil. for", a.Where.Name)
+		log(debugError, "uiDelete() ERROR: toolkit struct == nil. for", a.WhereId)
 		return
 	}
 
-	switch a.Where.Type {
+	switch tWhere.Type {
 	case toolkit.Group:
 		switch a.Type {
 		case toolkit.Margin:
@@ -247,7 +239,7 @@ func uiDelete(a *toolkit.Action) {
 		// tWhere.uiBox.Append(tWidget.uiControl, stretchy)
 	default:
 		log(debugError, "TODO: need to implement uiDelete() for a =", a.Type)
-		log(debugError, "TODO: need to implement uiDelete() for where =", a.Where.Type)
+		log(debugError, "TODO: need to implement uiDelete() for where =", a.WhereId)
-		log(debugError, "TODO: need to implement uiDelete() for widget =", a.Widget.Type)
+		log(debugError, "TODO: need to implement uiDelete() for widget =", a.WidgetId)
 	}
 }

toolkit/andlabs/add.go

@@ -8,40 +8,45 @@ import (
 )
 
 func actionDump(b bool, a *toolkit.Action) {
-	log(b, "dump() Widget.Type =", a.Type)
+	log(b, "actionDump() Widget.Type =", a.Type)
-	log(b, "dump() Widget.S =", a.S)
+	log(b, "actionDump() Widget.S =", a.S)
-	log(b, "dump() Widget.I =", a.I)
+	log(b, "actionDump() Widget.I =", a.I)
-	log(b, "dump() Widget =", a.Widget)
+	log(b, "actionDump() WidgetId =", a.WidgetId)
-	log(b, "dump() Where =", a.Where)
+	log(b, "actionDump() WhereId =", a.WhereId)
 }
 
 func add(a *toolkit.Action) {
-	if (a.Widget == nil) {
+	if (andlabs[a.WidgetId] != nil) {
-		log(debugError, "add() error. w.Widget == nil")
+		log(debugError, "add() error. can't make a widget that already exists. id =", a.WidgetId)
 		actionDump(debugError, a)
 		return
 	}
+	if (a.WidgetId == 0) {
+		log(debugError, "add() error. w.WidgetId == 0")
+		actionDump(debugError, a)
+		return
+	}
+
 	// for now, window gets handled without checking where == nil)
-	if (a.Widget.Type == toolkit.Window) {
+	if (a.WidgetT == toolkit.Window) {
 		doWindow(a)
 		return
 	}
 
-	t := mapToolkits[a.Where]
+	if (andlabs[a.WhereId] == nil) {
-	if (t == nil) {
 		// listMap(debugError) // memory corruption?
-		log(debugError, "add() Widget.Name =", a.Widget.Name, a.Widget.Type)
+		log(debugError, "add() Widget.Name =", a.Title, a.WidgetT)
 		// log(debugError, "add() Where.Name =", a.Where.Name)
-		log(debugError, "ERROR add() ERROR a.Where map to t == nil.")
+		log(debugError, "ERROR add() ERROR a.Where map to t == nil.", a.WidgetId, a.WhereId)
 		return
 	}
 
-	switch a.Widget.Type {
+	switch a.WidgetT {
 	case toolkit.Window:
 		doWindow(a)
 		return
 	case toolkit.Tab:
-		doTab(a)
+		newTab(a)
 		return
 	case toolkit.Label:
 		newLabel(a)
@@ -80,7 +85,7 @@ func add(a *toolkit.Action) {
 		newImage(a)
 		return
 	default:
-		log(debugError, "add() error TODO: ", a.Widget.Type, a.Widget.Name)
+		log(debugError, "add() error TODO: ", a.WidgetT, a.Title)
 	}
 }
 
@@ -109,18 +114,34 @@ func add(a *toolkit.Action) {
 // -- (0,1) -- (1,1) -- (1,1) --
 // -----------------------------
 func place(a *toolkit.Action, t *andlabsT, newt *andlabsT) bool {
-	log(debugAction, "place() START", a.Widget.Type, a.Widget.Name)
+	log(debugAction, "place() START", a.WidgetT, a.Title)
+
+	// add the structure to the array
+	if (andlabs[a.WidgetId] == nil) {
+		log(logInfo, "newTab() MAPPED", a.WidgetId, a.WhereId)
+		andlabs[a.WidgetId] = newt
+		newt.Type = a.WidgetT
+	} else {
+		log(debugError, "newTab() DO WHAT?", a.WidgetId, a.WhereId)
+		log(debugError, "THIS IS BAD")
+	}
 
 	if (newt.uiControl == nil) {
-		log(debugError, "place() ERROR uiControl == nil", a.Where.Type, a.Where.Name)
+		log(debugError, "place() ERROR uiControl == nil", a.WhereId)
 		return false
 	}
 
-	switch a.Where.Type {
+	where := andlabs[a.WhereId]
+	if (where == nil) {
+		log(debugError, "place() ERROR where == nil", a.WhereId)
+		return false
+	}
+
+	switch where.Type {
 	case toolkit.Grid:
-		log(debugGrid, "add() Grid try at Where X,Y =", a.Where.X, a.Where.Y)
+		log(debugGrid, "add() Grid try at Where X,Y =", a.X, a.Y)
-		newt.gridX = a.Where.X
+		newt.gridX = a.X
-		newt.gridY = a.Where.Y
+		newt.gridY = a.Y
 		log(debugGrid, "add() Grid try at gridX,gridY", newt.gridX, newt.gridY)
 		// at the very end, subtract 1 from X & Y since andlabs/ui starts counting at zero
 		t.uiGrid.Append(newt.uiControl,
@@ -130,14 +151,14 @@ func place(a *toolkit.Action, t *andlabsT, newt *andlabsT) bool {
 	case toolkit.Group:
 		if (t.uiBox == nil) {
 			t.uiGroup.SetChild(newt.uiControl)
-			log(debugGrid, "add() hack Group to use this as the box?", a.Widget.Name, a.Widget.Type)
+			log(debugGrid, "add() hack Group to use this as the box?", a.Title, a.WidgetT)
 			t.uiBox  = newt.uiBox
 		} else {
 			t.uiBox.Append(newt.uiControl, stretchy)
 		}
 		return true
 	case toolkit.Tab:
-		t.uiBox.Append(newt.uiControl, stretchy)
+		t.uiTab.Append(a.Title, newt.uiControl)
 		t.boxC += 1
 		return true
 	case toolkit.Box:
@@ -148,7 +169,7 @@ func place(a *toolkit.Action, t *andlabsT, newt *andlabsT) bool {
 		t.uiWindow.SetChild(newt.uiControl)
 		return true
 	default:
-		log(debugError, "add() how?", a.Where.Type)
+		log(debugError, "add() how?", a.WhereId)
 	}
 	return false
 }

toolkit/andlabs/box.go

@@ -9,19 +9,17 @@ import (
 
 // make new Box here
 func newBox(a *toolkit.Action) {
-	w := a.Widget
+	log(debugToolkit, "newBox()", a.Title)
-	parentW := a.Where
-	log(debugToolkit, "newBox()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugToolkit, "newBox() toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugToolkit, "newBox() toolkit struct == nil. name=", a.Title)
 		listMap(debugToolkit)
 	}
-	newt := t.rawBox(w.Name, a.B)
+	newt := t.rawBox(a.Title, a.B)
 	newt.boxC = 0
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
+	andlabs[a.WidgetId] = newt
 }
 
 // make new Box using andlabs/ui

toolkit/andlabs/button.go

@@ -10,27 +10,27 @@ import (
 func newButton(a *toolkit.Action) {
 	var t, newt *andlabsT
 	var b *ui.Button
-	w := a.Widget
+	log(debugToolkit, "newButton()", a.Title)
-	log(debugToolkit, "newButton()", w.Name)
 
-	t = mapToolkits[a.Where]
+	t = andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugToolkit, "newButton() toolkit struct == nil. name=", a.Where.Name, w.Name)
+		log(debugToolkit, "newButton() toolkit struct == nil. name=", a.Title)
 		return
 	}
 
 	newt = new(andlabsT)
 
-	b = ui.NewButton(w.Name)
+	b = ui.NewButton(a.Title)
 	newt.uiButton = b
 	newt.uiControl = b
-	newt.tw = w
+	newt.tw = a.Widget
+	newt.Type = a.WidgetT
 	newt.parent = t
 
 	b.OnClicked(func(*ui.Button) {
-		newt.commonChange(newt.tw)
+		newt.commonChange(newt.tw, a.WidgetId)
 	})
 
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
+	// mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/checkbox.go

@@ -6,10 +6,13 @@ import (
 	_ "github.com/andlabs/ui/winmanifest"
 )
 
-func (t *andlabsT) newCheckbox(w *toolkit.Widget) *andlabsT {
+func (t *andlabsT) newCheckbox(a *toolkit.Action) *andlabsT {
-	log(debugToolkit, "newCheckbox()", w.Name, w.Type)
 	var newt andlabsT
+	w := a.Widget
+	log(debugToolkit, "newCheckbox()", w.Name, w.Type)
 	newt.tw = w
+	newt.Type = w.Type
+	newt.wId = a.WidgetId
 
 	newt.uiCheckbox = ui.NewCheckbox(w.Name)
 	newt.uiControl = newt.uiCheckbox
@@ -17,7 +20,7 @@ func (t *andlabsT) newCheckbox(w *toolkit.Widget) *andlabsT {
 	newt.uiCheckbox.OnToggled(func(spin *ui.Checkbox) {
 		newt.tw.B = newt.checked()
 		log(debugChange, "val =", newt.tw.B)
-		newt.commonChange(newt.tw)
+		newt.commonChange(newt.tw, a.WidgetId)
 	})
 
 	return &newt
@@ -28,16 +31,13 @@ func (t *andlabsT) checked() bool {
 }
 
 func newCheckbox(a *toolkit.Action) {
-	w := a.Widget
+	log(debugToolkit, "newCheckbox()", a.Title)
-	parentW := a.Where
-	log(debugToolkit, "newCheckbox()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
 		listMap(debugError)
 		return
 	}
-	newt := t.newCheckbox(w)
+	newt := t.newCheckbox(a)
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/combobox.go

@@ -6,11 +6,14 @@ import (
 	"git.wit.org/wit/gui/toolkit"
 )
 
-func (t *andlabsT) newCombobox(w *toolkit.Widget) *andlabsT {
+func (t *andlabsT) newCombobox(a *toolkit.Action) *andlabsT {
 	var newt andlabsT
+	w := a.Widget
 	log(debugToolkit, "newCombobox() START", w.Name)
 
 	newt.tw = w
+	newt.wId = a.WidgetId
+	newt.Type = w.Type
 	s := ui.NewEditableCombobox()
 	newt.uiEditableCombobox = s
 	newt.uiControl = s
@@ -21,7 +24,7 @@ func (t *andlabsT) newCombobox(w *toolkit.Widget) *andlabsT {
 
 	s.OnChanged(func(spin *ui.EditableCombobox) {
 		newt.tw.S = spin.Text()
-		newt.commonChange(newt.tw)
+		newt.commonChange(newt.tw, a.WidgetId)
 	})
 
 	return &newt
@@ -42,17 +45,14 @@ func (t *andlabsT) AddComboboxName(title string) {
 }
 
 func newCombobox(a *toolkit.Action) {
-	w := a.Widget
+	log(debugToolkit, "newCombobox()", a.Title)
-	parentW := a.Where
-	log(debugToolkit, "newCombobox()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugToolkit, "newCombobox() toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugToolkit, "newCombobox() toolkit struct == nil. name=", a.Title)
 		listMap(debugToolkit)
 		return
 	}
-	newt := t.newCombobox(w)
+	newt := t.newCombobox(a)
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/common.go

@@ -4,7 +4,7 @@ import (
 	"git.wit.org/wit/gui/toolkit"
 )
 
-func (t *andlabsT) commonChange(tw *toolkit.Widget) {
+func (t *andlabsT) commonChange(tw *toolkit.Widget, wId int) {
 	log(debugChange, "commonChange() START widget   =", t.tw.Name, t.tw.Type)
 	if (tw == nil) {
 		log(true, "commonChange() What the fuck. there is no widget t.tw == nil")
@@ -15,23 +15,21 @@ func (t *andlabsT) commonChange(tw *toolkit.Widget) {
 		return
 	}
 	tw.Custom()
+
+	if (andlabs[wId] == nil) {
+		log(debugError, "commonChange() ERROR: wId map == nil", wId)
+		return
+	}
+	sendToChan(wId)
+
 	log(debugChange, "commonChange() END   Widget.Custom()", t.tw.Name, t.tw.Type)
 }
 
-func dump(p *toolkit.Widget, c *toolkit.Widget, b bool) {
+func sendToChan(i int) {
-	log(b, "Parent:")
+	if (callback == nil) {
-	pt := mapToolkits[p]
+		log(debugError, "commonChange() SHOULD SEND int back here, but callback == nil", i)
-	if (pt == nil) {
-		log(b, "Trying to do something on a widget that doesn't work or doesn't exist or something", c)
 		return
 	}
-	pt.Dump(b)
+	log(debugError, "commonChange() Running callback() i =", i)
-
+	callback(i)
-	log(b, "Child:")
-	ct := mapToolkits[c]
-	if (ct == nil) {
-		log(b, "Trying to do something on a widget that doesn't work or doesn't exist or something", c)
-		return
-	}
-	ct.Dump(b)
 }

toolkit/andlabs/delete.go

@@ -6,21 +6,21 @@ import "git.wit.org/wit/gui/toolkit"
 
 // delete the child widget from the parent
 // p = parent, c = child
-func destroy(p *toolkit.Widget, c *toolkit.Widget) {
+func destroy(pId int, cId int) {
-	log(true, "delete()", c.Name, c.Type)
+	log(true, "delete()", pId, cId)
 
-	pt := mapToolkits[p]
+	pt := andlabs[pId]
-	ct := mapToolkits[c]
+	ct := andlabs[cId]
 	if (ct == nil) {
-		log(true, "delete FAILED (ct = mapToolkit[c] == nil) for c", c.Name, c.Type)
+		log(true, "delete FAILED (ct = mapToolkit[c] == nil) for c", pId, cId)
 		// this pukes out a whole universe of shit
 		// listMap()
 		return
 	}
 
-	switch ct.tw.Type {
+	switch ct.Type {
 	case toolkit.Button:
-		log(true, "Should delete Button here:", c.Name)
+		log(true, "Should delete Button here:", ct.Name)
 		log(true, "Parent:")
 		pt.Dump(true)
 		log(true, "Child:")
@@ -38,16 +38,15 @@ func destroy(p *toolkit.Widget, c *toolkit.Widget) {
 		}
 
 	case toolkit.Window:
-		log(true, "Should delete Window here:", c.Name)
+		log(true, "Should delete Window here:", ct.Name)
 	default:
-		log(true, "Don't know how to delete c =", c.Type, c.Name)
 		log(true, "Don't know how to delete pt =", pt.tw.Type, pt.tw.Name, pt.uiButton)
 		log(true, "Don't know how to delete ct =", ct.tw.Type, ct.tw.Name, ct.uiButton)
 		log(true, "Parent:")
 		pt.Dump(true)
 		log(true, "Child:")
 		ct.Dump(true)
-		log(true, "Fuckit, let's destroy a button", c.Name, c.Type)
+		log(true, "Fuckit, let's destroy a button")
 		if (ct.uiButton != nil) {
 			pt.uiBox.Delete(4)
 			ct.uiButton.Destroy()

toolkit/andlabs/dropdown.go

@@ -6,11 +6,14 @@ import (
 	"git.wit.org/wit/gui/toolkit"
 )
 
-func (t *andlabsT) newDropdown(w *toolkit.Widget) *andlabsT {
+func (t *andlabsT) newDropdown(a *toolkit.Action) *andlabsT {
 	var newt andlabsT
-	log(debugToolkit, "gui.Toolbox.newDropdown() START", w.Name)
+	w := a.Widget
+	log(debugToolkit, "gui.Toolbox.newDropdown() START", a.Title)
 
 	newt.tw = w
+	newt.Type = w.Type
+	newt.wId = a.WidgetId
 	s := ui.NewCombobox()
 	newt.uiCombobox = s
 	newt.uiControl = s
@@ -26,7 +29,7 @@ func (t *andlabsT) newDropdown(w *toolkit.Widget) *andlabsT {
 			newt.text = "error"
 		}
 		newt.tw.S = newt.val[i]
-		newt.commonChange(newt.tw)
+		newt.commonChange(newt.tw, a.WidgetId)
 	})
 
 	return &newt
@@ -53,9 +56,9 @@ func (t *andlabsT) SetDropdown(i int) {
 }
 
 func AddDropdownName(a *toolkit.Action) {
-	log(debugToolkit, "gui.andlabs.AddDropdownName()", a.Widget.Name, "add:", a.S)
+	log(debugToolkit, "gui.andlabs.AddDropdownName()", a.WidgetId, "add:", a.S)
 
-	t := mapToolkits[a.Widget]
+	t := andlabs[a.WidgetId]
 	if (t == nil) {
 		log(debugToolkit, "go.andlabs.AddDropdownName() toolkit struct == nil. name=", a.Widget.Name, a.S)
 		listMap(debugToolkit)
@@ -64,31 +67,30 @@ func AddDropdownName(a *toolkit.Action) {
 	t.AddDropdownName(a.S)
 }
 
-func SetDropdownName(w *toolkit.Widget, s string) {
+func SetDropdownName(a *toolkit.Action, s string) {
-	log(debugChange, "gui.andlabs.SetDropdown()", w.Name, ",", s)
+	log(debugChange, "gui.andlabs.SetDropdown()", a.WidgetId, ",", s)
 
-	t := mapToolkits[w]
+	t := andlabs[a.WidgetId]
 	if (t == nil) {
-		log(debugError, "ERROR: SetDropdown() FAILED mapToolkits[w] == nil. name=", w.Name, s)
+		log(debugError, "ERROR: SetDropdown() FAILED mapToolkits[w] == nil. name=", a.WidgetId, s)
 		listMap(debugError)
 		return
 	}
 	t.SetDropdown(1)
+	// TODO: send back to wit/gui goroutine with the chan
 	t.tw.S = s
 }
 
 func newDropdown(a *toolkit.Action) {
-	w := a.Widget
+	log(debugToolkit, "gui.andlabs.newDropdown()", a.Title)
-	parentW := a.Where
-	log(debugToolkit, "gui.andlabs.newDropdown()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugToolkit, "go.andlabs.newDropdown() toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugToolkit, "go.andlabs.newDropdown() toolkit struct == nil. name=", a.WidgetId)
 		listMap(debugToolkit)
 		return
 	}
-	newt := t.newDropdown(w)
+	newt := t.newDropdown(a)
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
+	// mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/grid.go

@@ -14,9 +14,7 @@ import (
 // -----------------------------
 func newGrid(a *toolkit.Action) {
 	var newt *andlabsT
-	log(debugToolkit, "newGrid()", a.Widget.Name, "to", a.Where.Type)
+	log(debugToolkit, "newGrid()", a.WidgetId, "to", a.WhereId)
-
-	t := mapToolkits[a.Where]
 
 	newt = new(andlabsT)
 
@@ -24,9 +22,10 @@ func newGrid(a *toolkit.Action) {
 	newt.uiGrid = c
 	newt.uiControl = c
 	newt.tw = a.Widget
+	newt.Type = toolkit.Grid
 	newt.gridX = 0
 	newt.gridY = 0
 
+	t := andlabs[a.WhereId]
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/group.go

@@ -9,17 +9,15 @@ import (
 
 func newGroup(a *toolkit.Action) {
 	w := a.Widget
-	parentW := a.Where
 	log(debugToolkit, "NewGroup()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugToolkit, "NewGroup() toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugToolkit, "NewGroup() toolkit struct == nil. name=", w.Name)
 		listMap(debugToolkit)
 	}
 	newt := t.rawGroup(w.Name)
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }
 
 // make new Group here
@@ -34,13 +32,5 @@ func (t *andlabsT) rawGroup(title string) *andlabsT {
 	newt.uiGroup = g
 	newt.uiControl = g
 
-//	hbox := ui.NewVerticalBox()
-//	hbox.SetPadded(padded)
-//	g.SetChild(hbox)
-
-//	newt.uiBox = hbox
-//	newt.uiWindow = t.uiWindow
-//	newt.uiTab = t.uiTab
-
 	return &newt
 }

toolkit/andlabs/image.go

@@ -10,17 +10,15 @@ import (
 // make new Image here
 func newImage(a *toolkit.Action) {
 	w := a.Widget
-	parentW := a.Where
 	log(debugToolkit, "newImage()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugToolkit, "newImage() toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugToolkit, "newImage() toolkit struct == nil. name=", w.Name)
 		listMap(debugToolkit)
 	}
 	newt := t.rawImage(w.Name)
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }
 
 // make new Image using andlabs/ui

toolkit/andlabs/label.go

@@ -12,7 +12,7 @@ func newLabel(a *toolkit.Action) {
 	w := a.Widget
 	log(debugToolkit, "NewLabel()", w.Name)
 
-	t := mapToolkits[a.Where]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
 		listMap(debugError)
 		log(debugError, "ERROR newLabel() listMap()")
@@ -30,5 +30,4 @@ func newLabel(a *toolkit.Action) {
 	newt.uiControl = c
 
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/log.go

@@ -1,137 +1,25 @@
-//
-// version v1.2
-//
-// I like things to be easy.
-//
-// this means all the log settings are in one place. it should allow
-// things to be over-ridden externally to the library
-// but still allow command line --args to pass debugging settings
-//
-// I also have a generic sleep() and exit() in here because it's simple
-//
-// Usage:
-//
-// log("something", foo, bar)
-// var DEBUG bool = true
-// log(DEBUG, "something else", someOtherVariable)  # if DEBUG == false, return doing nothing
-// log(SPEW, "something else", someOtherVariable)   # this get's sent to spew.Dump(). Very useful for debugging!
-//
 package main
 
 import 	(
-	"os"
+	witlog "git.wit.org/wit/gui/log"
-	"runtime"
-	"runtime/pprof"
-	golog "log"
-	"time"
-	"reflect"
-	"github.com/davecgh/go-spew/spew"
-	// "net"
 )
 
-var 	LOGOFF	bool	= false	// turn this off, all logging stops
+// various debugging flags
-var	WARN	bool
+var logNow bool = true	// useful for active development
-var 	INFO	bool
+var logError bool = true
-
+var logWarn bool = false
-type spewt struct {
+var logInfo bool = false
-	a bool
+var logVerbose bool = false
-}
-
-var SPEW spewt
-
-
-/*
-	sleep()		# you know what this does? sleeps for 1 second. yep. dump. easy.
-	sleep(.1)	# you know what this does? yes, it sleeps for 1/10th of a second
-*/
-func sleep(a ...any) {
-	if (a == nil) {
-		time.Sleep(time.Second)
-		return
-	}
-
-	log(true, "sleep", a[0])
-
-	switch a[0].(type) {
-	case int:
-		time.Sleep(time.Duration(a[0].(int)) * time.Second)
-	case float64:
-		time.Sleep(time.Duration(a[0].(float64) * 1000) * time.Millisecond)
-	default:
-		log("sleep a[0], type = ", a[0], reflect.TypeOf(a[0]))
-	}
-}
-
-/*
-	exit()		# yep. exits. I guess everything must be fine
-	exit(3)		# I guess 3 it is then
-	exit("dont like apples")	# ok. I'll make a note of that
-*/
-func exit(a ...any) {
-	log(true, "exit", a)
-	//if (a) {
-	//	os.Exit(a)
-	//}
-	os.Exit(0)
-}
-
-/*
-	I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
-	I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
-	implementation is probably faster than all of those because you just set one bool to FALSE
-	and it all stops.
-	Sometimes I need to capture to stdout, sometimes stdout can't
-	work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread
-	over 8 million references in every .go file. I'm tapping out and putting
-	it in one place. here it is. Also, this makes having debug levels really fucking easy.
-	You can define whatever level of logging you want from anywhere (command line) etc.
-
-	log()		# doesn't do anything
-	log(stuff)	# sends it to whatever log you define in a single place. here is the place
-*/
 
 func log(a ...any) {
-	if (LOGOFF) {
+	witlog.Where = "wit/gui/andlabs"
-		return
+	witlog.Log(a...)
 }
 
-	if (a == nil) {
+func sleep(a ...any) {
-		return
+	witlog.Sleep(a...)
-	}
-	var tbool bool
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(tbool)) {
-		if (a[0] == false) {
-			return
-		}
-		a[0] = "GUI/Toolkit/Andlabs"
 }
 
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(SPEW)) {
+func exit(a ...any) {
-		// a = a[1:]
+	witlog.Exit(a...)
-		a[0] = "GUI/Toolkit/Andlabs"
-		if (debugToolkit) {
-			scs := spew.ConfigState{MaxDepth: 1}
-			scs.Dump(a)
-			// spew.Dump(a)
-		}
-		return
-	}
-
-	golog.Println(a...)
-}
-
-func loggo() {
-	pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
-	golog.Println("runtime.NumGoroutine() = ", runtime.NumGoroutine())
-}
-
-func logindent(depth int, format string, a ...interface{}) {
-	var tabs string
-	for i := 0; i < depth; i++ {
-		tabs = tabs + format
-	}
-
-	// newFormat := tabs + strconv.Itoa(depth) + " " + format
-	newFormat := tabs + format
-	log(debugToolkit, newFormat, a)
 }

toolkit/andlabs/main.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"embed"
-	"git.wit.org/wit/gui/toolkit"
+	// "git.wit.org/wit/gui/toolkit"
 
 	"github.com/andlabs/ui"
 	// the _ means we only need this for the init()
@@ -43,8 +43,10 @@ func Init() {
 	// log(debugToolkit, "gui/toolkit init() Setting defaultBehavior = true")
 	setDefaultBehavior(true)
 
-	mapWidgets = make(map[*andlabsT]*toolkit.Widget)
+	// mapWidgets = make(map[*andlabsT]*toolkit.Widget)
-	mapToolkits = make(map[*toolkit.Widget]*andlabsT)
+	// mapToolkits = make(map[*toolkit.Widget]*andlabsT)
+
+	andlabs = make(map[int]*andlabsT)
 }
 
 // TODO: properly exit the plugin since Quit() doesn't do it

toolkit/andlabs/plugin.go

@@ -31,6 +31,13 @@ func Action(a *toolkit.Action) {
 		rawAction(a)
 	}
 
+	if (callback == nil) {
+		if (a.Callback != nil) {
+			log(debugNow, "setting Callback", a.Callback)
+			callback = a.Callback
+		}
+	}
+
 	// f()
 	Queue(f)
 }
@@ -41,27 +48,29 @@ func rawAction(a *toolkit.Action) {
 	log(debugAction, "Action() START a.S =", a.S)
 	log(debugAction, "Action() START a.Widget =", a.Widget)
 
+	log(logInfo, "Action() START a.WidgetId =", a.WidgetId, "a.WhereId =", a.WhereId)
+
 	switch a.Type {
 	case toolkit.Add:
 		add(a)
 	case toolkit.Show:
 		a.Widget.B = true
-		show(a.Widget)
+		show(a)
 	case toolkit.Hide:
 		a.Widget.B = false
-		show(a.Widget)
+		show(a)
 	case toolkit.Enable:
 		a.Widget.B = true
-		enable(a.Widget)
+		enable(a)
 	case toolkit.Disable:
 		a.Widget.B = false
-		enable(a.Widget)
+		enable(a)
 	case toolkit.Get:
 		setText(a)
 	case toolkit.GetText:
 		switch a.Widget.Type {
 		case toolkit.Textbox:
-			t := mapToolkits[a.Widget]
+			t := andlabs[a.WidgetId]
 			a.S = t.s
 		}
 	case toolkit.Set:
@@ -122,16 +131,15 @@ func flag(a *toolkit.Action) {
 }
 
 func setText(a *toolkit.Action) {
-	w := a.Widget
+	t := andlabs[a.WidgetId]
-	if (w == nil) {
+	if (t == nil) {
-		log(debugError, "setText error. w.Widget == nil")
+		log(debugError, "setText error. andlabs[id] == nil", a.WidgetId)
 		actionDump(debugError, a)
 		return
 	}
-	t := mapToolkits[w]
+	log(debugChange, "setText() Attempt on", t.Type, "with", a.S)
-	log(debugChange, "setText() Attempt on", w.Type, "with", a.S)
 
-	switch w.Type {
+	switch t.Type {
 	case toolkit.Window:
 		t.uiWindow.SetTitle(a.S)
 	case toolkit.Tab:
@@ -142,12 +150,13 @@ func setText(a *toolkit.Action) {
 		case toolkit.SetText:
 			t.uiCheckbox.SetText(a.S)
 		case toolkit.Get:
-			w.B = t.uiCheckbox.Checked()
+			t.tw.B = t.uiCheckbox.Checked()
 		case toolkit.Set:
-			t.uiCheckbox.SetChecked(a.B)
+			// TODO: commented out while working on chan
-			w.B = a.B
+			// t.uiCheckbox.SetChecked(a.B)
+			t.tw.B = a.B
 		default:
-			log(debugError, "setText() unknown", a.Type, "on checkbox", w.Name)
+			log(debugError, "setText() unknown", a.Type, "on checkbox", t.tw.Name)
 		}
 	case toolkit.Textbox:
 		switch a.Type {
@@ -156,11 +165,11 @@ func setText(a *toolkit.Action) {
 		case toolkit.SetText:
 			t.uiMultilineEntry.SetText(a.S)
 		case toolkit.Get:
-			w.S = t.s
+			t.tw.S = t.s
 		case toolkit.GetText:
-			w.S = t.s
+			t.tw.S = t.s
 		default:
-			log(debugError, "setText() unknown", a.Type, "on checkbox", w.Name)
+			log(debugError, "setText() unknown", a.Type, "on checkbox", t.tw.Name)
 		}
 	case toolkit.Label:
 		t.uiLabel.SetText(a.S)
@@ -169,20 +178,20 @@ func setText(a *toolkit.Action) {
 	case toolkit.Slider:
 		switch a.Type {
 		case toolkit.Get:
-			w.I = t.uiSlider.Value()
+			t.tw.I = t.uiSlider.Value()
 		case toolkit.Set:
 			t.uiSlider.SetValue(a.I)
 		default:
-			log(debugError, "setText() unknown", a.Type, "on checkbox", w.Name)
+			log(debugError, "setText() unknown", a.Type, "on checkbox", t.tw.Name)
 		}
 	case toolkit.Spinner:
 		switch a.Type {
 		case toolkit.Get:
-			w.I = t.uiSpinbox.Value()
+			t.tw.I = t.uiSpinbox.Value()
 		case toolkit.Set:
 			t.uiSpinbox.SetValue(a.I)
 		default:
-			log(debugError, "setText() unknown", a.Type, "on checkbox", w.Name)
+			log(debugError, "setText() unknown", a.Type, "on checkbox", t.tw.Name)
 		}
 	case toolkit.Dropdown:
 		switch a.Type {
@@ -199,7 +208,7 @@ func setText(a *toolkit.Action) {
 				log(debugChange, "i, s", i, s)
 				if (a.S == s) {
 					t.uiCombobox.SetSelected(i)
-					log(debugChange, "setText() Dropdown worked.", w.S)
+					log(debugChange, "setText() Dropdown worked.", t.tw.S)
 					return
 				}
 			}
@@ -213,11 +222,11 @@ func setText(a *toolkit.Action) {
 				t.uiCombobox.SetSelected(i)
 			}
 		case toolkit.Get:
-			w.S = t.s
+			t.tw.S = t.s
 		case toolkit.GetText:
-			w.S = t.s
+			t.tw.S = t.s
 		default:
-			log(debugError, "setText() unknown", a.Type, "on checkbox", w.Name)
+			log(debugError, "setText() unknown", a.Type, "on checkbox", t.tw.Name)
 		}
 	case toolkit.Combobox:
 		switch a.Type {
@@ -230,13 +239,13 @@ func setText(a *toolkit.Action) {
 			t.uiEditableCombobox.SetText(a.S)
 			t.s = a.S
 		case toolkit.Get:
-			w.S = t.s
+			t.tw.S = t.s
 		case toolkit.GetText:
-			w.S = t.s
+			t.tw.S = t.s
 		default:
-			log(debugError, "setText() unknown", a.Type, "on checkbox", w.Name)
+			log(debugError, "setText() unknown", a.Type, "on checkbox", t.tw.Name)
 		}
 	default:
-		log(debugError, "plugin Send() Don't know how to setText on", w.Type, "yet", a.Type)
+		log(debugError, "plugin Send() Don't know how to setText on", t.tw.Type, "yet", a.Type)
 	}
 }

toolkit/andlabs/slider.go

@@ -7,19 +7,21 @@ import (
 	_ "github.com/andlabs/ui/winmanifest"
 )
 
-func (t *andlabsT) newSlider(w *toolkit.Widget) *andlabsT {
+func (t *andlabsT) newSlider(a *toolkit.Action) *andlabsT {
-	// make new node here
-	log(debugToolkit, w.Name, w.Type, w.X, w.Y)
 	var newt andlabsT
+	w := a.Widget
+	log(debugToolkit, w.Name, w.Type, w.X, w.Y)
 
 	s := ui.NewSlider(w.X, w.Y)
 	newt.uiSlider = s
 	newt.uiControl = s
 	newt.tw = w
+	newt.Type = toolkit.Slider
+	newt.wId = a.WidgetId
 
 	s.OnChanged(func(spin *ui.Slider) {
 		newt.tw.I = newt.uiSlider.Value()
-		newt.commonChange(newt.tw)
+		newt.commonChange(newt.tw, a.WidgetId)
 	})
 
 	return &newt
@@ -28,17 +30,15 @@ func (t *andlabsT) newSlider(w *toolkit.Widget) *andlabsT {
 func newSlider(a *toolkit.Action) {
 	var newt *andlabsT
 	w := a.Widget
-	parentW := a.Where
 	log(debugToolkit, "newSlider()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugError, "newSlider() ERROR toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugError, "newSlider() ERROR toolkit struct == nil. name=", w.Name)
 		return
 	}
 	w.X = a.X
 	w.Y = a.Y
-	newt = t.newSlider(w)
+	newt = t.newSlider(a)
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/spinner.go

@@ -7,19 +7,21 @@ import (
 	_ "github.com/andlabs/ui/winmanifest"
 )
 
-func (t *andlabsT) newSpinner(w *toolkit.Widget) *andlabsT {
+func (t *andlabsT) newSpinner(a *toolkit.Action) *andlabsT {
-	// make new node here
-	log(debugToolkit, "newSpinner()", w.X, w.Y)
 	var newt andlabsT
+	w := a.Widget
+	log(debugToolkit, "newSpinner()", w.X, w.Y)
 
 	s := ui.NewSpinbox(w.X, w.Y)
 	newt.uiSpinbox = s
 	newt.uiControl = s
 	newt.tw = w
+	newt.wId = a.WidgetId
+	newt.Type = toolkit.Spinner
 
 	s.OnChanged(func(s *ui.Spinbox) {
 		newt.tw.I = newt.uiSpinbox.Value()
-		newt.commonChange(newt.tw)
+		newt.commonChange(newt.tw, a.WidgetId)
 	})
 
 	return &newt
@@ -28,16 +30,14 @@ func (t *andlabsT) newSpinner(w *toolkit.Widget) *andlabsT {
 func newSpinner(a *toolkit.Action) {
 	var newt *andlabsT
 	w := a.Widget
-	parentW := a.Where
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugError, "NewSpinner() toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugError, "NewSpinner() toolkit struct == nil. name=", w.Name)
 		return
 	}
 	w.X = a.X
 	w.Y = a.Y
-	newt = t.newSpinner(w)
+	newt = t.newSpinner(a)
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/structs.go

@@ -5,14 +5,19 @@ import "git.wit.org/wit/gui/toolkit"
 import "github.com/andlabs/ui"
 import _ "github.com/andlabs/ui/winmanifest"
 
+var andlabs map[int]*andlabsT
+var callback func(int)
+
 // stores the raw toolkit internals
 type andlabsT struct {
-	id     string
+	wId	int	// widget ID
+	Type	toolkit.WidgetType
 
 	Name   string
 	// Type   toolkit.WidgetType
 	Width  int
 	Height int
+
 	tw	*toolkit.Widget
 	parent	*andlabsT
 

toolkit/andlabs/tab.go

@@ -19,36 +19,43 @@ import (
 	once there is one. If you send a Window here, it will replace
 	any existing tabs rather than adding a new one
 */
-func (t *andlabsT) newTab(name string) *andlabsT {
+func (t *andlabsT) newTab(a *toolkit.Action) {
 	// var w *ui.Window
 	var newt *andlabsT
 
-	log(debugToolkit, "gui.toolkit.AddTab()")
+	log(debugToolkit, "newTab() START", a.WidgetId, a.WhereId)
-
-	if (t.uiWindow == nil) {
-		log(debugToolkit, "gui.Toolkit.UiWindow == nil. I can't add a toolbar without window")
-		return nil
-	}
 
 	if (t.uiTab == nil) {
+		if (t.uiWindow == nil) {
+			log(debugToolkit, "newTab() uiWindow == nil. I can't add a toolbar without window", a.WidgetId, a.WhereId)
+			return
+		}
 		// this means you have to make a new tab
-		log(debugToolkit, "gui.toolkit.NewTab() GOOD. This should be the first tab:", name)
+		log(debugToolkit, "newTab() GOOD. This should be the first tab:", a.WidgetId, a.WhereId)
-		newt = rawTab(t.uiWindow, name)
+		newt = rawTab(t.uiWindow, a.Title)
 		t.uiTab = newt.uiTab
 	} else {
 		// this means you have to append a tab
-		log(debugToolkit, "gui.toolkit.NewTab() GOOD. This should be an additional tab:", name)
+		log(debugToolkit, "newTab() GOOD. This should be an additional tab:", a.WidgetId, a.WhereId)
-		newt = t.appendTab(name)
+		newt = t.appendTab(a.Title)
 	}
 
-	newt.Name = name
+	// add the structure to the array
+	if (andlabs[a.WidgetId] == nil) {
+		log(logInfo, "newTab() MAPPED", a.WidgetId, a.WhereId)
+		andlabs[a.WidgetId] = newt
+		newt.Type = a.Widget.Type
+	} else {
+		log(debugError, "newTab() DO WHAT?", a.WidgetId, a.WhereId)
+		log(debugError, "THIS IS BAD")
+	}
+
+	newt.Name = a.Title
 
 	log(debugToolkit, "t:")
 	t.Dump(debugToolkit)
 	log(debugToolkit, "newt:")
 	newt.Dump(debugToolkit)
-
-	return newt
 }
 
 // This sets _all_ the tabs to Margin = true
@@ -64,29 +71,21 @@ func tabSetMargined(tab *ui.Tab, b bool) {
 
 func rawTab(w *ui.Window, name string) *andlabsT {
 	var newt andlabsT
-	log(debugToolkit, "gui.toolkit.NewTab() ADD", name)
+	log(debugToolkit, "rawTab() START", name)
 
 	if (w == nil) {
-		log(debugToolkit, "gui.toolkit.NewTab() node.UiWindow == nil. I can't add a tab without a window")
+		log(debugError, "UiWindow == nil. I can't add a tab without a window")
-		log(debugToolkit, "gui.toolkit.NewTab() node.UiWindow == nil. I can't add a tab without a window")
+		log(debugError, "UiWindow == nil. I can't add a tab without a window")
-		log(debugToolkit, "gui.toolkit.NewTab() node.UiWindow == nil. I can't add a tab without a window")
+		log(debugError, "UiWindow == nil. I can't add a tab without a window")
 		sleep(1)
 		return nil
 	}
-	log(debugToolkit, "gui.toolkit.AddTab() START name =", name)
+
 	tab := ui.NewTab()
-	w.SetMargined(margin)
-
-	hbox := ui.NewHorizontalBox() // this makes everything go along the horizon
-	hbox.SetPadded(padded)
-	tab.Append(name, hbox)
-	tabSetMargined(tab, margin) // TODO: run this in the right place(?)
 	w.SetChild(tab)
-
-	newt.uiWindow = w
 	newt.uiTab = tab
 	newt.uiControl = tab
-	newt.uiBox = hbox
+	log(debugToolkit, "rawTab() END", name)
 	return &newt
 }
 
@@ -120,20 +119,14 @@ func (t *andlabsT) appendTab(name string) *andlabsT {
 }
 
 func newTab(a *toolkit.Action) {
-	parentW := a.Where
+	// w := a.Widget
-	w := a.Widget
+	log(debugToolkit, "newTab()", a.WhereId)
-	var newt *andlabsT
-	log(debugToolkit, "gui.andlabs.NewTab()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugToolkit, "go.andlabs.NewTab() toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugToolkit, "newTab() parent toolkit == nil. new tab can not be made =", a.WhereId)
+		log(debugToolkit, "look for a window? check for an existing tab?")
 		return
 	}
-	newt = t.newTab(w.Name)
+	t.newTab(a)
-	mapWidgetsToolkits(a, newt)
-}
-
-func doTab(a *toolkit.Action) {
-	newTab(a)
 }

toolkit/andlabs/textbox.go

@@ -17,6 +17,7 @@ func (t *andlabsT) newTextbox(w *toolkit.Widget) *andlabsT {
 
 	newt.Name = w.Name
 	newt.tw = w
+	newt.Type = toolkit.Textbox
 
 	c.OnChanged(func(spin *ui.MultilineEntry) {
 		t.s = spin.Text()
@@ -29,16 +30,14 @@ func (t *andlabsT) newTextbox(w *toolkit.Widget) *andlabsT {
 
 func newTextbox(a *toolkit.Action) {
 	w := a.Widget
-	parentW := a.Where
 	log(debugToolkit, "newCombobox()", w.Name)
 
-	t := mapToolkits[parentW]
+	t := andlabs[a.WhereId]
 	if (t == nil) {
-		log(debugToolkit, "newCombobox() toolkit struct == nil. name=", parentW.Name, w.Name)
+		log(debugToolkit, "newCombobox() toolkit struct == nil. name=", w.Name)
 		listMap(debugToolkit)
 		return
 	}
 	newt := t.newTextbox(w)
 	place(a, t, newt)
-	mapWidgetsToolkits(a, newt)
 }

toolkit/andlabs/widget.go

@@ -1,69 +1,24 @@
 package main
 
 import (
-	"git.wit.org/wit/gui/toolkit"
+	// "git.wit.org/wit/gui/toolkit"
 )
 
 // This is a map between the widgets in wit/gui and the internal structures of gocui
 
-var mapWidgets map[*andlabsT]*toolkit.Widget
+// var mapWidgets map[*andlabsT]*toolkit.Widget
-var mapToolkits map[*toolkit.Widget]*andlabsT
+// var mapToolkits map[*toolkit.Widget]*andlabsT
 
 // This lists out the known mappings
 // deprecate and use instead the GUI interface
 func listMap(b bool) {
 	log(b, "listMap() disabled HERE. output too big")
 	return
-	for t, w := range mapWidgets {
-		log(b, "andlabs =", t.Name, "widget =", w.Name)
-	}
 	log(b, "listMap() HERE mapToolkits()")
-	for w, t := range mapToolkits {
+	for i, t := range andlabs {
-		log(b, "andlabs =", t, "widget =", w.Name)
+		log(b, "andlabs =", t, "widgetId =", i)
 		t.Dump(b)
 	}
 	log(b, "listMap() HERE mapWidgets()")
 	log(b, "listMap() HERE FIXME. output too big")
 }
-
-func mapWidgetsToolkits(a *toolkit.Action, t *andlabsT) {
-	w := a.Widget
-	if ((mapToolkits[w] == nil) && (mapWidgets[t] == nil)) {
-		log(debugToolkit, "map a new widget", w, t)
-		mapToolkits[w] = t
-		mapWidgets[t] = w
-		return
-	}
-
-	if (mapToolkits[w] != nil) {
-		tw := mapToolkits[w]
-		if (tw == nil) {
-			// logic corruption somewhere? Have you been deleting things recently?
-			log(true, "mapToolkits[w] is set, but mapWidgets[t] is nil")
-			panic("WTF mapWidgets[t] == nil")
-		}
-		log(debugToolkit, "mapToolkits[w] is", tw)
-		if (tw == nil) {
-			log(debugError, "BAD map? mapWidgets[w] tw == nil")
-		} else {
-			log(debugError, "BAD map? mapWidgets[w] is", tw)
-			tw.Dump(debugError)
-		}
-	}
-
-	if (mapWidgets[t] != nil) {
-		wt := mapWidgets[t]
-		if (mapToolkits[w] == nil) {
-			// logic corruption somewhere? Have you been deleting things recently?
-			log(true, "mapWidgets[t] is set, but mapToolkits[w] is nil")
-			panic("WTF mapToolkits[w] == nil")
-		}
-		if (wt == nil) {
-			log(debugError, "BAD map? mapWidgets[t] wt == nil")
-		} else {
-			log(debugError, "BAD map? mapWidgets[t] is", wt)
-			widgetDump(debugError, wt)
-		}
-	}
-	log(debugToolkit, "map of widget worked", w.Type, ",", w.Name)
-}

toolkit/andlabs/window.go

@@ -27,13 +27,15 @@ func newWindow(a *toolkit.Action) {
 	}
 	newt = new(andlabsT)
 	newt.tw = w
+	newt.Type = toolkit.Window
+	newt.wId = a.WidgetId
 
 	// menubar bool is if the OS defined border on the window should be used
 	win := ui.NewWindow(w.Name, w.Width, w.Height, menubar)
 	win.SetBorderless(canvas)
 	win.SetMargined(margin)
 	win.OnClosing(func(*ui.Window) bool {
-		newt.commonChange(newt.tw)
+		newt.commonChange(newt.tw, a.WidgetId)
 		return true
 	})
 	win.Show()
@@ -42,16 +44,17 @@ func newWindow(a *toolkit.Action) {
 	// newt.UiWindowBad = win // deprecate this as soon as possible
 	newt.Name = w.Name
 
-	mapWidgetsToolkits(a, newt)
+	andlabs[a.WidgetId] = newt
 	return
 }
 
 func (t *andlabsT) SetWindowTitle(title string) {
 	log(debugToolkit, "toolkit NewWindow", t.Name, "title", title)
 	win := t.uiWindow
-	if (win != nil) {
+	if (win == nil) {
-		win.SetTitle(title)
+		log(debugError, "Error: no window", t.wId)
 	} else {
+		win.SetTitle(title)
 		log(debugToolkit, "Setting the window title", title)
 	}
 }

toolkit/democui/log.go

@@ -1,135 +1,22 @@
-//
-// version v1.3
-//
-// I like things to be easy.
-//
-// combining logging inside of a gui made me do this
-//
-// this means all the log settings are in one place. it should allow
-// things to be over-ridden externally to the library
-// but still allow command line --args to pass debugging settings
-//
-// I also have a generic sleep() and exit() in here because it's simple
-//
-// Usage:
-//
-// log("something", foo, bar)
-// var DEBUG bool = true
-// log(DEBUG, "something else", someOtherVariable)  # if DEBUG == false, return doing nothing
-// log(SPEW, "something else", someOtherVariable)   # this get's sent to spew.Dump(). Very useful for debugging!
-//
 package main
 
 import 	(
 	"os"
-	golog "log"
+	witlog "git.wit.org/wit/gui/log"
-	"time"
-	"reflect"
-	"github.com/davecgh/go-spew/spew"
 )
 
-var 	LOGOFF	bool	= false	// turn this off, all logging stops
-var	WARN	bool
-var 	INFO	bool
-
-type spewt struct {
-	a bool
-}
-
-var SPEW spewt
-
-
-/*
-	sleep()		# you know what this does? sleeps for 1 second. yep. dump. easy.
-	sleep(.1)	# you know what this does? yes, it sleeps for 1/10th of a second
-*/
-func sleep(a ...any) {
-	if (a == nil) {
-		time.Sleep(time.Second)
-		return
-	}
-
-	log(true, "sleep", a[0])
-
-	switch a[0].(type) {
-	case int:
-		time.Sleep(time.Duration(a[0].(int)) * time.Second)
-	case float64:
-		time.Sleep(time.Duration(a[0].(float64) * 1000) * time.Millisecond)
-	default:
-		log("sleep a[0], type = ", a[0], reflect.TypeOf(a[0]))
-	}
-}
-
-/*
-	exit()		# yep. exits. I guess everything must be fine
-	exit(3)		# I guess 3 it is then
-	exit("dont like apples")	# ok. I'll make a note of that
-*/
-func exit(a ...any) {
-	log(true, "exit", a)
-	//if (a) {
-	//	os.Exit(a)
-	//}
-	os.Exit(0)
-}
-
-/*
-	I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
-	I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
-	implementation is probably faster than all of those because you just set one bool to FALSE
-	and it all stops.
-	Sometimes I need to capture to stdout, sometimes stdout can't
-	work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread
-	over 8 million references in every .go file. I'm tapping out and putting
-	it in one place. here it is. Also, this makes having debug levels really fucking easy.
-	You can define whatever level of logging you want from anywhere (command line) etc.
-
-	log()		# doesn't do anything
-	log(stuff)	# sends it to whatever log you define in a single place. here is the place
-*/
-
 func log(a ...any) {
-	if (LOGOFF) {
+	witlog.Log(a...)
-		return
 }
 
-	if (a == nil) {
+func sleep(a ...any) {
-		return
+	witlog.Sleep(a...)
-	}
-	var tbool bool
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(tbool)) {
-		if (a[0] == false) {
-			return
-		}
-		a[0] = "GUI/Toolkit/gocui"
 }
 
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(SPEW)) {
+func exit(a ...any) {
-		// a = a[1:]
+	witlog.Exit(a...)
-		a[0] = "GUI/Toolkit/gocui"
-		if (debugToolkit) {
-			scs := spew.ConfigState{MaxDepth: 1}
-			scs.Dump(a)
-			// spew.Dump(a)
-		}
-		return
-	}
-
-	golog.Println(a...)
-}
-
-func logindent(depth int, format string, a ...interface{}) {
-	var tabs string
-	for i := 0; i < depth; i++ {
-		tabs = tabs + format
-	}
-
-	// newFormat := tabs + strconv.Itoa(depth) + " " + format
-	newFormat := tabs + format
-	log(debugToolkit, newFormat, a)
 }
 
 func setOutput(f *os.File) {
-	golog.SetOutput(f)
+	witlog.SetOutput(f)
 }

toolkit/gocui/log.go

@@ -1,135 +1,22 @@
-//
-// version v1.3
-//
-// I like things to be easy.
-//
-// combining logging inside of a gui made me do this
-//
-// this means all the log settings are in one place. it should allow
-// things to be over-ridden externally to the library
-// but still allow command line --args to pass debugging settings
-//
-// I also have a generic sleep() and exit() in here because it's simple
-//
-// Usage:
-//
-// log("something", foo, bar)
-// var DEBUG bool = true
-// log(DEBUG, "something else", someOtherVariable)  # if DEBUG == false, return doing nothing
-// log(SPEW, "something else", someOtherVariable)   # this get's sent to spew.Dump(). Very useful for debugging!
-//
 package main
 
 import 	(
 	"os"
-	golog "log"
+	witlog "git.wit.org/wit/gui/log"
-	"time"
-	"reflect"
-	"github.com/davecgh/go-spew/spew"
 )
 
-var 	LOGOFF	bool	= false	// turn this off, all logging stops
-var	WARN	bool
-var 	INFO	bool
-
-type spewt struct {
-	a bool
-}
-
-var SPEW spewt
-
-
-/*
-	sleep()		# you know what this does? sleeps for 1 second. yep. dump. easy.
-	sleep(.1)	# you know what this does? yes, it sleeps for 1/10th of a second
-*/
-func sleep(a ...any) {
-	if (a == nil) {
-		time.Sleep(time.Second)
-		return
-	}
-
-	log(true, "sleep", a[0])
-
-	switch a[0].(type) {
-	case int:
-		time.Sleep(time.Duration(a[0].(int)) * time.Second)
-	case float64:
-		time.Sleep(time.Duration(a[0].(float64) * 1000) * time.Millisecond)
-	default:
-		log("sleep a[0], type = ", a[0], reflect.TypeOf(a[0]))
-	}
-}
-
-/*
-	exit()		# yep. exits. I guess everything must be fine
-	exit(3)		# I guess 3 it is then
-	exit("dont like apples")	# ok. I'll make a note of that
-*/
-func exit(a ...any) {
-	log(true, "exit", a)
-	//if (a) {
-	//	os.Exit(a)
-	//}
-	os.Exit(0)
-}
-
-/*
-	I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
-	I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
-	implementation is probably faster than all of those because you just set one bool to FALSE
-	and it all stops.
-	Sometimes I need to capture to stdout, sometimes stdout can't
-	work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread
-	over 8 million references in every .go file. I'm tapping out and putting
-	it in one place. here it is. Also, this makes having debug levels really fucking easy.
-	You can define whatever level of logging you want from anywhere (command line) etc.
-
-	log()		# doesn't do anything
-	log(stuff)	# sends it to whatever log you define in a single place. here is the place
-*/
-
 func log(a ...any) {
-	if (LOGOFF) {
+	witlog.Log(a...)
-		return
 }
 
-	if (a == nil) {
+func sleep(a ...any) {
-		return
+	witlog.Sleep(a...)
-	}
-	var tbool bool
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(tbool)) {
-		if (a[0] == false) {
-			return
-		}
-		a[0] = "GUI/Toolkit/gocui"
 }
 
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(SPEW)) {
+func exit(a ...any) {
-		// a = a[1:]
+	witlog.Exit(a...)
-		a[0] = "GUI/Toolkit/gocui"
-		if (debugToolkit) {
-			scs := spew.ConfigState{MaxDepth: 1}
-			scs.Dump(a)
-			// spew.Dump(a)
-		}
-		return
-	}
-
-	golog.Println(a...)
-}
-
-func logindent(depth int, format string, a ...interface{}) {
-	var tabs string
-	for i := 0; i < depth; i++ {
-		tabs = tabs + format
-	}
-
-	// newFormat := tabs + strconv.Itoa(depth) + " " + format
-	newFormat := tabs + format
-	log(debugToolkit, newFormat, a)
 }
 
 func setOutput(f *os.File) {
-	golog.SetOutput(f)
+	witlog.SetOutput(f)
 }

toolkit/widget.go

@@ -18,7 +18,6 @@ type ActionType int
 // Could a protobuf be used here? (Can functions be passed?)
 type Widget struct {
 	Name   string
-	// Action string		// "New", "Delete", "Set", aka something to do
 	Type  WidgetType
 
 	// This function is how you interact with the toolkit
@@ -57,14 +56,17 @@ type Widget struct {
 
 type Action struct {
 	Type ActionType
+	ActionT ActionType
+	WidgetT WidgetType
+
+	WidgetId int
+	WhereId int
+	Title string
 
 	// this should be the widget
 	// if the action is New, Hide, Enable, etc
 	Widget *Widget
-
+	Callback  func(int)
-	// this is the widget 
-	// where the other one should be put on New, Move, etc
-	Where *Widget
 
 	// This is how the values are passed back and forth
 	// values from things like checkboxes & dropdown's