lots cleaner code between the pluginv0.6.1

    Queue() around SetText is helping userspace crashing
    merge forceDump(bool) into Dump()
    debugging output configuration is pretty clean
    keep cutting down duplicate things
    --gui-verbose flag works
    make label "standard" code
    add debug.FreeOSMemory()
    move the GO language internals to display in the GUI
    update push to do tags and go to github.com/wit-go/
    remove the other license file
        it might be confusing golang.org and github
    proper WidgetType
    added a Quit() button

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

19 files changed, 602 insertions, 374 deletions

diff --git a/toolkit/andlabs/box.go b/toolkit/andlabs/box.go
index 463b89a..430e78e 100644
--- a/toolkit/andlabs/box.go
+++ b/toolkit/andlabs/box.go
@@ -11,7 +11,7 @@ func (t *andlabsT) GetBox() *ui.Box {
 // create a new box
 func (t *andlabsT) NewBox() *andlabsT {
 	log(debugToolkit, "gui.Toolbox.NewBox() START create default")
-	t.Dump()
+	t.Dump(debugToolkit)
 	if (t.uiGroup != nil) {
 		log(debugToolkit, "\tgui.Toolbox.NewBox() is a Group")
 		var newTK andlabsT
@@ -49,6 +49,6 @@ func (t *andlabsT) NewBox() *andlabsT {
 		return &newT
 	}
 	log(debugToolkit, "\tgui.Toolbox.NewBox() FAILED. Couldn't figure out where to make a box")
-	t.Dump()
+	t.Dump(debugToolkit)
 	return nil
 }
diff --git a/toolkit/andlabs/button.go b/toolkit/andlabs/button.go
index 9933e1f..deb34fa 100644
--- a/toolkit/andlabs/button.go
+++ b/toolkit/andlabs/button.go
@@ -7,7 +7,7 @@ import (
 	"git.wit.org/wit/gui/toolkit"
 )
 
-func NewButton(parentW *toolkit.Widget, w *toolkit.Widget) {
+func newButton(parentW *toolkit.Widget, w *toolkit.Widget) {
 	var t, newt *andlabsT
 	var b *ui.Button
 	log(debugToolkit, "gui.andlabs.NewButton()", w.Name)
@@ -25,19 +25,11 @@ func NewButton(parentW *toolkit.Widget, w *toolkit.Widget) {
 
 	b = ui.NewButton(w.Name)
 	newt.uiButton = b
+	newt.tw = w
+	newt.parent = t
 
 	b.OnClicked(func(*ui.Button) {
-		log(debugChange, "TODO: SHOULD LEAVE Button click HERE VIA channels. button name =", w.Name)
-		log(debugChange, "FOUND WIDGET =", w)
-		if (w.Custom == nil) {
-			log(debugChange, "WIDGET DOES NOT have Custom()")
-			log(debugChange, "TODO: NOTHING TO DO button name =", w.Name)
-			return
-		}
-		// t.Dump()
-		// newt.Dump()
-		log(debugChange, "Running w.Custom()")
-		w.Custom()
+		newt.commonChange(newt.tw)
 	})
 
 	log(debugToolkit, "gui.Toolbox.NewButton() about to append to Box parent t:", w.Name)
@@ -55,3 +47,41 @@ func NewButton(parentW *toolkit.Widget, w *toolkit.Widget) {
 
 	mapWidgetsToolkits(w, newt)
 }
+
+func doButton(p *toolkit.Widget, c *toolkit.Widget) {
+	if broken(c) {
+		return
+	}
+	if (c.Action == "New") {
+		newButton(p, c)
+		return
+	}
+	ct := mapToolkits[c]
+	if (ct == nil) {
+		log(true, "Trying to do something on a widget that doesn't work or doesn't exist or something", c)
+		return
+	}
+	if ct.broken() {
+		log(true, "Button() ct.broken", ct)
+		return
+	}
+	if (ct.uiButton == nil) {
+		log(true, "Button() uiButton == nil", ct)
+		return
+	}
+	log(true, "Going to attempt:", c.Action)
+	switch c.Action {
+	case "Enable":
+		ct.uiButton.Enable()
+	case "Disable":
+		ct.uiButton.Disable()
+	case "Show":
+		ct.uiButton.Show()
+	case "Hide":
+		ct.uiButton.Hide()
+	case "Set":
+		ct.uiButton.SetText(c.S)
+	default:
+		log(true, "Can't do", c.Action, "to a Button")
+	}
+}
diff --git a/toolkit/andlabs/checkbox.go b/toolkit/andlabs/checkbox.go
index 5466d17..29a8e4d 100644
--- a/toolkit/andlabs/checkbox.go
+++ b/toolkit/andlabs/checkbox.go
@@ -1,36 +1,29 @@
 package main
 
-import "git.wit.org/wit/gui/toolkit"
+import (
+	"git.wit.org/wit/gui/toolkit"
+	"github.com/andlabs/ui"
+	_ "github.com/andlabs/ui/winmanifest"
+)
 
-import "github.com/andlabs/ui"
-import _ "github.com/andlabs/ui/winmanifest"
-
-func (t andlabsT) NewCheckbox(name string, f func()) *andlabsT {
-	log(debugToolkit, "gui.Toolkit.NewCheckbox()", name)
+func (t andlabsT) NewCheckbox(w *toolkit.Widget) *andlabsT {
+	log(debugToolkit, "NewCheckbox()", w.Name, w.Type)
 	var newt andlabsT
+	newt.tw = w
 
 	if t.broken() {
 		return nil
 	}
 
-	c := ui.NewCheckbox(name)
+	c := ui.NewCheckbox(w.Name)
 	newt.uiCheckbox = c
 	newt.uiBox = t.uiBox
 	t.uiBox.Append(c, stretchy)
-	// newt.Custom = f
 
 	c.OnToggled(func(spin *ui.Checkbox) {
-		// log(debugToolkit, "gui.Toolkit.NewCheckbox() clicked", name)
-		newt.commonChange("Checkbox")
-		/*
-		if (f != nil) {
-			log(debugToolkit, "Run custom() here", f)
-			log(SPEW, f)
-			f()
-		} else {
-			log(debugToolkit, "No custom() function here")
-		}
-		*/
+		newt.tw.B = newt.Checked()
+		log(debugChange, "val =", newt.tw.B)
+		newt.commonChange(newt.tw)
 	})
 
 	return &newt
@@ -45,25 +38,52 @@ func (t andlabsT) Checked() bool {
 }
 
 func NewCheckbox(parentW *toolkit.Widget, w *toolkit.Widget) {
-	log(debugToolkit, "gui.andlabs.NewCheckbox()", w.Name)
+	log(debugToolkit, "NewCheckbox()", w.Name)
 
 	t := mapToolkits[parentW]
 	if (t == nil) {
-		listMap()
-	}
-	newt := t.NewCheckbox(w.Name, w.Custom)
-	newt.Custom = w.Custom
-	/*
-	if (w.Custom != nil) {
-		log(true, "go.andlabs.NewCheckbox() toolkit struct == nil. name=", parentW.Name, w.Name)
-		log(true, "Run custom() START here", w.Custom)
-		w.Custom()
-		log(true, "Run custom() END")
-		// exit("ran it here")
-	} else {
-		log(true, "No custom() function here")
-		// exit("nothing here")
+		listMap(debugError)
+		return
 	}
-	*/
+	newt := t.NewCheckbox(w)
 	mapWidgetsToolkits(w, newt)
 }
+
+func doCheckbox(p *toolkit.Widget, c *toolkit.Widget) {
+	if broken(c) {
+		return
+	}
+	if (c.Action == "New") {
+		NewCheckbox(p, c)
+		return
+	}
+	ct := mapToolkits[c]
+	if (ct == nil) {
+		log(true, "Trying to do something on a widget that doesn't work or doesn't exist or something", c)
+		return
+	}
+	if ct.broken() {
+		log(true, "checkbox() ct.broken", ct)
+		return
+	}
+	if (ct.uiCheckbox == nil) {
+		log(true, "checkbox() uiCheckbox == nil", ct)
+		return
+	}
+	log(true, "Going to attempt:", c.Action)
+	switch c.Action {
+	case "Enable":
+		ct.uiCheckbox.Enable()
+	case "Disable":
+		ct.uiCheckbox.Disable()
+	case "Show":
+		ct.uiCheckbox.Show()
+	case "Hide":
+		ct.uiCheckbox.Hide()
+	case "Set":
+		ct.uiCheckbox.SetText(c.S)
+		ct.uiCheckbox.SetChecked(c.B)
+	default:
+		log(true, "Can't do", c.Action, "to a checkbox")
+	}
+}
diff --git a/toolkit/andlabs/common.go b/toolkit/andlabs/common.go
index 94e19e1..31b73e6 100644
--- a/toolkit/andlabs/common.go
+++ b/toolkit/andlabs/common.go
@@ -1,5 +1,9 @@
 package main
 
+import (
+	"git.wit.org/wit/gui/toolkit"
+)
+
 // This is important. This sets the defaults for the gui. Without this, there isn't correct padding, etc
 func init() {
 	// Can you pass values to a plugin init() ? Otherwise, there is no way to safely print
@@ -7,79 +11,52 @@ func init() {
 	setDefaultBehavior(true)
 }
 
-func (t andlabsT) commonChange(widget string) {
-	s := t.String()
-	log(debugChange, "commonChange() START widget   =", widget)
-	log(debugChange, "commonChange() t.String =", s)
-	if (t.OnChanged != nil) {
-		// log(debugChange, "commonChange() toolkit.OnChanged() START")
-		// t.OnChanged(&t)
-		exit("OnChanged is not implemented. TODO: FIX THIS")
-		return
-	}
-	if (t.Custom != nil) {
-		log(debugChange, "commonChange() START toolkit.Custom()")
-		t.Custom()
-		log(debugChange, "commonChange() END toolkit.Custom()")
-		return
-	}
-	if (widget == "Checkbox") {
-		log(debugChange, "commonChange() END Need to read the Checkbox value")
+func (t andlabsT) commonChange(tw *toolkit.Widget) {
+	log(debugChange, "commonChange() START widget   =", t.Name, t.Type)
+	if (tw == nil) {
+		log(true, "commonChange() What the fuck. there is no widget t.tw == nil")
 		return
 	}
-	if (widget == "Dropdown") {
-		t.getDropdown()
-		if (t.tw == nil) {
-			log(debugChange, "commonChange() END tw.Custom == nil")
-		}
-		if (t.tw.Custom == nil) {
-			log(debugChange, "commonChange() END Dropdown (no custom())")
-		}
-		t.tw.Custom()
-		log(debugChange, "commonChange() END Dropdown")
+	if (tw.Custom == nil) {
+		log(debugChange, "commonChange() END    Widget.Custom() = nil", t.tw.Name, t.tw.Type)
 		return
 	}
-	log(debugChange, "commonChange() t.String =", s)
-	log(debugChange, "commonChange() ENDED without finding any callback")
-}
-
-func (t *andlabsT) getDropdown() {
-	log(debugChange, "commonChange() Need to read the dropdown menu")
-	if (t.uiCombobox == nil) {
-		log(debugChange, "commonChange() END BAD NEWS. t.uiCombobox == nil")
-		return
-	}
-	i := t.uiCombobox.Selected()
-	log(debugChange, "commonChange() t.uiCombobox = ", i)
-	if (t.tw == nil) {
-		log(debugChange, "commonChange() END tw = nil")
-		return
-	}
-	t.tw.S = t.String()
-	log(debugChange, "commonChange() END tw = ", t.tw)
-	return
+	tw.Custom()
+	log(debugChange, "commonChange() END   Widget.Custom()", t.tw.Name, t.tw.Type)
 }
 
 // does some sanity checks on the internal structs of the binary tree
 // TODO: probably this should not panic unless it's running in devel mode (?)
+// TODO: redo this now that WidgetType is used and send() is used to package plugins
 func (t *andlabsT) broken() bool {
+	if (t.parent != nil) {
+		return false
+	}
 	if (t.uiBox == nil) {
 		if (t.uiWindow != nil) {
-			log(debugToolkit, "gui.Toolkit.UiBox == nil. This is an empty window. Try to add a box")
+			log(debugToolkit, "UiBox == nil. This is an empty window. Try to add a box")
 			t.NewBox()
 			return false
 		}
-		log(debugToolkit, "gui.Toolkit.UiBox == nil. I can't add a widget without a place to put it")
+		log(true, "UiBox == nil. I can't add a widget without a place to put it")
 		// log(debugToolkit, "probably could just make a box here?")
 		// corruption or something horrible?
+		t.Dump(true)
 		panic("wit/gui toolkit/andlabs func broken() invalid goroutine access into this toolkit?")
 		panic("wit/gui toolkit/andlabs func broken() this probably should not cause the app to panic here (?)")
 		return true
 	}
 	if (t.uiWindow == nil) {
-		log(debugToolkit, "gui.Toolkit.UiWindow == nil. I can't add a widget without a place to put it (IGNORING FOR NOW)")
-		forceDump(t)
+		log(debugToolkit, "UiWindow == nil. I can't add a widget without a place to put it (IGNORING FOR NOW)")
+		t.Dump(debugToolkit)
 		return false
 	}
 	return false
 }
+func broken(w *toolkit.Widget) bool {
+	if (w == nil) {
+		log(true, "widget == nil. I can't do anything widget")
+		return true
+	}
+	return false
+}
diff --git a/toolkit/andlabs/debug.go b/toolkit/andlabs/debug.go
index 9b7e160..befbaa0 100644
--- a/toolkit/andlabs/debug.go
+++ b/toolkit/andlabs/debug.go
@@ -1,6 +1,6 @@
 package main
 
-// import "git.wit.org/wit/gui/toolkit"
+import "git.wit.org/wit/gui/toolkit"
 
 import "github.com/davecgh/go-spew/spew"
 
@@ -15,6 +15,8 @@ var margin bool // add space around the frames of windows
 
 var debugToolkit bool
 var debugChange bool
+var debugPlugin bool
+var debugError bool = true
 // var DebugToolkit bool
 
 // This is important. This sets the defaults for the gui. Without this, there isn't correct padding, etc
@@ -59,42 +61,35 @@ func (t *andlabsT) String() string {
 	return t.GetText()
 }
 
-func forceDump(t *andlabsT) {
-	tmp := debugToolkit
-	debugToolkit = true
-	t.Dump()
-	debugToolkit = tmp
-}
-
 func (t *andlabsT) GetText() string {
-	log(debugToolkit, "gui.Toolkit.GetText() Enter debugToolkit=", debugToolkit)
+	log(debugToolkit, "GetText() Enter debugToolkit=", debugToolkit)
 	if (t.uiEntry != nil) {
-		log(debugToolkit, "gui.Toolkit.uiEntry.Text() =", t.uiEntry.Text())
+		log(debugToolkit, "uiEntry.Text() =", t.uiEntry.Text())
 		return t.uiEntry.Text()
 	}
 	if (t.uiMultilineEntry != nil) {
-		log(debugToolkit, "gui.Toolkit.uiMultilineEntry.Text() =", t.uiMultilineEntry.Text())
+		log(debugToolkit, "uiMultilineEntry.Text() =", t.uiMultilineEntry.Text())
 		text := t.uiMultilineEntry.Text()
-		log(debugToolkit, "gui.Toolkit.uiMultilineEntry.Text() =", text)
+		log(debugToolkit, "uiMultilineEntry.Text() =", text)
 		t.text = text
 		return text
 	}
 	if (t.uiCombobox != nil) {
-		log(debugToolkit, "gui.Toolkit.uiCombobox() =", t.text)
+		log(debugToolkit, "uiCombobox() =", t.text)
 		return t.text
 	}
 	return ""
 }
 
 func (t *andlabsT) SetText(s string) bool {
-	log(debugToolkit, "gui.Toolkit.Text() SetText() Enter")
+	log(debugToolkit, "Text() SetText() Enter")
 	if (t.uiEntry != nil) {
-		log(debugToolkit, "gui.Toolkit.Value() =", t.uiEntry.Text)
+		log(debugToolkit, "Value() =", t.uiEntry.Text)
 		t.uiEntry.SetText(s)
 		return true
 	}
 	if (t.uiMultilineEntry != nil) {
-		log(debugToolkit, "gui.Toolkit.Value() =", t.uiMultilineEntry.Text)
+		log(debugToolkit, "Value() =", t.uiMultilineEntry.Text)
 		t.uiMultilineEntry.SetText(s)
 		return true
 	}
@@ -103,91 +98,101 @@ func (t *andlabsT) SetText(s string) bool {
 
 func sanity(t *andlabsT) bool {
 	if (debugToolkit) {
-		log(debugToolkit, "gui.Toolkit.Value() Enter")
+		log(debugToolkit, "Value() Enter")
 		scs := spew.ConfigState{MaxDepth: 1}
 		scs.Dump(t)
 	}
 	if (t.uiEntry == nil) {
-		log(debugToolkit, "gui.Toolkit.Value() =", t.uiEntry.Text)
+		log(debugToolkit, "Value() =", t.uiEntry.Text)
 		return false
 	}
 	return true
 }
 
 func (t *andlabsT) SetValue(i int) bool {
-	log(debugToolkit, "gui.Toolkit.SetValue() START")
+	log(debugToolkit, "SetValue() START")
 	if (sanity(t)) {
 		return false
 	}
-	t.Dump()
+	t.Dump(debugToolkit)
 	// panic("got to toolkit.SetValue")
 	return true
 }
 
 func (t *andlabsT) Value() int {
 	if (debugToolkit) {
-		log(debugToolkit, "gui.Toolkit.Value() Enter")
+		log(debugToolkit, "Value() Enter")
 		scs := spew.ConfigState{MaxDepth: 1}
 		scs.Dump(t)
 	}
 	if (t == nil) {
-		log(debugToolkit, "gui.Toolkit.Value() can not get value t == nil")
+		log(debugToolkit, "Value() can not get value t == nil")
 		return 0
 	}
 	if (t.uiSlider != nil) {
-		log(debugToolkit, "gui.Toolkit.Value() =", t.uiSlider.Value)
+		log(debugToolkit, "Value() =", t.uiSlider.Value)
 		return t.uiSlider.Value()
 	}
 	if (t.uiSpinbox != nil) {
-		log(debugToolkit, "gui.Toolkit.Value() =", t.uiSpinbox.Value)
+		log(debugToolkit, "Value() =", t.uiSpinbox.Value)
 		return t.uiSpinbox.Value()
 	}
-	log(debugToolkit, "gui.Toolkit.Value() Could not find a ui element to get a value from")
+	log(debugToolkit, "Value() Could not find a ui element to get a value from")
 	return 0
 }
 
-func (t *andlabsT) Dump() {
-	if ! debugToolkit {
+func (t *andlabsT) Dump(b bool) {
+	if ! b {
 		return
 	}
-	log(debugToolkit, "gui.Toolkit.Dump() Name  = ", t.Name, t.Width, t.Height)
+	log(b, "Name  = ", t.Name, t.Width, t.Height)
 	if (t.uiBox != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiBox      =", t.uiBox)
+		log(b, "uiBox      =", t.uiBox)
 	}
 	if (t.uiButton != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiButton    =", t.uiButton)
+		log(b, "uiButton    =", t.uiButton)
 	}
 	if (t.uiCombobox != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiCombobox  =", t.uiCombobox)
+		log(b, "uiCombobox  =", t.uiCombobox)
 	}
 	if (t.uiWindow != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiWindow    =", t.uiWindow)
+		log(b, "uiWindow    =", t.uiWindow)
 	}
 	if (t.uiTab != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiTab       =", t.uiTab)
+		log(b, "uiTab       =", t.uiTab)
 	}
 	if (t.uiGroup != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiGroup     =", t.uiGroup)
+		log(b, "uiGroup     =", t.uiGroup)
 	}
 	if (t.uiEntry != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiEntry     =", t.uiEntry)
+		log(b, "uiEntry     =", t.uiEntry)
 	}
 	if (t.uiMultilineEntry != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiMultilineEntry =", t.uiMultilineEntry)
+		log(b, "uiMultilineEntry =", t.uiMultilineEntry)
 	}
 	if (t.uiSlider != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiSlider    =", t.uiSlider)
+		log(b, "uiSlider    =", t.uiSlider)
 	}
 	if (t.uiCheckbox != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() uiCheckbox  =", t.uiCheckbox)
+		log(b, "uiCheckbox  =", t.uiCheckbox)
 	}
-	if (t.OnExit != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() OnExit      =", t.OnExit)
-	}
-	if (t.Custom != nil) {
-		log(debugToolkit, "gui.Toolkit.Dump() Custom      =", t.Custom)
+	widgetDump(b, t.tw)
+}
+
+func widgetDump(b bool, w *toolkit.Widget) {
+	if (w == nil) {
+		log(b, "widget = nil")
+		return
 	}
-	log(debugToolkit, "gui.Toolkit.Dump() c         =", t.c)
-	log(debugToolkit, "gui.Toolkit.Dump() val       =", t.val)
-	log(debugToolkit, "gui.Toolkit.Dump() text      =", t.text)
+
+	log(b, "widget.Name        =", w.Name)
+	log(b, "widget.Action      =", w.Action)
+	log(b, "widget.Type        =", w.Type)
+	log(b, "widget.Custom      =", w.Custom)
+	log(b, "widget.B           =", w.B)
+	log(b, "widget.I           =", w.I)
+	log(b, "widget.Width       =", w.Width)
+	log(b, "widget.Height      =", w.Height)
+	log(b, "widget.X           =", w.X)
+	log(b, "widget.Y           =", w.Y)
 }
diff --git a/toolkit/andlabs/dropdown.go b/toolkit/andlabs/dropdown.go
index 2691a62..935741c 100644
--- a/toolkit/andlabs/dropdown.go
+++ b/toolkit/andlabs/dropdown.go
@@ -1,20 +1,20 @@
 package main
 
-import "github.com/andlabs/ui"
-import _ "github.com/andlabs/ui/winmanifest"
+import (
+	"github.com/andlabs/ui"
+	_ "github.com/andlabs/ui/winmanifest"
+	"git.wit.org/wit/gui/toolkit"
+)
 
-import "git.wit.org/wit/gui/toolkit"
-
-func (t *andlabsT) NewDropdown(title string) *andlabsT {
-	// make new node here
+func (t *andlabsT) NewDropdown(w *toolkit.Widget) *andlabsT {
 	var newt andlabsT
-
-	log(debugToolkit, "gui.Toolbox.NewDropdownCombobox()", title)
+	log(debugToolkit, "gui.Toolbox.NewDropdown() START", w.Name)
 
 	if t.broken() {
 		return nil
 	}
 
+	newt.tw = w
 	s := ui.NewCombobox()
 	newt.uiCombobox = s
 	newt.uiBox = t.uiBox
@@ -27,11 +27,11 @@ func (t *andlabsT) NewDropdown(title string) *andlabsT {
 	s.OnSelected(func(spin *ui.Combobox) {
 		i := spin.Selected()
 		if (newt.val == nil) {
-			log(debugToolkit, "make map didn't work")
+			log(debugChange, "make map didn't work")
 			newt.text = "error"
 		}
-		newt.text = newt.val[i]
-		newt.commonChange("Dropdown")
+		newt.tw.S = newt.val[i]
+		newt.commonChange(newt.tw)
 	})
 
 	return &newt
@@ -44,6 +44,12 @@ func (t *andlabsT) AddDropdownName(title string) {
 		return
 	}
 	t.val[t.c] = title
+
+	// If this is the first menu added, set the dropdown to it
+	if (t.c == 0) {
+		log(debugChange, "THIS IS THE FIRST Dropdown", title)
+		t.uiCombobox.SetSelected(1)
+	}
 	t.c = t.c + 1
 }
 
@@ -57,11 +63,10 @@ func NewDropdown(parentW *toolkit.Widget, w *toolkit.Widget) {
 	t := mapToolkits[parentW]
 	if (t == nil) {
 		log(debugToolkit, "go.andlabs.NewDropdown() toolkit struct == nil. name=", parentW.Name, w.Name)
-		listMap()
+		listMap(debugToolkit)
+		return
 	}
-	newt := t.NewDropdown(w.Name)
-	newt.Custom = w.Custom
-	newt.tw = w
+	newt := t.NewDropdown(w)
 	mapWidgetsToolkits(w, newt)
 }
 
@@ -71,18 +76,21 @@ func AddDropdownName(w *toolkit.Widget, s string) {
 	t := mapToolkits[w]
 	if (t == nil) {
 		log(debugToolkit, "go.andlabs.AddDropdownName() toolkit struct == nil. name=", w.Name, s)
-		listMap()
+		listMap(debugToolkit)
+		return
 	}
 	t.AddDropdownName(s)
 }
 
-func SetDropdown(w *toolkit.Widget, i int) {
-	log(debugToolkit, "gui.andlabs.SetDropdown()", i)
+func SetDropdownName(w *toolkit.Widget, s string) {
+	log(debugChange, "gui.andlabs.SetDropdown()", w.Name, ",", s)
 
 	t := mapToolkits[w]
 	if (t == nil) {
-		log(debugToolkit, "go.andlabs.SetDropdown() toolkit struct == nil. name=", w.Name, i)
-		listMap()
+		log(debugError, "ERROR: SetDropdown() FAILED mapToolkits[w] == nil. name=", w.Name, s)
+		listMap(debugError)
+		return
 	}
-	t.SetDropdown(i)
+	t.SetDropdown(1)
+	t.tw.S = s
 }
diff --git a/toolkit/andlabs/group.go b/toolkit/andlabs/group.go
index 1762b7f..613efb6 100644
--- a/toolkit/andlabs/group.go
+++ b/toolkit/andlabs/group.go
@@ -7,13 +7,13 @@ import (
 	_ "github.com/andlabs/ui/winmanifest"
 )
 
-func NewGroup(parentW *toolkit.Widget, w *toolkit.Widget) {
+func newGroup(parentW *toolkit.Widget, w *toolkit.Widget) {
 	log(debugToolkit, "gui.andlabs.NewGroup()", w.Name)
 
 	t := mapToolkits[parentW]
 	if (t == nil) {
 		log(debugToolkit, "go.andlabs.NewGroup() toolkit struct == nil. name=", parentW.Name, w.Name)
-		listMap()
+		listMap(debugToolkit)
 	}
 	newt := t.NewGroup(w.Name)
 	mapWidgetsToolkits(w, newt)
@@ -23,18 +23,23 @@ func NewGroup(parentW *toolkit.Widget, w *toolkit.Widget) {
 func (t andlabsT) NewGroup(title string) *andlabsT {
 	var newt andlabsT
 
-	log(debugToolkit, "gui.Toolbox.NewGroup() create", title)
+	log(debugToolkit, "NewGroup() create", title)
 
 	g := ui.NewGroup(title)
 	g.SetMargined(margin)
 
 	if (t.uiBox != nil) {
-		t.uiBox.Append(g, stretchy)
+		// TODO: temporary hack to make the output textbox 'fullscreen'
+		if (title == "output") {
+			t.uiBox.Append(g, true)
+		} else {
+			t.uiBox.Append(g, stretchy)
+		}
 	} else if (t.uiWindow != nil) {
 		t.uiWindow.SetChild(g)
 	} else {
-		log(debugToolkit, "gui.ToolboxNode.NewGroup() node.UiBox == nil. I can't add a range UI element without a place to put it")
-		log(debugToolkit, "probably could just make a box here?")
+		log(debugError, "NewGroup() node.UiBox == nil. I can't add a range UI element without a place to put it")
+		log(debugError, "probably could just make a box here?")
 		exit("internal wit/gui error")
 	}
 
@@ -47,8 +52,5 @@ func (t andlabsT) NewGroup(title string) *andlabsT {
 	newt.uiWindow = t.uiWindow
 	newt.Name = title
 
-	t.Dump()
-	newt.Dump()
-	// panic("toolkit.NewGroup")
 	return &newt
 }
diff --git a/toolkit/andlabs/label.go b/toolkit/andlabs/label.go
index e990b42..6bdd9b2 100644
--- a/toolkit/andlabs/label.go
+++ b/toolkit/andlabs/label.go
@@ -7,66 +7,74 @@ import (
 	"git.wit.org/wit/gui/toolkit"
 )
 
-var pwLabel *toolkit.Widget
-var wLabel *toolkit.Widget
-var tmpNewt *andlabsT
+func newLabel(parentW *toolkit.Widget, w *toolkit.Widget) {
+	var newt *andlabsT
+	log(debugToolkit, "NewLabel()", w.Name)
 
-func NewLabel(parentW *toolkit.Widget, w *toolkit.Widget) {
-	pwLabel = parentW
-	wLabel = w
-	tmpNewt = new(andlabsT)
-	tmpNewt.Width = 10
-	log(debugToolkit, "mapWidgets in ui.QueueMain() START newt =", tmpNewt.Width, tmpNewt)
-	if (tmpNewt == nil) {
-		log(debugToolkit, "mapWidgets WHY THE HELL IS THIS NIL?", tmpNewt.Width, tmpNewt)
-	}
-	ui.QueueMain(newLabel)
-
-	log(true, "sleep(.2) HACK. TODO: wrap spinlock around andlabs.ui goroutine")
-	// log(true, "sleep(.2) HACK. TODO: verify newLabel() is running inside andlabs/ui goroutine") // verified that worked
-	sleep(.2)
-	log(debugToolkit, "mapWidgets parentW/wLabel =", pwLabel)
-	log(debugToolkit, "mapWidgets new/newt =", tmpNewt)
-	mapWidgetsToolkits(w, tmpNewt)
-
-	/*
 	t := mapToolkits[parentW]
 	if (t == nil) {
-		log(debugToolkit, "go.andlabs.NewDropdown() toolkit struct == nil. name=", parentW.Name, w.Name)
-		listMap()
-	}
-	newt := t.NewDropdown(w.Name)
-	mapWidgetsToolkits(w, newt)
-	*/
-}
-
-func newLabel() {
-	var t, newt *andlabsT
-	log(debugToolkit, "gui.andlabs.NewButton()", wLabel.Name)
-
-	t = mapToolkits[pwLabel]
-	if (t == nil) {
-		log(debugToolkit, "go.andlabs.NewButton() toolkit struct == nil. name=", pwLabel.Name, wLabel.Name)
+		listMap(debugError)
+		log(debugError, "ERROR newLabel() listMap()")
+		log(debugError, "ERROR FFFFFFFFFFFF listMap()")
+		log(debugError, "ERROR FFFFFFFFFFFF listMap()")
 		return
 	}
 
+	log(debugToolkit, "NewLabel()", w.Name)
 	if t.broken() {
 		return
 	}
-	newt = tmpNewt
 
-	newt.uiLabel = ui.NewLabel(wLabel.Name)
+	newt = new(andlabsT)
+
+	c := ui.NewLabel(w.Name + " FIX")
+	newt.uiLabel = c
+
 	newt.uiBox = t.uiBox
+	newt.tw = w
+	if (defaultBehavior) {
+		t.uiBox.Append(c, stretchy)
+	}
+
+	mapWidgetsToolkits(w, newt)
+}
 
-	log(debugToolkit, "gui.Toolbox.NewButton() about to append to Box parent t:", wLabel.Name)
-	t.Dump()
-	log(debugToolkit, "gui.Toolbox.NewButton() about to append to Box new t:", wLabel.Name)
-	newt.Dump()
 
-	if (t.uiBox != nil) {
-		t.uiBox.Append(newt.uiLabel, false)
-	} else {
-		log(debugToolkit, "ERROR: wit/gui andlabs couldn't place this label in a box")
+func doLabel(p *toolkit.Widget, c *toolkit.Widget) {
+	if broken(c) {
+		return
+	}
+	if (c.Action == "New") {
+		newLabel(p, c)
+		return
+	}
+	ct := mapToolkits[c]
+	if (ct == nil) {
+		log(true, "Trying to do something on a widget that doesn't work or doesn't exist or something", c)
+		return
+	}
+	if ct.broken() {
+		log(true, "Label() ct.broken", ct)
 		return
 	}
+	if (ct.uiLabel == nil) {
+	
+		log(true, "Label() uiLabel == nil", ct)
+		return
+	}
+	log(true, "Going to attempt:", c.Action)
+	switch c.Action {
+	case "Enable":
+		ct.uiLabel.Enable()
+	case "Disable":
+		ct.uiLabel.Disable()
+	case "Show":
+		ct.uiLabel.Show()
+	case "Hide":
+		ct.uiLabel.Hide()
+	case "Set":
+		ct.uiLabel.SetText(c.S)
+	default:
+		log(true, "Can't do", c.Action, "to a Label")
+	}
 }
diff --git a/toolkit/andlabs/log.go b/toolkit/andlabs/log.go
index fff5ba8..98b4e54 100644
--- a/toolkit/andlabs/log.go
+++ b/toolkit/andlabs/log.go
@@ -98,9 +98,8 @@ func log(a ...any) {
 	if (a == nil) {
 		return
 	}
-	var blah bool
-	if (reflect.TypeOf(a[0]) == reflect.TypeOf(blah)) {
-		// golog.Println("\t a[0] = bool")
+	var tbool bool
+	if (reflect.TypeOf(a[0]) == reflect.TypeOf(tbool)) {
 		if (a[0] == false) {
 			return
 		}
@@ -111,7 +110,9 @@ func log(a ...any) {
 		// a = a[1:]
 		a[0] = "WIT/GUI/Toolkit"
 		if (debugToolkit) {
-			spew.Dump(a)
+			scs := spew.ConfigState{MaxDepth: 1}
+			scs.Dump(a)
+			// spew.Dump(a)
 		}
 		return
 	}
diff --git a/toolkit/andlabs/main.go b/toolkit/andlabs/main.go
index 73aaad5..a72821a 100644
--- a/toolkit/andlabs/main.go
+++ b/toolkit/andlabs/main.go
@@ -32,20 +32,19 @@ func Main(f func()) {
 // For example: Queue(NewWindow())
 //
 func Queue(f func()) {
-	log(debugToolkit, "Sending function to ui.QueueMain() (using gtk via andlabs/ui)")
-	log("THIS MIGHT BREAK")
+	log(debugToolkit, "Sending function to ui.QueueMain()")
+	log(true, "THIS DOES BREAK. TODO: wrap this")
 	ui.QueueMain(f)
 	// f()
 }
 
 func Init() {
-	log(debugToolkit, "should Init() here")
+	log(debugToolkit, "Init()")
 
 	mapWidgets = make(map[*andlabsT]*toolkit.Widget)
 	mapToolkits = make(map[*toolkit.Widget]*andlabsT)
 }
 
 func Quit() {
-	log(debugToolkit, "should Quit() here")
-	// myExit(nil)
+	log(debugToolkit, "Quit() TODO: close the toolkit cleanly")
 }
diff --git a/toolkit/andlabs/plugin.go b/toolkit/andlabs/plugin.go
index 5165178..5bc40a0 100644
--- a/toolkit/andlabs/plugin.go
+++ b/toolkit/andlabs/plugin.go
@@ -1,49 +1,104 @@
 package main
 
-import (
-	"git.wit.org/wit/gui/toolkit"
-)
+// if you include more than just this import
+// then your plugin might be doing something un-ideal (just a guess from 2023/02/27)
+import "git.wit.org/wit/gui/toolkit"
 
-// This is a map between the widgets in wit/gui and the internal structures of gocui
+// import "github.com/andlabs/ui"
+// import _ "github.com/andlabs/ui/winmanifest"
 
-var mapWidgets map[*andlabsT]*toolkit.Widget
-var mapToolkits map[*toolkit.Widget]*andlabsT
-
-// This lists out the know mappings
-func listMap() {
-	log(debugToolkit, "listMap() HERE")
-	log(debugToolkit, "listMap() HERE")
-	log(debugToolkit, "listMap() HERE mapWidgets()")
-	for t, w := range mapWidgets {
-		log(debugToolkit, "andlabs =", t.Name, "widget =", w.Name)
+//
+// This should be called ?
+// Pass() ?
+// This handles all interaction between the wit/gui package (what golang knows about)
+// and this plugin that talks to the OS and does scary and crazy things to make
+// a GUI on whatever OS or whatever GUI toolkit you might have (GTK, QT, WASM, libcurses)
+//
+// Once you are here, you should be in a protected goroutine created by the golang wit/gui package
+//
+// TODO: make sure you can't escape this goroutine
+//
+func Send(p *toolkit.Widget, c *toolkit.Widget) {
+	if (p == nil) {
+		log(debugPlugin, "Send() parent = nil")
+	} else {
+		log(debugPlugin, "Send() parent =", p.Name, ",", p.Type)
 	}
-	log(debugToolkit, "listMap() HERE mapToolkits()")
-	for w, t := range mapToolkits {
-		log(debugToolkit, "andlabs =", t, "widget =", w.Name)
-		forceDump(t)
+	log(debugPlugin, "Send() child  =", c.Name, ",", c.Action, ",", c.Type)
+
+	switch c.Type {
+	case toolkit.Window:
+		newWindow(c)
+	case toolkit.Tab:
+		newTab(p, c)
+	case toolkit.Group:
+		newGroup(p, c)
+	case toolkit.Button:
+		doButton(p, c)
+	case toolkit.Checkbox:
+		doCheckbox(p, c)
+	case toolkit.Label:
+		newLabel(p, c)
+	case toolkit.Textbox:
+		doTextbox(p, c)
+	case toolkit.Slider:
+		newSlider(p, c)
+	case toolkit.Spinner:
+		newSpinner(p, c)
+	default:
+		log(true, "unknown parent =", p.Name, p.Type)
+		log(true, "unknown child  =", c.Name, c.Type)
+		log(true, "Don't know how to do", c.Type, "yet")
 	}
 }
 
-func mapWidgetsToolkits(w *toolkit.Widget, t *andlabsT) {
-	if (mapToolkits[w] == nil) {
-		mapToolkits[w] = t
-	} else {
-		log(debugToolkit, "WTF: mapToolkits was sent nil. this should not happen w =", w)
-		log(debugToolkit, "WTF: mapToolkits was sent nil. this should not happen t =", t.Width)
-		log(debugToolkit, "WTF: mapToolkits map already set to ", mapToolkits[w])
-		panic("WTF mapWidgetsToolkits() w == nil")
+// delete the child widget from the parent
+// p = parent, c = child
+func destroy(p *toolkit.Widget, c *toolkit.Widget) {
+	log(true, "delete()", c.Name, c.Type)
+
+	pt := mapToolkits[p]
+	ct := mapToolkits[c]
+	if (ct == nil) {
+		log(true, "delete FAILED (ct = mapToolkit[c] == nil) for c", c.Name, c.Type)
+		// this pukes out a whole universe of shit
+		// listMap()
+		return
 	}
 
-	if (mapWidgets[t] == nil) {
-		mapWidgets[t] = w
-	} else {
-		log(debugToolkit, "WTF: mapWidgets already installed. w =", w)
-		log(debugToolkit, "WTF: mapWidgets already installed. t =", t.Width, t)
-		log(SPEW, &t)
-		log(SPEW, t)
-		log(SPEW, *t)
-		log(debugToolkit, "WTF: mapWidgets already mapped to", mapWidgets[t])
-		log(SPEW, mapWidgets[t])
-		panic("WTF. mapWidget andlabs toolkit already mapped to gui toolkit")
+	switch ct.Type {
+	case toolkit.Button:
+		log(true, "Should delete Button here:", c.Name)
+		log(true, "Parent:")
+		pt.Dump(true)
+		log(true, "Child:")
+		ct.Dump(true)
+		if (pt.uiBox == nil) {
+			log(true, "Don't know how to destroy this")
+		} else {
+			log(true, "Fuck it, destroy the whole box", pt.Name)
+			// pt.uiBox.Destroy() // You have a bug: You cannot destroy a uiControl while it still has a parent.
+			pt.uiBox.SetPadded(false)
+			pt.uiBox.Delete(4)
+			ct.uiButton.Disable()
+			// ct.uiButton.Hide()
+			ct.uiButton.Destroy()
+		}
+
+	case toolkit.Window:
+		log(true, "Should delete Window here:", c.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.Type, pt.Name, pt.uiButton)
+		log(true, "Don't know how to delete ct =", ct.Type, ct.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)
+		if (ct.uiButton != nil) {
+			pt.uiBox.Delete(4)
+			ct.uiButton.Destroy()
+		}
 	}
 }
diff --git a/toolkit/andlabs/slider.go b/toolkit/andlabs/slider.go
index 4857935..87639ca 100644
--- a/toolkit/andlabs/slider.go
+++ b/toolkit/andlabs/slider.go
@@ -7,31 +7,32 @@ import (
 	_ "github.com/andlabs/ui/winmanifest"
 )
 
-func (t andlabsT) NewSlider(title string, x int, y int) *andlabsT {
+func (t andlabsT) newSlider(w *toolkit.Widget) *andlabsT {
 	// make new node here
-	log(debugToolkit, "gui.Toolkit.NewSpinbox()", x, y)
+	log(debugToolkit, w.Name, w.Type, w.X, w.Y)
 	var newt andlabsT
 
 	if (t.uiBox == nil) {
-		log(debugToolkit, "gui.ToolkitNode.NewGroup() node.UiBox == nil. I can't add a range UI element without a place to put it")
+		log(debugToolkit, "node.UiBox == nil. I can't add a range UI element without a place to put it")
 		log(debugToolkit, "probably could just make a box here?")
 		exit("internal golang wit/gui/toolkit error")
 		return nil
 	}
 
-	s := ui.NewSlider(x, y)
+	s := ui.NewSlider(w.X, w.Y)
 	newt.uiSlider = s
 	newt.uiBox = t.uiBox
+	newt.tw = w
 	t.uiBox.Append(s, stretchy)
 
 	s.OnChanged(func(spin *ui.Slider) {
-		newt.commonChange("Slider")
+		newt.commonChange(newt.tw)
 	})
 
 	return &newt
 }
 
-func NewSlider(parentW *toolkit.Widget, w *toolkit.Widget) {
+func newSlider(parentW *toolkit.Widget, w *toolkit.Widget) {
 	var newt *andlabsT
 	log(debugToolkit, "gui.andlabs.NewTab()", w.Name)
 
@@ -40,6 +41,6 @@ func NewSlider(parentW *toolkit.Widget, w *toolkit.Widget) {
 		log(debugToolkit, "go.andlabs.NewTab() toolkit struct == nil. name=", parentW.Name, w.Name)
 		return
 	}
-	newt = t.NewSlider(w.Name, w.X, w.Y)
+	newt = t.newSlider(w)
 	mapWidgetsToolkits(w, newt)
 }
diff --git a/toolkit/andlabs/spinner.go b/toolkit/andlabs/spinner.go
index b98fb0c..1a7430e 100644
--- a/toolkit/andlabs/spinner.go
+++ b/toolkit/andlabs/spinner.go
@@ -1,27 +1,43 @@
 package main
 
-import "github.com/andlabs/ui"
-import _ "github.com/andlabs/ui/winmanifest"
+import (
+	"git.wit.org/wit/gui/toolkit"
 
-func (t andlabsT) NewSpinner(title string, x int, y int) *andlabsT {
+	"github.com/andlabs/ui"
+	_ "github.com/andlabs/ui/winmanifest"
+)
+
+func (t andlabsT) newSpinner(w *toolkit.Widget) *andlabsT {
 	// make new node here
-	log(debugToolkit, "gui.Toolkit.NewSpinner()", x, y)
+	log(debugToolkit, "newSpinner()", w.X, w.Y)
 	var newt andlabsT
 
 	if (t.uiBox == nil) {
-		log(debugToolkit, "gui.ToolkitNode.NewSpinner() node.UiBox == nil. I can't add a range UI element without a place to put it")
-		exit("internal golang wit/gui error")
+		log(debugToolkit, "newSpinner() node.UiBox == nil. I can't add a range UI element without a place to put it")
 		return nil
 	}
 
-	s := ui.NewSpinbox(x, y)
+	s := ui.NewSpinbox(w.X, w.Y)
 	newt.uiSpinbox = s
 	newt.uiBox = t.uiBox
+	newt.tw = w
 	t.uiBox.Append(s, stretchy)
 
 	s.OnChanged(func(s *ui.Spinbox) {
-		newt.commonChange("Spinner")
+		newt.commonChange(newt.tw)
 	})
 
 	return &newt
 }
+
+func newSpinner(parentW *toolkit.Widget, w *toolkit.Widget) {
+	var newt *andlabsT
+
+	t := mapToolkits[parentW]
+	if (t == nil) {
+		log(debugToolkit, "go.andlabs.NewTab() toolkit struct == nil. name=", parentW.Name, w.Name)
+		return
+	}
+	newt = t.newSpinner(w)
+	mapWidgetsToolkits(w, newt)
+}
diff --git a/toolkit/andlabs/structs.go b/toolkit/andlabs/structs.go
index cf3afaf..45b6d1d 100644
--- a/toolkit/andlabs/structs.go
+++ b/toolkit/andlabs/structs.go
@@ -10,31 +10,27 @@ type andlabsT struct {
 	id     string
 
 	Name   string
+	Type   toolkit.WidgetType
 	Width  int
 	Height int
 	tw	*toolkit.Widget
-
-	OnChanged func(*andlabsT)
-	OnExit    func(*andlabsT)
-
-	Custom  func()
+	parent	*andlabsT
 
 	uiBox     *ui.Box
-	uiBox2    *ui.Box	// temporary hack while implementing tabs
 	uiButton  *ui.Button
 	uiControl *ui.Control
 	uiCombobox *ui.Combobox
 	uiCheckbox *ui.Checkbox
 	uiEntry   *ui.Entry
-	uiMultilineEntry   *ui.MultilineEntry
 	uiGroup   *ui.Group
 	uiLabel   *ui.Label
 	uiSlider  *ui.Slider
 	uiSpinbox *ui.Spinbox
 	uiTab     *ui.Tab
-	uiText    *ui.EditableCombobox
 	uiWindow  *ui.Window
-	UiWindowBad  *ui.Window
+	// UiWindowBad  *ui.Window // erase this
+	uiMultilineEntry   *ui.MultilineEntry
+	uiEditableCombobox    *ui.EditableCombobox
 
 	// used as a counter to work around limitations of widgets like combobox
 	// this is probably fucked up and in many ways wrong because of unsafe goroutine threading
diff --git a/toolkit/andlabs/tab.go b/toolkit/andlabs/tab.go
index f9085b4..995bbbd 100644
--- a/toolkit/andlabs/tab.go
+++ b/toolkit/andlabs/tab.go
@@ -33,7 +33,7 @@ func (t *andlabsT) newTab(name string) *andlabsT {
 	if (t.uiTab == nil) {
 		// this means you have to make a new tab
 		log(debugToolkit, "gui.toolkit.NewTab() GOOD. This should be the first tab:", name)
-		newt = newTab(t.uiWindow, name)
+		newt = rawTab(t.uiWindow, name)
 		t.uiTab = newt.uiTab
 	} else {
 		// this means you have to append a tab
@@ -44,9 +44,9 @@ func (t *andlabsT) newTab(name string) *andlabsT {
 	newt.Name = name
 
 	log(debugToolkit, "t:")
-	t.Dump()
+	t.Dump(debugToolkit)
 	log(debugToolkit, "newt:")
-	newt.Dump()
+	newt.Dump(debugToolkit)
 
 	return newt
 }
@@ -62,7 +62,7 @@ func tabSetMargined(tab *ui.Tab) {
 	}
 }
 
-func newTab(w *ui.Window, name string) *andlabsT {
+func rawTab(w *ui.Window, name string) *andlabsT {
 	var t andlabsT
 	log(debugToolkit, "gui.toolkit.NewTab() ADD", name)
 
@@ -118,7 +118,7 @@ func (t *andlabsT) appendTab(name string) *andlabsT {
 	return &newT
 }
 
-func NewTab(parentW *toolkit.Widget, w *toolkit.Widget) {
+func newTab(parentW *toolkit.Widget, w *toolkit.Widget) {
 	var newt *andlabsT
 	log(debugToolkit, "gui.andlabs.NewTab()", w.Name)
 
diff --git a/toolkit/andlabs/textbox.go b/toolkit/andlabs/textbox.go
index cb6075d..e916fd9 100644
--- a/toolkit/andlabs/textbox.go
+++ b/toolkit/andlabs/textbox.go
@@ -5,19 +5,32 @@ import "git.wit.org/wit/gui/toolkit"
 import "github.com/andlabs/ui"
 import _ "github.com/andlabs/ui/winmanifest"
 
-func (t andlabsT) NewTextbox(name string) *andlabsT {
-	var newt andlabsT
+func newTextbox(parentW *toolkit.Widget, w *toolkit.Widget) {
+	log(debugToolkit, "NewTexbox()", w.Name)
 
-	log(debugToolkit, "gui.Toolkit.NewTextbox()", name)
+	t := mapToolkits[parentW]
+	if (t == nil) {
+		listMap(debugError)
+		log(debugError, "newTextbox() listMap()")
+		log(debugError, "FFFFFFFFFFFF listMap()")
+		log(debugError, "FFFFFFFFFFFF listMap()")
+	}
+	// t.NewTextbox(w)
+// func (t andlabsT) NewTextbox(w *toolkit.Widget) *andlabsT {
+	var newt *andlabsT
+	newt = new(andlabsT)
+
+	log(debugToolkit, "gui.Toolkit.NewTextbox()", w.Name)
 	if t.broken() {
-		return nil
+		return
 	}
 
 	c := ui.NewNonWrappingMultilineEntry()
 	newt.uiMultilineEntry = c
 
 	newt.uiBox = t.uiBox
-	newt.Name = name
+	newt.Name = w.Name
+	newt.tw = w
 	if (defaultBehavior) {
 		t.uiBox.Append(c, true)
 	} else {
@@ -25,41 +38,59 @@ func (t andlabsT) NewTextbox(name string) *andlabsT {
 	}
 
 	c.OnChanged(func(spin *ui.MultilineEntry) {
-		newt.commonChange("Textbox")
+		w.S = newt.uiMultilineEntry.Text()
+		// this is still dangerous
+		// newt.commonChange(newt.tw)
+		log(debugChange, "Not yet safe to trigger on change for ui.MultilineEntry")
 	})
-
-	return &newt
+	mapWidgetsToolkits(w, newt)
 }
 
-func NewTextbox(parentW *toolkit.Widget, w *toolkit.Widget) {
-	var t, newt *andlabsT
-	log(debugToolkit, "gui.andlabs.NewTextbox()", w.Name)
 
-	t = mapToolkits[parentW]
-	if (t == nil) {
-		log(debugToolkit, "go.andlabs.NewTextbox() toolkit struct == nil. name=", parentW.Name, w.Name)
+func doTextbox(p *toolkit.Widget, c *toolkit.Widget) {
+	if broken(c) {
 		return
 	}
-
-	if t.broken() {
+	if (c.Action == "New") {
+		newTextbox(p, c)
 		return
 	}
-	newt = new(andlabsT)
-
-	newt.uiLabel = ui.NewLabel(w.Name)
-	newt.uiBox = t.uiBox
-
-	log(debugToolkit, "gui.Toolbox.NewTextbox() about to append to Box parent t:", w.Name)
-	t.Dump()
-	log(debugToolkit, "gui.Toolbox.NewTextbox() about to append to Box new t:", w.Name)
-	newt.Dump()
-
-	if (t.uiBox != nil) {
-		t.uiBox.Append(newt.uiLabel, false)
-	} else {
-		log(debugToolkit, "ERROR: wit/gui andlabs couldn't place this Textbox in a box")
+	ct := mapToolkits[c]
+	if (ct == nil) {
+		log(true, "Trying to do something on a widget that doesn't work or doesn't exist or something", c)
+		return
+	}
+	if ct.broken() {
+		log(true, "Textbox() ct.broken", ct)
 		return
 	}
+	if (ct.uiMultilineEntry == nil) {
+		log(debugError, "Textbox() uiMultilineEntry == nil", ct)
+		return
+	}
+	// the dns control panel isn't crashing anymore (?)
+	Queue(ct.doSimpleAction)
+}
 
-	mapWidgetsToolkits(w, newt)
+func (t *andlabsT) doSimpleAction() {
+	if (t.tw == nil) {
+		log(true, "doSimpleAction() got an empty widget")
+		log(true, "THIS SHOULD NEVER HAPPEN")
+		panic("crap. panic. widget == nil")
+	}
+	log(debugChange, "Going to attempt:", t.tw.Action)
+	switch  t.tw.Action {
+	case "Enable":
+		t.uiMultilineEntry.Enable()
+	case "Disable":
+		t.uiMultilineEntry.Disable()
+	case "Show":
+		t.uiMultilineEntry.Show()
+	case "Hide":
+		t.uiMultilineEntry.Hide()
+	case "Set":
+		t.uiMultilineEntry.SetText(t.tw.S)
+	default:
+		log(debugError, "Can't do", t.tw.Action, "to a Textbox")
+	}
 }
diff --git a/toolkit/andlabs/widget.go b/toolkit/andlabs/widget.go
new file mode 100644
index 0000000..58f8514
--- /dev/null
+++ b/toolkit/andlabs/widget.go
@@ -0,0 +1,67 @@
+package main
+
+import (
+	"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 mapToolkits map[*toolkit.Widget]*andlabsT
+
+// This lists out the know mappings
+func listMap(b bool) {
+	log(b, "listMap() HERE")
+	log(b, "listMap() HERE")
+	for t, w := range mapWidgets {
+		log(b, "andlabs =", t.Name, "widget =", w.Name)
+	}
+	log(debugToolkit, "listMap() HERE mapToolkits()")
+	for w, t := range mapToolkits {
+		log(b, "andlabs =", t, "widget =", w.Name)
+		t.Dump(b)
+	}
+	log(b, "listMap() HERE mapWidgets()")
+	log(b, "listMap() HERE FIXME. output too big")
+}
+
+func mapWidgetsToolkits(w *toolkit.Widget, t *andlabsT) {
+	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(true, "mapToolkits[w] is", tw)
+		if (tw == nil) {
+			log(true, "BAD map? mapWidgets[w] tw == nil")
+		} else {
+			log(true, "BAD map? mapWidgets[w] is", tw)
+			tw.Dump(true)
+		}
+	}
+
+	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(true, "BAD map? mapWidgets[t] wt == nil")
+		} else {
+			log(true, "BAD map? mapWidgets[t] is", wt)
+			widgetDump(true, wt)
+		}
+	}
+	log(debugToolkit, "map of widget worked", w.Type, ",", w.Name, ",", w.Action)
+}
diff --git a/toolkit/andlabs/window.go b/toolkit/andlabs/window.go
index 7527ac5..40cd410 100644
--- a/toolkit/andlabs/window.go
+++ b/toolkit/andlabs/window.go
@@ -15,8 +15,8 @@ func (t *andlabsT) ErrorWindow(msg1 string, msg2 string) {
 	ui.MsgBoxError(t.uiWindow, msg1, msg2)
 }
 
-func NewWindow(w *toolkit.Widget) {
-	var t *andlabsT
+func newWindow(w *toolkit.Widget) {
+	var newt *andlabsT
 
 	log(debugToolkit, "toolkit NewWindow", w.Name, w.Width, w.Height)
 
@@ -24,34 +24,23 @@ func NewWindow(w *toolkit.Widget) {
 		log(debugToolkit, "wit/gui plugin error. widget == nil")
 		return
 	}
-	t = new(andlabsT)
-	// t = NewWindow2(w.Name, w.Width, w.Height)
+	newt = new(andlabsT)
+	newt.tw = w
 
-// func NewWindow2(title string, x int, y int) *andlabsT {
 	// 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 {
-		log(debugToolkit, "ui.Window().OnExit() SHOULD ATTEMPT CALLBACK here")
-		t.Dump()
-		if (w.Custom != nil) {
-			w.Custom()
-			return true
-		}
-		// if (w.Event != nil) {
-		// 	w.Event(w)
-		// 	return true
-		// }
-		log(debugToolkit, "andlabs.ui.Window().OnClosing() was not defined")
-		return false
+		newt.commonChange(newt.tw)
+		return true
 	})
 	win.Show()
-	t.uiWindow = win
-	t.UiWindowBad = win // deprecate this as soon as possible
-	t.Name = w.Name
+	newt.uiWindow = win
+	// newt.UiWindowBad = win // deprecate this as soon as possible
+	newt.Name = w.Name
 
-	mapWidgetsToolkits(w, t)
+	mapWidgetsToolkits(w, newt)
 	return
 }
 
diff --git a/toolkit/widget.go b/toolkit/widget.go
index 295a598..fcb6d31 100644
--- a/toolkit/widget.go
+++ b/toolkit/widget.go
@@ -11,8 +11,19 @@ package toolkit
 // Event() seems like a good name.
 // Could a protobuf be used here? (Can functions be passed?)
 type Widget struct {
-	Name   string
-	Type   string	// after lots of back and forth, a simple string
+	Name   string   // "New", "Delete", "Set", aka something to do
+	Action string   // "New", "Delete", "Set", aka something to do
+	// Type   string	// after lots of back and forth, a simple string
+	Type  WidgetType
+
+	// This is how the values are passed back and forth
+	// values from things like checkboxes & dropdown's
+	// The string is also used to set the button name
+	B	bool
+	I	int
+	// maybe safe if there is correctly working Custom() between goroutines
+	// (still probably not, almost certainly not)
+	S	string // not safe to have 'S'
 
 	// This GUI is intended for simple things
 	// We are not laying out PDF's here
@@ -22,49 +33,61 @@ type Widget struct {
 	X      int
 	Y      int
 
-	// latest attempt
-	Custom    func()
+	// Put space around elements to improve look & feel
+	Margin	bool
 
-	// This might be useful to simplify retrieving 
-	// values from things like checkboxes & dropdown's
-	B	bool
-	I	int
-	S	string
+	// Make widgets fill up the space available
+	Expand	bool
 
-	// other things I've tried
-	// Event     func(*Widget) *Widget
-//	OnChanged func(*Widget)
-//	Custom    func(*Widget)
-//	OnExit    func(*Widget)
+	// latest attempt. seems to work so far (2023/02/28)
+	// Hopefully this will be the barrier between the goroutines
+	Custom    func()
 }
 
-/*
-type Widget int
+type WidgetType int
 
 // https://ieftimov.com/post/golang-datastructures-trees/
 const (
-	Unknown Widget = iota
+	Unknown WidgetType = iota
 	Window
 	Tab
+	Group
 	Frame
-	Dropbox
-	Spinner
+	Button
+	Checkbox
+	Dropdown
 	Label
+	Textbox
+	Slider
+	Spinner
 )
 
-func (s Widget) String() string {
+func (s WidgetType) String() string {
 	switch s {
 	case Window:
 		return "Window"
 	case Tab:
 		return "Tab"
+	case Group:
+		return "Group"
 	case Frame:
 		return "Frame"
+	case Button:
+		return "Button"
+	case Checkbox:
+		return "Checkbox"
+	case Dropdown:
+		return "Dropdown"
 	case Label:
 		return "Label"
-	case Dropbox:
-		return "Dropbox"
+	case Textbox:
+		return "Textbox"
+	case Slider:
+		return "Slider"
+	case Spinner:
+		return "Spinner"
+	case Unknown:
+		return "Unknown"
 	}
-	return "unknown"
+	return "GuiToolkitTUndefinedType"
 }
-*/