diff options
Diffstat (limited to 'toolkit')
32 files changed, 1459 insertions, 279 deletions
diff --git a/toolkit/andlabs2/Makefile b/toolkit/andlabs2/Makefile new file mode 100644 index 0000000..54cf7f5 --- /dev/null +++ b/toolkit/andlabs2/Makefile @@ -0,0 +1,4 @@ +all: plugin + +plugin: + GO111MODULE="off" go build -buildmode=plugin -o ../andlabs2.so diff --git a/toolkit/andlabs2/box.go b/toolkit/andlabs2/box.go new file mode 100644 index 0000000..bb9945e --- /dev/null +++ b/toolkit/andlabs2/box.go @@ -0,0 +1,66 @@ +package main + +import "log" + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +// create a new box +func (t *andlabsT) GetBox() *ui.Box { + return t.uiBox +} + +// create a new box +func (t *andlabsT) NewBox() *andlabsT { + if (DebugToolkit) { + log.Println("gui.Toolbox.NewBox() START create default") + } + t.Dump() + if (t.uiGroup != nil) { + if (DebugToolkit) { + log.Println("\tgui.Toolbox.NewBox() is a Group") + } + var newTK andlabsT + + vbox := ui.NewVerticalBox() + vbox.SetPadded(padded) + t.uiGroup.SetChild(vbox) + newTK.uiBox = vbox + + return &newTK + } + if (t.uiBox != nil) { + if (DebugToolkit) { + log.Println("\tgui.Toolbox.NewBox() is a Box") + } + var newTK andlabsT + + vbox := ui.NewVerticalBox() + vbox.SetPadded(padded) + t.uiBox.Append(vbox, stretchy) + newTK.uiBox = vbox + newTK.Name = t.Name + + return &newTK + } + if (t.uiWindow != nil) { + if (DebugToolkit) { + log.Println("\tgui.Toolbox.NewBox() is a Window") + } + var newT andlabsT + + vbox := ui.NewVerticalBox() + vbox.SetPadded(padded) + t.uiWindow.SetChild(vbox) + newT.uiBox = vbox + newT.Name = t.Name + + // panic("WTF") + return &newT + } + if (DebugToolkit) { + log.Println("\tgui.Toolbox.NewBox() FAILED. Couldn't figure out where to make a box") + } + t.Dump() + return nil +} diff --git a/toolkit/andlabs2/button.go b/toolkit/andlabs2/button.go new file mode 100644 index 0000000..bd80683 --- /dev/null +++ b/toolkit/andlabs2/button.go @@ -0,0 +1,67 @@ +package main + +import "log" +// import "os" + + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +import "git.wit.org/wit/gui/toolkit" +func NewButton(parentW *toolkit.Widget, w *toolkit.Widget) { + var t, newt *andlabsT + var b *ui.Button + log.Println("gui.andlabs.NewButton()", w.Name) + + t = mapToolkits[parentW] + if (t == nil) { + log.Println("go.andlabs.NewButton() toolkit struct == nil. name=", parentW.Name, w.Name) + return + } + + if t.broken() { + return + } + newt = new(andlabsT) + + b = ui.NewButton(w.Name) + newt.uiButton = b + + b.OnClicked(func(*ui.Button) { + if (DebugToolkit) { + log.Println("TODO: IN TOOLKIT GOROUTINE. SHOULD LEAVE HERE VIA channels. button name =", w.Name) + log.Println("FOUND WIDGET!", w) + } + if (w.Custom != nil) { + w.Custom() + return + } + if (w.Event != nil) { + w.Event(w) + return + } + t.Dump() + newt.Dump() + if (DebugToolkit) { + log.Println("TODO: LEFT TOOLKIT GOROUTINE WITH NOTHING TO DO button name =", w.Name) + } + }) + + if (DebugToolkit) { + log.Println("gui.Toolbox.NewButton() about to append to Box parent t:", w.Name) + t.Dump() + log.Println("gui.Toolbox.NewButton() about to append to Box new t:", w.Name) + newt.Dump() + } + if (t.uiBox != nil) { + t.uiBox.Append(b, stretchy) + } else if (t.uiWindow != nil) { + t.uiWindow.SetChild(b) + } else { + log.Println("ERROR: wit/gui andlabs couldn't place this button in a box or a window") + log.Println("ERROR: wit/gui andlabs couldn't place this button in a box or a window") + return + } + + mapWidgetsToolkits(w, newt) +} diff --git a/toolkit/andlabs2/checkbox.go b/toolkit/andlabs2/checkbox.go new file mode 100644 index 0000000..b4b1524 --- /dev/null +++ b/toolkit/andlabs2/checkbox.go @@ -0,0 +1,34 @@ +package main + +import "log" + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +func (t andlabsT) NewCheckbox(name string) *andlabsT { + log.Println("gui.Toolkit.NewCheckbox()", name) + var newt andlabsT + + if t.broken() { + return nil + } + + c := ui.NewCheckbox(name) + newt.uiCheckbox = c + newt.uiBox = t.uiBox + t.uiBox.Append(c, stretchy) + + c.OnToggled(func(spin *ui.Checkbox) { + newt.commonChange("Checkbox") + }) + + return &newt +} + +func (t andlabsT) Checked() bool { + if t.broken() { + return false + } + + return t.uiCheckbox.Checked() +} diff --git a/toolkit/andlabs2/common.go b/toolkit/andlabs2/common.go new file mode 100644 index 0000000..fc6cbe8 --- /dev/null +++ b/toolkit/andlabs2/common.go @@ -0,0 +1,61 @@ +package main + +import "log" + +func init() { + if (DebugToolkit) { + log.Println("gui/toolkit init() Setting defaultBehavior = true") + } + setDefaultBehavior(true) +} + +func (t andlabsT) commonChange(widget string) { + s := t.String() + if (DebugToolkit) { + log.Println("gui.Toolkit.ui.OnChanged() =", s) + } + if (t.OnChanged != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.OnChanged() trying to run toolkit.OnChanged() entered val =", s) + } + t.OnChanged(&t) + return + } + if (t.Custom != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.OnChanged() Running toolkit.Custom()") + t.Dump() + } + t.Custom() + return + } + if (DebugToolkit) { + log.Println("gui.Toolkit.OnChanged() ENDED without finding any callback") + } +} + +// 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 (?) +func (t *andlabsT) broken() bool { + if (t.uiBox == nil) { + if (t.uiWindow != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.UiBox == nil. This is an empty window. Try to add a box") + } + t.NewBox() + return false + } + log.Println("gui.Toolkit.UiBox == nil. I can't add a widget without a place to put it") + // log.Println("probably could just make a box here?") + // corruption or something horrible? + 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.Println("gui.Toolkit.UiWindow == nil. I can't add a widget without a place to put it (IGNORING FOR NOW)") + forceDump(t) + return false + } + return false +} diff --git a/toolkit/andlabs2/demo.go b/toolkit/andlabs2/demo.go new file mode 100644 index 0000000..0781f88 --- /dev/null +++ b/toolkit/andlabs2/demo.go @@ -0,0 +1,92 @@ +package main + +import "log" + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +/* + This is a code example taken directly from the toolkit andlabs/ui + + This code is here to double check that the toolkit itself still works + the same way. This is intended as a sanity check. +*/ + +func BlankWindow(w *ui.Window) *ui.Box { + hbox := ui.NewHorizontalBox() + hbox.SetPadded(true) + w.SetChild(hbox) + return hbox +} + +func (t *andlabsT) DemoNumbersPage() { + var w *ui.Window + + log.Println("Starting wit/gui toolkit andlabs/ui DemoNumbersPage()") + + w = t.uiWindow + t.uiBox = makeNumbersPage() + t.uiBox.SetPadded(true) + w.SetChild(t.uiBox) + w.SetTitle("Internal demo of andlabs/ui toolkit") +} + +func makeNumbersPage() *ui.Box { + hbox := ui.NewHorizontalBox() + hbox.SetPadded(true) + + group := ui.NewGroup("Numbers") + group.SetMargined(true) + hbox.Append(group, true) + + vbox := ui.NewVerticalBox() + vbox.SetPadded(true) + group.SetChild(vbox) + + spinbox := ui.NewSpinbox(0, 100) + slider := ui.NewSlider(0, 100) + pbar := ui.NewProgressBar() + spinbox.OnChanged(func(*ui.Spinbox) { + slider.SetValue(spinbox.Value()) + pbar.SetValue(spinbox.Value()) + }) + slider.OnChanged(func(*ui.Slider) { + spinbox.SetValue(slider.Value()) + pbar.SetValue(slider.Value()) + }) + vbox.Append(spinbox, false) + vbox.Append(slider, false) + vbox.Append(pbar, false) + + ip := ui.NewProgressBar() + ip.SetValue(-1) + vbox.Append(ip, false) + + group = ui.NewGroup("Lists") + group.SetMargined(true) + hbox.Append(group, true) + + vbox = ui.NewVerticalBox() + vbox.SetPadded(true) + group.SetChild(vbox) + + cbox := ui.NewCombobox() + cbox.Append("Combobox Item 1") + cbox.Append("Combobox Item 2") + cbox.Append("Combobox Item 3") + vbox.Append(cbox, false) + + ecbox := ui.NewEditableCombobox() + ecbox.Append("Editable Item 1") + ecbox.Append("Editable Item 2") + ecbox.Append("Editable Item 3") + vbox.Append(ecbox, false) + + rb := ui.NewRadioButtons() + rb.Append("Radio Button 1") + rb.Append("Radio Button 2") + rb.Append("Radio Button 3") + vbox.Append(rb, false) + + return hbox +} diff --git a/toolkit/andlabs2/dropdown.go b/toolkit/andlabs2/dropdown.go new file mode 100644 index 0000000..1e1886a --- /dev/null +++ b/toolkit/andlabs2/dropdown.go @@ -0,0 +1,90 @@ +package main + +import "log" +// import "time" + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +import "git.wit.org/wit/gui/toolkit" + +func (t *andlabsT) NewDropdown(title string) *andlabsT { + // make new node here + if (DebugToolkit) { + log.Println("gui.Toolbox.NewDropdownCombobox()", title) + } + var newt andlabsT + + if t.broken() { + return nil + } + + s := ui.NewCombobox() + newt.uiCombobox = s + newt.uiBox = t.uiBox + t.uiBox.Append(s, stretchy) + + // initialize the index + newt.c = 0 + newt.val = make(map[int]string) + + s.OnSelected(func(spin *ui.Combobox) { + i := spin.Selected() + if (newt.val == nil) { + log.Println("make map didn't work") + newt.text = "error" + } + newt.text = newt.val[i] + newt.commonChange("Dropdown") + }) + + return &newt +} + +func (t *andlabsT) AddDropdownName(title string) { + t.uiCombobox.Append(title) + if (t.val == nil) { + log.Println("make map didn't work") + return + } + t.val[t.c] = title + t.c = t.c + 1 +} + +func (t andlabsT) SetDropdown(i int) { + t.uiCombobox.SetSelected(i) +} + +func NewDropdown(parentW *toolkit.Widget, w *toolkit.Widget) { + log.Println("gui.andlabs.NewDropdown()", w.Name) + + t := mapToolkits[parentW] + if (t == nil) { + log.Println("go.andlabs.NewDropdown() toolkit struct == nil. name=", parentW.Name, w.Name) + listMap() + } + newt := t.NewDropdown(w.Name) + mapWidgetsToolkits(w, newt) +} + +func AddDropdownName(w *toolkit.Widget, s string) { + log.Println("gui.andlabs.AddDropdownName()", w.Name, "add:", s) + + t := mapToolkits[w] + if (t == nil) { + log.Println("go.andlabs.AddDropdownName() toolkit struct == nil. name=", w.Name, s) + listMap() + } + t.AddDropdownName(s) +} + +func SetDropdown(w *toolkit.Widget, i int) { + log.Println("gui.andlabs.SetDropdown()", i) + + t := mapToolkits[w] + if (t == nil) { + log.Println("go.andlabs.SetDropdown() toolkit struct == nil. name=", w.Name, i) + listMap() + } + t.SetDropdown(i) +} diff --git a/toolkit/andlabs2/group.go b/toolkit/andlabs2/group.go new file mode 100644 index 0000000..39f740b --- /dev/null +++ b/toolkit/andlabs2/group.go @@ -0,0 +1,56 @@ +package main + +import "log" +import "os" + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +import "git.wit.org/wit/gui/toolkit" + +func NewGroup(parentW *toolkit.Widget, w *toolkit.Widget) { + log.Println("gui.andlabs.NewGroup()", w.Name) + + t := mapToolkits[parentW] + if (t == nil) { + log.Println("go.andlabs.NewGroup() toolkit struct == nil. name=", parentW.Name, w.Name) + listMap() + } + newt := t.NewGroup(w.Name) + mapWidgetsToolkits(w, newt) +} + +// make new Group here +func (t andlabsT) NewGroup(title string) *andlabsT { + var newt andlabsT + + if (DebugToolkit) { + log.Println("gui.Toolbox.NewGroup() create", title) + } + g := ui.NewGroup(title) + g.SetMargined(margin) + + if (t.uiBox != nil) { + t.uiBox.Append(g, stretchy) + } else if (t.uiWindow != nil) { + t.uiWindow.SetChild(g) + } else { + log.Println("gui.ToolboxNode.NewGroup() node.UiBox == nil. I can't add a range UI element without a place to put it") + log.Println("probably could just make a box here?") + os.Exit(0) + } + + hbox := ui.NewVerticalBox() + hbox.SetPadded(padded) + g.SetChild(hbox) + + newt.uiGroup = g + newt.uiBox = hbox + newt.uiWindow = t.uiWindow + newt.Name = title + + t.Dump() + newt.Dump() + // panic("toolkit.NewGroup") + return &newt +} diff --git a/toolkit/andlabs2/label.go b/toolkit/andlabs2/label.go new file mode 100644 index 0000000..c5a6896 --- /dev/null +++ b/toolkit/andlabs2/label.go @@ -0,0 +1,42 @@ +package main + +import "log" + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +import "git.wit.org/wit/gui/toolkit" + +func NewLabel(parentW *toolkit.Widget, w *toolkit.Widget) { + var t, newt *andlabsT + log.Println("gui.andlabs.NewButton()", w.Name) + + t = mapToolkits[parentW] + if (t == nil) { + log.Println("go.andlabs.NewButton() toolkit struct == nil. name=", parentW.Name, w.Name) + return + } + + if t.broken() { + return + } + newt = new(andlabsT) + + newt.uiLabel = ui.NewLabel(w.Name) + newt.uiBox = t.uiBox + + if (DebugToolkit) { + log.Println("gui.Toolbox.NewButton() about to append to Box parent t:", w.Name) + t.Dump() + log.Println("gui.Toolbox.NewButton() about to append to Box new t:", w.Name) + newt.Dump() + } + if (t.uiBox != nil) { + t.uiBox.Append(newt.uiLabel, false) + } else { + log.Println("ERROR: wit/gui andlabs couldn't place this label in a box") + return + } + + mapWidgetsToolkits(w, newt) +} diff --git a/toolkit/andlabs2/main.go b/toolkit/andlabs2/main.go new file mode 100644 index 0000000..8a28710 --- /dev/null +++ b/toolkit/andlabs2/main.go @@ -0,0 +1,56 @@ +package main + +import ( + "log" +// "time" + + "git.wit.org/wit/gui/toolkit" + + "github.com/andlabs/ui" + // the _ means we only need this for the init() + _ "github.com/andlabs/ui/winmanifest" +) + +func Main(f func()) { + if (DebugToolkit) { + log.Println("Starting gui.Main() (using gtk via andlabs/ui)") + } + ui.Main( func() { + log.Println("Starting gui.Main() (using gtk via andlabs/ui)") + log.Println("Starting gui.Main() (using gtk via andlabs/ui)") + log.Println("Starting gui.Main() (using gtk via andlabs/ui)") + log.Println("Starting gui.Main() (using gtk via andlabs/ui)") + log.Println("Starting gui.Main() (using gtk via andlabs/ui)") + log.Println("Starting gui.Main() (using gtk via andlabs/ui)") + // time.Sleep(1 * time.Second) + // NewWindow2("helloworld2", 200, 100) + f() + }) +} + +// Other goroutines must use this to access the GUI +// +// You can not acess / process the GUI thread directly from +// other goroutines. This is due to the nature of how +// Linux, MacOS and Windows work (they all work differently. suprise. surprise.) +// +// For example: Queue(NewWindow()) +// +func Queue(f func()) { + if (DebugToolkit) { + log.Println("Sending function to ui.QueueMain() (using gtk via andlabs/ui)") + } + ui.QueueMain(f) +} + +func Init() { + log.Println("should Init() here") + + mapWidgets = make(map[*andlabsT]*toolkit.Widget) + mapToolkits = make(map[*toolkit.Widget]*andlabsT) +} + +func Quit() { + log.Println("should Quit() here") + // myExit(nil) +} diff --git a/toolkit/andlabs2/plugin.go b/toolkit/andlabs2/plugin.go new file mode 100644 index 0000000..f78e95e --- /dev/null +++ b/toolkit/andlabs2/plugin.go @@ -0,0 +1,43 @@ +package main + +import ( + "log" + + "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() { + log.Println("listMap() HERE") + log.Println("listMap() HERE") + log.Println("listMap() HERE mapWidgets()") + for t, w := range mapWidgets { + log.Println("andlabs =", t.Name, "widget =", w.Name) + } + log.Println("listMap() HERE mapToolkits()") + for w, t := range mapToolkits { + log.Println("andlabs =", t, "widget =", w.Name) + forceDump(t) + } +} + +func mapWidgetsToolkits(w *toolkit.Widget, t *andlabsT) { + if (mapToolkits[w] == nil) { + mapToolkits[w] = t + } else { + log.Println("WTF: mapToolkits already installed") + panic("WTF") + } + + if (mapWidgets[t] == nil) { + mapWidgets[t] = w + } else { + log.Println("WTF: mapWidgets already installed") + panic("WTF") + } +} diff --git a/toolkit/andlabs2/slider.go b/toolkit/andlabs2/slider.go new file mode 100644 index 0000000..f9ff0f3 --- /dev/null +++ b/toolkit/andlabs2/slider.go @@ -0,0 +1,48 @@ +package main + +import ( + "log" + "os" + + "git.wit.org/wit/gui/toolkit" + + "github.com/andlabs/ui" + _ "github.com/andlabs/ui/winmanifest" +) + +func (t andlabsT) NewSlider(title string, x int, y int) *andlabsT { + // make new node here + log.Println("gui.Toolkit.NewSpinbox()", x, y) + var newt andlabsT + + if (t.uiBox == nil) { + log.Println("gui.ToolkitNode.NewGroup() node.UiBox == nil. I can't add a range UI element without a place to put it") + log.Println("probably could just make a box here?") + os.Exit(0) + return nil + } + + s := ui.NewSlider(x, y) + newt.uiSlider = s + newt.uiBox = t.uiBox + t.uiBox.Append(s, stretchy) + + s.OnChanged(func(spin *ui.Slider) { + newt.commonChange("Slider") + }) + + return &newt +} + +func NewSlider(parentW *toolkit.Widget, w *toolkit.Widget) { + var newt *andlabsT + log.Println("gui.andlabs.NewTab()", w.Name) + + t := mapToolkits[parentW] + if (t == nil) { + log.Println("go.andlabs.NewTab() toolkit struct == nil. name=", parentW.Name, w.Name) + return + } + newt = t.NewSlider(w.Name, w.X, w.Y) + mapWidgetsToolkits(w, newt) +} diff --git a/toolkit/andlabs2/spinner.go b/toolkit/andlabs2/spinner.go new file mode 100644 index 0000000..6505b48 --- /dev/null +++ b/toolkit/andlabs2/spinner.go @@ -0,0 +1,30 @@ +package main + +import "log" +import "os" + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +func (t andlabsT) NewSpinner(title string, x int, y int) *andlabsT { + // make new node here + log.Println("gui.Toolkit.NewSpinner()", x, y) + var newt andlabsT + + if (t.uiBox == nil) { + log.Println("gui.ToolkitNode.NewSpinner() node.UiBox == nil. I can't add a range UI element without a place to put it") + os.Exit(0) + return nil + } + + s := ui.NewSpinbox(x, y) + newt.uiSpinbox = s + newt.uiBox = t.uiBox + t.uiBox.Append(s, stretchy) + + s.OnChanged(func(s *ui.Spinbox) { + newt.commonChange("Spinner") + }) + + return &newt +} diff --git a/toolkit/andlabs2/structs.go b/toolkit/andlabs2/structs.go new file mode 100644 index 0000000..2f3fa72 --- /dev/null +++ b/toolkit/andlabs2/structs.go @@ -0,0 +1,249 @@ +package main + +import "log" + +import "github.com/andlabs/ui" +import _ "github.com/andlabs/ui/winmanifest" + +import "github.com/davecgh/go-spew/spew" + +var defaultBehavior bool = true + +var bookshelf bool // do you want things arranged in the box like a bookshelf or a stack? +var canvas bool // if set to true, the windows are a raw canvas +var menubar bool // for windows +var stretchy bool // expand things like buttons to the maximum size +var padded bool // add space between things like buttons +var margin bool // add space around the frames of windows + +var DebugToolkit bool + +func setDefaultBehavior(s bool) { + defaultBehavior = s + if (defaultBehavior) { + if (DebugToolkit) { + log.Println("Setting this toolkit to use the default behavior.") + log.Println("This is the 'guessing' part as defined by the wit/gui 'Principles'. Refer to the docs.") + } + stretchy = false + padded = true + menubar = true + margin = true + canvas = false + bookshelf = true // 99% of the time, things make a vertical stack of objects + + DebugToolkit = false + } else { + log.Println("This toolkit is set to ignore the default behavior.") + } +} + +func SetDebugToolkit (s bool) { + DebugToolkit = s +} + +func GetDebugToolkit () bool { + return DebugToolkit +} + +// stores the raw toolkit internals +type andlabsT struct { + id string + + Name string + Width int + Height int + + OnChanged func(*andlabsT) + OnExit func(*andlabsT) + + Custom func() + + 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 + + // 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 + // but it's working for now due to the need for need for a correct interaction layer betten toolkits + c int + val map[int]string + text string +} + +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 { + t.Dump() + if (DebugToolkit) { + log.Println("gui.Toolkit.Text() Enter") + scs := spew.ConfigState{MaxDepth: 1} + scs.Dump(t) + } + if (t.uiEntry != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() =", t.uiEntry.Text()) + } + return t.uiEntry.Text() + } + if (t.uiMultilineEntry != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() =", t.uiMultilineEntry.Text()) + } + text := t.uiMultilineEntry.Text() + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() text =", text) + } + t.text = text + return text + } + if (t.uiCombobox != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.GetText() =", t.text) + } + return t.text + } + return "" +} + +func (t *andlabsT) SetText(s string) bool { + if (DebugToolkit) { + log.Println("gui.Toolkit.Text() Enter") + scs := spew.ConfigState{MaxDepth: 1} + scs.Dump(t) + } + if (t.uiEntry != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() =", t.uiEntry.Text) + } + t.uiEntry.SetText(s) + return true + } + if (t.uiMultilineEntry != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() =", t.uiMultilineEntry.Text) + } + t.uiMultilineEntry.SetText(s) + return true + } + return false +} + +func sanity(t *andlabsT) bool { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() Enter") + scs := spew.ConfigState{MaxDepth: 1} + scs.Dump(t) + } + if (t.uiEntry == nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() =", t.uiEntry.Text) + } + return false + } + return true +} + +func (t *andlabsT) SetValue(i int) bool { + log.Println("gui.Toolkit.SetValue() START") + if (sanity(t)) { + return false + } + t.Dump() + // panic("got to toolkit.SetValue") + return true +} + +func (t *andlabsT) Value() int { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() Enter") + scs := spew.ConfigState{MaxDepth: 1} + scs.Dump(t) + } + if (t == nil) { + log.Println("gui.Toolkit.Value() can not get value t == nil") + return 0 + } + if (t.uiSlider != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() =", t.uiSlider.Value) + } + return t.uiSlider.Value() + } + if (t.uiSpinbox != nil) { + if (DebugToolkit) { + log.Println("gui.Toolkit.Value() =", t.uiSpinbox.Value) + } + return t.uiSpinbox.Value() + } + log.Println("gui.Toolkit.Value() Could not find a ui element to get a value from") + return 0 +} + +func (t *andlabsT) Dump() { + if ! DebugToolkit { + return + } + log.Println("gui.Toolkit.Dump() Name = ", t.Name, t.Width, t.Height) + if (t.uiBox != nil) { + log.Println("gui.Toolkit.Dump() uiBox =", t.uiBox) + } + if (t.uiButton != nil) { + log.Println("gui.Toolkit.Dump() uiButton =", t.uiButton) + } + if (t.uiCombobox != nil) { + log.Println("gui.Toolkit.Dump() uiCombobox =", t.uiCombobox) + } + if (t.uiWindow != nil) { + log.Println("gui.Toolkit.Dump() uiWindow =", t.uiWindow) + } + if (t.uiTab != nil) { + log.Println("gui.Toolkit.Dump() uiTab =", t.uiTab) + } + if (t.uiGroup != nil) { + log.Println("gui.Toolkit.Dump() uiGroup =", t.uiGroup) + } + if (t.uiEntry != nil) { + log.Println("gui.Toolkit.Dump() uiEntry =", t.uiEntry) + } + if (t.uiMultilineEntry != nil) { + log.Println("gui.Toolkit.Dump() uiMultilineEntry =", t.uiMultilineEntry) + } + if (t.uiSlider != nil) { + log.Println("gui.Toolkit.Dump() uiSlider =", t.uiSlider) + } + if (t.uiCheckbox != nil) { + log.Println("gui.Toolkit.Dump() uiCheckbox =", t.uiCheckbox) + } + if (t.OnExit != nil) { + log.Println("gui.Toolkit.Dump() OnExit =", t.OnExit) + } + if (t.Custom != nil) { + log.Println("gui.Toolkit.Dump() Custom =", t.Custom) + } + log.Println("gui.Toolkit.Dump() c =", t.c) + log.Println("gui.Toolkit.Dump() val =", t.val) + log.Println("gui.Toolkit.Dump() text =", t.text) +} diff --git a/toolkit/andlabs2/tab.go b/toolkit/andlabs2/tab.go new file mode 100644 index 0000000..0556fb9 --- /dev/null +++ b/toolkit/andlabs2/tab.go @@ -0,0 +1,147 @@ +package main + +import ( + "log" + "time" + + "git.wit.org/wit/gui/toolkit" + + "github.com/andlabs/ui" + _ "github.com/andlabs/ui/winmanifest" +) + +/* + This adds a tab + + andlabs/ui is goofy in the sense that you have to determine + if the ui.Window already has a tab in it. If it does, then + you need to add this tab and not run SetChild() on the window + or instead it replaces the existing tab with the new one + + I work around this by always sending a Toolkit that is a tab + 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 { + // var w *ui.Window + var newt *andlabsT + + log.Println("gui.toolkit.AddTab() sleep 3") + + if (t.uiWindow == nil) { + log.Println("gui.Toolkit.UiWindow == nil. I can't add a toolbar without window") + return nil + } + + if (t.uiTab == nil) { + // this means you have to make a new tab + log.Println("gui.toolkit.NewTab() GOOD. This should be the first tab:", name) + newt = newTab(t.uiWindow, name) + t.uiTab = newt.uiTab + } else { + // this means you have to append a tab + log.Println("gui.toolkit.NewTab() GOOD. This should be an additional tab:", name) + newt = t.appendTab(name) + } + + newt.Name = name + + if (DebugToolkit) { + log.Println("t:") + t.Dump() + log.Println("newt:") + newt.Dump() + } + + return newt +} + +// This sets _all_ the tabs to Margin = true +// +// TODO: do proper tab tracking (will be complicated). low priority +func tabSetMargined(tab *ui.Tab) { + c := tab.NumPages() + for i := 0; i < c; i++ { + if (DebugToolkit) { + log.Println("SetMargined", i, margin) + } + tab.SetMargined(i, margin) + } +} + +func newTab(w *ui.Window, name string) *andlabsT { + var t andlabsT + if (DebugToolkit) { + log.Println("gui.toolkit.NewTab() ADD", name) + } + + if (w == nil) { + log.Println("gui.toolkit.NewTab() node.UiWindow == nil. I can't add a tab without a window") + log.Println("gui.toolkit.NewTab() node.UiWindow == nil. I can't add a tab without a window") + log.Println("gui.toolkit.NewTab() node.UiWindow == nil. I can't add a tab without a window") + time.Sleep(1 * time.Second) + return nil + } + if (DebugToolkit) { + log.Println("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) // TODO: run this in the right place(?) + w.SetChild(tab) + + t.uiWindow = w + t.uiTab = tab + t.uiBox = hbox + return &t +} + +func (t *andlabsT) appendTab(name string) *andlabsT { + var newT andlabsT + if (DebugToolkit) { + log.Println("gui.toolkit.NewTab() ADD", name) + } + + if (t.uiTab == nil) { + log.Println("gui.Toolkit.UiWindow == nil. I can't add a widget without a place to put it") + panic("should never have happened. wit/gui/toolkit has ui.Tab == nil") + } + if (DebugToolkit) { + log.Println("gui.toolkit.AddTab() START name =", name) + } + + var hbox *ui.Box + if (defaultBehavior) { + hbox = ui.NewHorizontalBox() + } else { + if (bookshelf) { + hbox = ui.NewHorizontalBox() + } else { + hbox = ui.NewVerticalBox() + } + } + hbox.SetPadded(padded) + t.uiTab.Append(name, hbox) + + newT.uiWindow = t.uiWindow + newT.uiTab = t.uiTab + newT.uiBox = hbox + return &newT +} + +func NewTab(parentW *toolkit.Widget, w *toolkit.Widget) { + var newt *andlabsT + log.Println("gui.andlabs.NewTab()", w.Name) + + t := mapToolkits[parentW] + if (t == nil) { + log.Println("go.andlabs.NewTab() toolkit struct == nil. name=", parentW.Name, w.Name) + return + } + newt = t.newTab(w.Name) + mapWidgetsToolkits(w, newt) +} diff --git a/toolkit/andlabs2/textbox.go b/toolkit/andlabs2/textbox.go new file mode 100644 index 0000000..c7a9390 --- /dev/null +++ b/toolkit/andlabs2/textbox.go @@ -0,0 +1,70 @@ +package main + +import "log" + +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 + + if (DebugToolkit) { + log.Println("gui.Toolkit.NewTextbox()", name) + } + if t.broken() { + return nil + } + + c := ui.NewNonWrappingMultilineEntry() + newt.uiMultilineEntry = c + + newt.uiBox = t.uiBox + newt.Name = name + if (defaultBehavior) { + t.uiBox.Append(c, true) + } else { + t.uiBox.Append(c, stretchy) + } + + c.OnChanged(func(spin *ui.MultilineEntry) { + newt.commonChange("Textbox") + }) + + return &newt +} + +func NewTextbox(parentW *toolkit.Widget, w *toolkit.Widget) { + var t, newt *andlabsT + log.Println("gui.andlabs.NewTextbox()", w.Name) + + t = mapToolkits[parentW] + if (t == nil) { + log.Println("go.andlabs.NewTextbox() toolkit struct == nil. name=", parentW.Name, w.Name) + return + } + + if t.broken() { + return + } + newt = new(andlabsT) + + newt.uiLabel = ui.NewLabel(w.Name) + newt.uiBox = t.uiBox + + if (DebugToolkit) { + log.Println("gui.Toolbox.NewTextbox() about to append to Box parent t:", w.Name) + t.Dump() + log.Println("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.Println("ERROR: wit/gui andlabs couldn't place this Textbox in a box") + return + } + + mapWidgetsToolkits(w, newt) +} diff --git a/toolkit/andlabs2/window.go b/toolkit/andlabs2/window.go new file mode 100644 index 0000000..b360cb8 --- /dev/null +++ b/toolkit/andlabs2/window.go @@ -0,0 +1,78 @@ +package main + +import ( + "log" + + "github.com/andlabs/ui" + _ "github.com/andlabs/ui/winmanifest" + + "git.wit.org/wit/gui/toolkit" +) + +func (t *andlabsT) MessageWindow(msg1 string, msg2 string) { + ui.MsgBox(t.uiWindow, msg1, msg2) +} + +func (t *andlabsT) ErrorWindow(msg1 string, msg2 string) { + ui.MsgBoxError(t.uiWindow, msg1, msg2) +} + +func NewWindow(w *toolkit.Widget) { + var t *andlabsT + + if (DebugToolkit) { + log.Println("toolkit NewWindow", w.Name, w.Width, w.Height) + } + + if (w == nil) { + log.Println("wit/gui plugin error. widget == nil") + return + } + t = new(andlabsT) + // t = NewWindow2(w.Name, w.Width, w.Height) + +// 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 { + if (DebugToolkit) { + log.Println("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 + } + if (DebugToolkit) { + log.Println("andlabs.ui.Window().OnClosing() was not defined") + } + return false + }) + win.Show() + t.uiWindow = win + t.UiWindowBad = win // deprecate this as soon as possible + t.Name = w.Name + + mapWidgetsToolkits(w, t) + return +} + +func (t *andlabsT) SetWindowTitle(title string) { + if (DebugToolkit) { + log.Println("toolkit NewWindow", t.Name, "title", title) + } + win := t.uiWindow + if (win != nil) { + win.SetTitle(title) + } else { + if (DebugToolkit) { + log.Println("Setting the window title", title) + } + } +} diff --git a/toolkit/gocui/Makefile b/toolkit/gocui/Makefile index 27f23ed..597b2b2 100644 --- a/toolkit/gocui/Makefile +++ b/toolkit/gocui/Makefile @@ -6,3 +6,6 @@ build: plugin: GO111MODULE="off" go build -buildmode=plugin -o ../gocui.so + +objdump: + objdump -t ../gocui.so |less diff --git a/toolkit/gocui/button.go b/toolkit/gocui/button.go index 8fb6e05..5b41c48 100644 --- a/toolkit/gocui/button.go +++ b/toolkit/gocui/button.go @@ -7,42 +7,49 @@ import ( "strings" "github.com/awesome-gocui/gocui" + "git.wit.org/wit/gui/toolkit" ) -func (w *Widget) AddButton() { -// func (g greeting) AddButton() { +func NewButton(parentW *toolkit.Widget, w *toolkit.Widget) { log.Println("gui.gocui.AddButton()", w.Name) - addButton2(w.Name, w.Event) + addButton(w.Name) + // viewWidget[v] = w + stringWidget[w.Name] = w + listMap() } -func addButton2(name string, e func(*Widget) *Widget) { - addButton(name) -} - -func addButton(name string) error { +func addButton(name string) *gocui.View { t := len(name) + if (baseGui == nil) { + panic("WTF") + } v, err := baseGui.SetView(name, currentX, currentY, currentX+t+3, currentY+2, 0) if err == nil { - return err + log.Println("wit/gui internal plugin error", err) + return nil } if !errors.Is(err, gocui.ErrUnknownView) { - return err + log.Println("wit/gui internal plugin error", err) + return nil } v.Wrap = true fmt.Fprintln(v, " " + name) fmt.Fprintln(v, strings.Repeat("foo\n", 2)) - if _, err := baseGui.SetCurrentView(name); err != nil { - return err + currentView, err := baseGui.SetCurrentView(name) + if err != nil { + log.Println("wit/gui internal plugin error", err) + return nil } + log.Println("wit/gui addbutton() current view name =", currentView.Name()) views = append(views, name) curView = len(views) - 1 idxView += 1 currentY += 3 - if (groupSize < len(views)) { - groupSize = len(views) + if (groupSize < len(name)) { + groupSize = len(name) } - return nil + return currentView } diff --git a/toolkit/gocui/main.go b/toolkit/gocui/gocui.go index 314f5be..d614387 100644 --- a/toolkit/gocui/main.go +++ b/toolkit/gocui/gocui.go @@ -8,6 +8,9 @@ import ( "errors" "fmt" "log" + "os" + + "git.wit.org/wit/gui/toolkit" "github.com/awesome-gocui/gocui" ) @@ -22,61 +25,57 @@ var ( currentY = 2 groupSize = 0 baseGui *gocui.Gui + helpLabel *gocui.View + err error + ch chan(func ()) ) -var helpLabel *gocui.View - func Init() { - // setup log to write to a file -// logInit() - - g, err := gocui.NewGui(gocui.OutputNormal, true) - baseGui = g + baseGui, err = gocui.NewGui(gocui.OutputNormal, true) if err != nil { log.Panicln(err) } - defer g.Close() - g.Highlight = true - g.SelFgColor = gocui.ColorRed - g.SelFrameColor = gocui.ColorRed + baseGui.Highlight = true + baseGui.SelFgColor = gocui.ColorRed + baseGui.SelFrameColor = gocui.ColorRed - g.SetManagerFunc(layout) + baseGui.SetManagerFunc(layout) - if err := initKeybindings(g); err != nil { + if err := initKeybindings(baseGui); err != nil { log.Panicln(err) } - if err := newView(g); err != nil { - log.Panicln(err) - } - - addButton("hello") - addButton("world") - addButton("foo") - addGroup("blank") - addButton("bar") - addButton("bar none") - addButton("bar going") + viewWidget = make(map[*gocui.View]*toolkit.Widget) + stringWidget = make(map[string]*toolkit.Widget) - addGroup("te") - addButton("world 2") - addButton("foo 2") + ch = make(chan func()) +} - if err := baseGui.MainLoop(); err != nil && !errors.Is(err, gocui.ErrQuit) { - log.Panicln(err) - } +func Queue(f func()) { + log.Println("QUEUEEEEE") + f() } -func ToolkitMain() { +func Main(f func()) { + if (baseGui == nil) { + panic("WTF Main()") + } + defer baseGui.Close() + // log.Println("ADDDDDDDD BUTTTTTTTTTON") + // addButton("test 3") + f() if err := baseGui.MainLoop(); err != nil && !errors.Is(err, gocui.ErrQuit) { log.Panicln(err) } + baseGui.Close() + os.Exit(0) } func layout(g *gocui.Gui) error { var err error maxX, _ := g.Size() + helpLabel, err = g.SetView("help", maxX-32, 0, maxX-1, 11, 0) if err != nil { if !errors.Is(err, gocui.ErrUnknownView) { diff --git a/toolkit/gocui/greeter.go b/toolkit/gocui/greeter.go deleted file mode 100644 index e3094e5..0000000 --- a/toolkit/gocui/greeter.go +++ /dev/null @@ -1,79 +0,0 @@ -package main - -import ( - "log" - - // "errors" - // "fmt" - // "strings" - // "github.com/awesome-gocui/gocui" -) - -type greeting string - -// stores the raw toolkit internals -type toolkit struct { - id string - Name string - - OnChanged func(toolkit) -} - -// this is exported -var Greeter greeting -var Toolkit toolkit - -// func main() { -func (g greeting) Greet() { - log.Println("Hello Universe") - Init() - // ToolkitMain() -} - -func (g greeting) JcarrButton() { - log.Println("Hello GreetButton meet Universe") - addButton("Greet foo") - addButton("Greet foo 2") -} - -func addGroup(name string) { - log.Println("addGroup()", name) - currentY = 2 - currentX += groupSize + 6 -} - -func (g greeting) AddButton(name string) { -// func (g greeting) AddButton() { - log.Println("gui.gocui.AddButton()", name) - addButton(name) -} - -/* -func addButton(name string) error { - t := len(name) - v, err := baseGui.SetView(name, currentX, currentY, currentX+t+3, currentY+2, 0) - if err == nil { - return err - } - if !errors.Is(err, gocui.ErrUnknownView) { - return err - } - - v.Wrap = true - fmt.Fprintln(v, " " + name) - fmt.Fprintln(v, strings.Repeat("foo\n", 2)) - - if _, err := baseGui.SetCurrentView(name); err != nil { - return err - } - - views = append(views, name) - curView = len(views) - 1 - idxView += 1 - currentY += 3 - if (groupSize < len(views)) { - groupSize = len(views) - } - return nil -} -*/ diff --git a/toolkit/gocui/group.go b/toolkit/gocui/group.go new file mode 100644 index 0000000..7cea346 --- /dev/null +++ b/toolkit/gocui/group.go @@ -0,0 +1,38 @@ +package main + +import ( + "log" + + "git.wit.org/wit/gui/toolkit" +) + +func NewGroup(parentW *toolkit.Widget, w *toolkit.Widget) { + if (parentW == nil) { + log.Println("wit/gui plugin error. parent widget == nil") + return + } + if (w == nil) { + log.Println("wit/gui plugin error. widget == nil") + return + } + if (w.Name == "") { + w.Name = parentW.Name + } + if (w.Name == "") { + w.Name = "nil newGroup" + } + log.Println("gui.gocui.AddGroup", w.Name) + addGroup(w.Name) + stringWidget[w.Name] = w +} + +func addGroup(name string) { + log.Println("addGroup() START name =", name) + log.Println("addGroup() START groupSize =", groupSize, "currentY =", currentY, "currentX =", currentX) + + currentY = 2 + currentX += groupSize + 5 + groupSize = 0 + + log.Println("addGroup() START, RESET Y = 3, RESET X = ", currentX) +} diff --git a/toolkit/gocui/keybindings.go b/toolkit/gocui/keybindings.go index fdac1ff..69def39 100644 --- a/toolkit/gocui/keybindings.go +++ b/toolkit/gocui/keybindings.go @@ -11,6 +11,7 @@ import ( // "strings" "github.com/awesome-gocui/gocui" + "git.wit.org/wit/gui/toolkit" ) func initKeybindings(g *gocui.Gui) error { @@ -87,6 +88,21 @@ func initKeybindings(g *gocui.Gui) error { if err := g.SetKeybinding("", gocui.KeyEnter, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error { log.Println("enter", v.Name()) + var w *toolkit.Widget + w = stringWidget[v.Name()] + if (w == nil) { + log.Println("COULD NOT FIND WIDGET", v.Name()) + } else { + log.Println("FOUND WIDGET!", w) + if (w.Custom != nil) { + w.Custom() + return nil + } + if (w.Event != nil) { + w.Event(w) + return nil + } + } return nil }); err != nil { return err @@ -105,17 +121,11 @@ func initKeybindings(g *gocui.Gui) error { }); err != nil { return err } - if err := g.SetKeybinding("", 'j', gocui.ModNone, - func(g *gocui.Gui, v *gocui.View) error { - return newJ(g) - }); err != nil { - return err - } if err := g.SetKeybinding("", 'h', gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error { log.Println("help", v.Name()) tmp, _ := g.SetViewOnTop("help") - log.Println("help 2", tmp.Name(), "blah") + log.Println("help 2", tmp.Name()) // g.SetView("help", 2, 2, 30, 15, 0); g.SetCurrentView("help") // moveView(g, tmp, 0, -delta) diff --git a/toolkit/gocui/newJ.go b/toolkit/gocui/newJ.go deleted file mode 100644 index 3e04cd3..0000000 --- a/toolkit/gocui/newJ.go +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright 2014 The gocui Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package main - -import ( - "errors" - "fmt" - "log" - "strings" - - "github.com/awesome-gocui/gocui" -) - -var topX int = 2 -var bottomX int = 20 -var topY int = 2 -var bottomY int = 7 - -func newJ(g *gocui.Gui) error { - // maxX, maxY := g.Size() - name := fmt.Sprintf("jcarr %v foo ", idxView) - v, err := g.SetView(name, topX, topY, bottomX, bottomY, 0) - if err == nil { - return err - } - if !errors.Is(err, gocui.ErrUnknownView) { - return err - } - - v.Wrap = true - fmt.Fprintln(v, name) - fmt.Fprintln(v, strings.Repeat("foo\n", 2)) - // fmt.Fprintln(v, strings.Repeat(name+" ", 30)) - log.Println("newJ added a new view", v.Name()) - - if _, err := g.SetCurrentView(name); err != nil { - return err - } - - views = append(views, name) - curView = len(views) - 1 - idxView += 1 - return nil -} diff --git a/toolkit/gocui/plugin.go b/toolkit/gocui/plugin.go new file mode 100644 index 0000000..5be26f3 --- /dev/null +++ b/toolkit/gocui/plugin.go @@ -0,0 +1,28 @@ +package main + +import ( + "log" + + "git.wit.org/wit/gui/toolkit" + + "github.com/awesome-gocui/gocui" +) + +// This is a map between the widgets in wit/gui and the internal structures of gocui +var viewWidget map[*gocui.View]*toolkit.Widget +var stringWidget map[string]*toolkit.Widget + +func Quit() { + baseGui.Close() +} + +// This lists out the know mappings +func listMap() { + for v, w := range viewWidget { + log.Println("view =", v.Name, "widget name =", w.Name) + } + for s, w := range stringWidget { + log.Println("string =", s, "widget =", w) + } +} + diff --git a/toolkit/gocui/views.go b/toolkit/gocui/views.go index 6c9c65d..defe2b2 100644 --- a/toolkit/gocui/views.go +++ b/toolkit/gocui/views.go @@ -11,6 +11,7 @@ import ( "strings" "github.com/awesome-gocui/gocui" + // "git.wit.org/wit/gui/toolkit" ) func newView(g *gocui.Gui) error { diff --git a/toolkit/gocui/widget.go b/toolkit/gocui/widget.go deleted file mode 100644 index 758ac38..0000000 --- a/toolkit/gocui/widget.go +++ /dev/null @@ -1,26 +0,0 @@ -package main - -// passes information between the toolkit library (plugin) - -// All Toolkit interactions should be done via a channel or Queue() - -// This is the only thing that is passed between the toolkit plugin - -// what names should be used? This is not part of [[Graphical Widget]] -// Event() seems like a good name. -// Could a protobuf be used here? (Can functions be passed?) -type Widget struct { - i int - s string - - Name string - Width int - Height int - - Event func(*Widget) *Widget - - // Probably deprecate these - OnChanged func(*Widget) - Custom func(*Widget) - OnExit func(*Widget) -} diff --git a/toolkit/gocui/window.go b/toolkit/gocui/window.go new file mode 100644 index 0000000..b2d241d --- /dev/null +++ b/toolkit/gocui/window.go @@ -0,0 +1,18 @@ +package main + +import ( + "log" + + "git.wit.org/wit/gui/toolkit" +) + +func NewWindow(w *toolkit.Widget) { + if (w == nil) { + log.Println("wit/gui plugin error. widget == nil") + return + } + if (w.Name == "") { + w.Name = "nil newWindow" + } + log.Println("gui.gocui.AddWindow", w.Name) +} diff --git a/toolkit/hello/Makefile b/toolkit/hello/Makefile deleted file mode 100644 index 8271843..0000000 --- a/toolkit/hello/Makefile +++ /dev/null @@ -1,8 +0,0 @@ -all: plugin - ldd ../hello.so - -build: - GO111MODULE="off" go build - -plugin: - GO111MODULE="off" go build -buildmode=plugin -o ../hello.so diff --git a/toolkit/hello/greeter.go b/toolkit/hello/greeter.go deleted file mode 100644 index 1eb3307..0000000 --- a/toolkit/hello/greeter.go +++ /dev/null @@ -1,23 +0,0 @@ -package main - -import ( -// "errors" - "fmt" -// "log" -// "strings" - -// "github.com/awesome-gocui/gocui" -) - -type greeting string - - -// func main() { -func (g greeting) Greet() { - fmt.Println("Hello Universe") - Init() - // ToolkitMain() -} - -// this is exported -var Greeter greeting diff --git a/toolkit/hello/main.go b/toolkit/hello/main.go deleted file mode 100644 index 3a72d1f..0000000 --- a/toolkit/hello/main.go +++ /dev/null @@ -1,44 +0,0 @@ -// This creates a simple hello world window -package main - -import ( - "os" - "log" - "git.wit.org/wit/gui" -) - -func Init() { - gui.Main(myGUI) -} - -// This initializes the first window -func myGUI() { - var w *gui.Node - gui.Config.Title = "Hello World golang wit/gui Window" - gui.Config.Width = 640 - gui.Config.Height = 480 - gui.Config.Exit = myExit - - w = gui.NewWindow() - addHelloWorld(w, "A Simple Tab") -} - -func addHelloWorld(window *gui.Node, title string) { - var newNode, g, tb *gui.Node - - newNode = window.NewTab(title) - - g = newNode.NewGroup("hello") - tb = g.NewTextbox("hello world box") // when debugging, this string will be used - tb.OnChanged = func(*gui.Node) { - s := tb.GetText() - log.Println("text box =", s) - } - tb.SetText("world") -} - -func myExit(n *gui.Node) { - log.Println("exit() here") - os.Exit(0) -} - diff --git a/toolkit/widget.go b/toolkit/widget.go new file mode 100644 index 0000000..9003546 --- /dev/null +++ b/toolkit/widget.go @@ -0,0 +1,69 @@ +package toolkit + +// passes information between the toolkit library (plugin) + +// All Toolkit interactions should be done via a channel or Queue() + +// This is the only thing that is passed between the toolkit plugin + +// what names should be used? This is not part of [[Graphical Widget]] +// Event() seems like a good name. +// Could a protobuf be used here? (Can functions be passed?) +type Widget struct { + i int + s string + + Name string + Width int + Height int + X int + Y int + + Custom func() + Event func(*Widget) *Widget + + // Probably deprecate these +// OnChanged func(*Widget) +// Custom func(*Widget) +// OnExit func(*Widget) +} + +type Blah struct { + i int + s string + + Name string + Width int + Height int +} + +/* +type Widget int + +// https://ieftimov.com/post/golang-datastructures-trees/ +const ( + Unknown Widget = iota + Window + Tab + Frame + Dropbox + Spinner + Label +) + +func (s Widget) String() string { + switch s { + case Window: + return "Window" + case Tab: + return "Tab" + case Frame: + return "Frame" + case Label: + return "Label" + case Dropbox: + return "Dropbox" + } + return "unknown" +} +*/ |