jcarr
/
new-gui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into devel

This commit is contained in:
Jeff Carr 2022-10-11 11:59:42 -05:00
parent 04c9f6d89d 23b29405fe
commit 9076499b30
30 changed files with 2150 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -1 +1,3 @@
*.swp
cmds/gui-example/gui-example
cmds/gui-demo/gui-demo

20
Makefile
View File

@ -1,19 +1,13 @@
# simple sortcut to push all git changes
push:
git checkout devel
git pull
git add --all
-git commit -a -s
git push
all:
@echo
@echo "make examples # will run all the examples"
@echo "make update # full git update"
@echo
# should update every go dependancy (?)
update:
git pull
go get -v -t -u ./...
merge-devel:
git checkout master
git pull origin master
git merge devel
git push origin master
git checkout devel
examples:
make -C gui-example

10
area.go
View File

@ -107,10 +107,10 @@ func (ah GuiArea) KeyEvent(a *ui.Area, ke *ui.AreaKeyEvent) (handled bool) {
return false
}
func ShowTextBox(box *GuiBox, newText *ui.AttributedString, custom func(*GuiButton), name string) {
func (b *GuiBox) ShowTextBox(newText *ui.AttributedString, custom func(*GuiButton), name string) {
log.Println("ShowTextBox() START")
gw := box.Window
gw := b.Window
if (gw == nil) {
log.Println("ShowTextBox() ERROR gw = nil")
return
@ -127,10 +127,10 @@ func ShowTextBox(box *GuiBox, newText *ui.AttributedString, custom func(*GuiButt
*/
// TODO: allow padded & axis here
box.UiBox.SetPadded(true)
b.UiBox.SetPadded(true)
// add(gw.BoxMap["MAINBOX"], newbox)
makeGenericArea(box, newText, custom)
box.UiBox.Append(box.Window.Area.UiArea, true)
makeGenericArea(b, newText, custom)
b.UiBox.Append(b.Window.Area.UiArea, true)
}

116
box.go
View File

@ -1,6 +1,7 @@
package gui
import "log"
import "os"
// import "reflect"
import "github.com/andlabs/ui"
@ -34,6 +35,7 @@ func add(box *GuiBox, newbox *GuiBox) {
newbox.Window.BoxMap["MAINBOX"] = newbox
log.Println("gui.add() END")
panic("gui.add() MAINBOX gui.add() END")
return
} else {
log.Println("\tgui.add() ERROR DONT KNOW HOW TO ADD TO A RAW WINDOW YET")
@ -41,33 +43,77 @@ func add(box *GuiBox, newbox *GuiBox) {
}
log.Println("\tgui.add() ERROR DON'T KNOW HOW TO add to Window as MAINBOX DONE")
log.Println("gui.add() END")
panic("gui.add() gui.add() END")
return
}
log.Println("\tgui.add() adding", newbox.Name, "to", box.Name)
// copy the box settings over
newbox.Window = box.Window
if (box.UiBox == nil) {
log.Println("\tgui.add() ERROR box.UiBox == nil")
panic("crap")
if (box.node == nil) {
box.Dump()
panic("gui.add() ERROR box.node == nil")
}
if (newbox.UiBox == nil) {
log.Println("\tgui.add() ERROR newbox.UiBox == nil")
panic("crap")
panic("gui.add() ERROR newbox.UiBox == nil")
}
if (box.UiBox == nil) {
box.Dump()
// panic("gui.add() ERROR box.UiBox == nil")
return
// TODO: fix this whole add() function // Oct 9
}
// log.Println("\tgui.add() newbox.UiBox == ", newbox.UiBox.GetParent())
// spew.Dump(newbox.UiBox)
box.UiBox.Append(newbox.UiBox, false)
box.Dump()
panic("gui.add()")
// add the newbox to the Window.BoxMap[]
box.Window.BoxMap[newbox.Name] = newbox
log.Println("gui.add() END")
}
func NewBox(box *GuiBox, axis int, name string) *GuiBox {
log.Println("VerticalBox START")
func (n *Node) AddBox(axis int, name string) *Node {
newBox := new(GuiBox)
newBox.Window = n.window
newBox.Name = name
if (n.box == nil) {
n.box = newBox
}
// make a new box & a new node
newNode := n.makeNode(name, 111, 100 + Config.counter)
newNode.box = newBox
Config.counter += 1
var uiBox *ui.Box
if (axis == Xaxis) {
uiBox = ui.NewHorizontalBox()
} else {
uiBox = ui.NewVerticalBox()
}
uiBox.SetPadded(true)
newBox.UiBox = uiBox
newNode.uiBox = uiBox
n.Append(newNode)
// add(n.box, newBox)
return newNode
}
func (b *GuiBox) NewBox(axis int, name string) *GuiBox {
log.Println("gui.NewBox() START")
n := b.FindNode()
if (n == nil) {
log.Println("gui.NewBox() SERIOUS ERROR. CAN NOT FIND NODE")
os.Exit(0)
} else {
log.Println("gui.NewBox() node =", n.Name)
}
var newbox *GuiBox
newbox = new(GuiBox)
newbox.Window = box.Window
newbox.Window = b.Window
newbox.Name = name
var uiBox *ui.Box
@ -78,13 +124,18 @@ func NewBox(box *GuiBox, axis int, name string) *GuiBox {
}
uiBox.SetPadded(true)
newbox.UiBox = uiBox
add(box, newbox)
add(b, newbox)
// panic("gui.NewBox")
return newbox
}
func HardBox(gw *GuiWindow, axis int, name string) *GuiBox {
log.Println("HardBox() START axis =", axis)
if (gw.node == nil) {
gw.Dump()
panic("gui.HardBox() gw.node == nil")
}
// add a Vertical Seperator if there is already a box
// Is this right?
box := gw.BoxMap["MAINBOX"]
@ -120,6 +171,12 @@ func HardBox(gw *GuiWindow, axis int, name string) *GuiBox {
func HorizontalBreak(box *GuiBox) {
log.Println("VerticalSeparator added to box =", box.Name)
tmp := ui.NewHorizontalSeparator()
if (box == nil) {
return
}
if (box.UiBox == nil) {
return
}
box.UiBox.Append(tmp, false)
}
@ -128,3 +185,40 @@ func VerticalBreak(box *GuiBox) {
tmp := ui.NewVerticalSeparator()
box.UiBox.Append(tmp, false)
}
func (n *Node) AddComboBox(title string, s ...string) *Node {
box := n.uiBox
if (box == nil) {
return n
}
ecbox := ui.NewEditableCombobox()
for id, name := range s {
log.Println("Adding Combobox Entry:", id, name)
ecbox.Append(name)
}
ecbox.OnChanged(func(*ui.EditableCombobox) {
test := ecbox.Text()
log.Println("node.Name = '" + n.Name + "' text for '" + title + "' is now: '" + test + "'")
})
box.Append(ecbox, false)
newNode := n.AddNode(title)
newNode.uiText = ecbox
return newNode
}
func (n *Node) OnChanged(f func()) {
f()
}
func (n *Node) GetText() string {
if (n.uiText == nil) {
return ""
}
ecbox := n.uiText
return ecbox.Text()
}

60
button.go
View File

@ -1,10 +1,12 @@
package gui
import "log"
import "reflect"
import "github.com/andlabs/ui"
import _ "github.com/andlabs/ui/winmanifest"
// import "github.com/davecgh/go-spew/spew"
// This is the default mouse click handler
// Every mouse click that hasn't been assigned to
// something specific will fall into this routine
@ -50,6 +52,60 @@ func guiButtonClick(button *GuiButton) {
}
}
func (n *Node) AddButton(name string, custom func(*Node)) *Node {
if (n.uiBox == nil) {
log.Println("gui.Node.AppendButton() filed node.UiBox == nil")
return n
}
button := ui.NewButton(name)
log.Println("reflect.TypeOF(uiBox) =", reflect.TypeOf(n.uiBox))
log.Println("reflect.TypeOF(uiButton) =", reflect.TypeOf(button))
n.uiBox.Append(button, false)
n.uiButton = button
newNode := n.makeNode(name, 888, 888 + Config.counter)
newNode.uiButton = button
newNode.custom = custom
button.OnClicked(func(*ui.Button) {
log.Println("gui.AppendButton() Button Clicked. Running custom()")
custom(newNode)
})
// panic("AppendButton")
// time.Sleep(3 * time.Second)
return newNode
}
func (n *Node) CreateButton(custom func(*GuiButton), name string, values interface {}) *Node {
newNode := n.AddBox(Xaxis, "test CreateButton")
box := newNode.FindBox()
if (box == nil) {
panic("node.CreateButton().FindBox() == nil")
}
newUiB := ui.NewButton(name)
newUiB.OnClicked(defaultButtonClick)
var newB *GuiButton
newB = new(GuiButton)
newB.B = newUiB
if (box.UiBox == nil) {
log.Println("CreateButton() box.Window == nil")
// ErrorWindow(box.Window, "Login Failed", msg) // can't even do this
panic("maybe print an error and return nil? or make a fake button?")
} else {
// uibox := box.UiBox
// uibox.Append(newUiB, true)
}
newB.Box = box
newB.Custom = custom
newB.Values = values
Data.AllButtons = append(Data.AllButtons, newB)
box.Append(newB.B, false)
return newNode
}
func CreateButton(box *GuiBox, custom func(*GuiButton), name string, values interface {}) *GuiButton {
newUiB := ui.NewButton(name)
newUiB.OnClicked(defaultButtonClick)
@ -68,7 +124,7 @@ func CreateButton(box *GuiBox, custom func(*GuiButton), name string, values inte
Data.AllButtons = append(Data.AllButtons, newB)
box.UiBox.Append(newB.B, false)
box.Append(newB.B, false)
return newB
}
@ -110,6 +166,6 @@ func CreateColorButton(box *GuiBox, custom func(*GuiButton), name string, values
Data.MouseClick(&newCB)
}
})
box.UiBox.Append(newCB.CB, false)
box.Append(newCB.CB, false)
return &newCB
}

5
cmds/gui-demo/Makefile Normal file
View File

@ -0,0 +1,5 @@
run: build
./gui-demo
build:
go build

33
cmds/gui-demo/demo-window.go Normal file
View File

@ -0,0 +1,33 @@
package main
import "log"
import "git.wit.org/wit/gui"
func demoClick (n *gui.Node) {
log.Println("demoClick() Dumping node:")
n.Dump()
}
func addDemoTab(n *gui.Node, title string) {
newNode := n.AddTab(title, nil)
if (gui.Config.Debug) {
newNode.Dump()
}
newNode.ListChildren(false)
groupNode1 := newNode.AddGroup("group 1")
groupNode1.AddComboBox("demoCombo1", "foo", "bar", "stuff")
groupNode1.AddComboBox("demoCombo3", "foo 3", "bar", "stuff")
groupNode1.Dump()
butNode1 := groupNode1.AddButton("button1", demoClick)
butNode1.Dump()
butNode2 := groupNode1.AddButton("button2", demoClick)
butNode2.Dump()
groupNode2 := newNode.AddGroup("group 2")
groupNode2.AddComboBox("demoCombo2", "more 1", "more 2", "more 3")
}

68
cmds/gui-demo/main.go Normal file
View File

@ -0,0 +1,68 @@
package main
import (
"log"
"os"
"time"
"git.wit.org/wit/gui"
)
// This initializes the first window
//
// Then starts a goroutine to demonstrate how to
// inject things into the GUI
func main() {
log.Println("Starting my Control Panel")
go gui.Main(initGUI)
watchGUI()
}
// This initializes the first window
func initGUI() {
gui.Config.Title = "WIT GUI Window Demo 1"
gui.Config.Width = 640
gui.Config.Height = 480
gui.Config.Exit = myExit
node1 := gui.NewWindow()
addDemoTab(node1, "A Simple Tab Demo")
gui.Config.Title = "WIT GUI Window Demo 2"
gui.Config.Width = 640
gui.Config.Height = 240
gui.Config.Exit = myExit
node2 := gui.NewWindow()
node2.DemoAndlabsUiTab("A Simple andlabs/ui Tab Demo")
}
// This demonstrates how to properly interact with the GUI
// You can not involke the GUI from external goroutines in most cases.
func watchGUI() {
var i = 1
for {
log.Println("Waiting", i, "seconds")
i += 1
time.Sleep(1 * time.Second)
if i == 4 {
log.Println("Opening a Debug Window via the gui.Queue()")
gui.Config.Width = 800
gui.Config.Height = 300
gui.Config.Exit = myDebugExit
gui.Queue(gui.DebugWindow)
}
}
}
func myExit(n *gui.Node) {
log.Println()
log.Println("Entered myExit() on node.Name =", n.Name)
log.Println()
os.Exit(0)
}
func myDebugExit(n *gui.Node) {
log.Println("Entered myDebugExit() on node.Name =", n.Name)
log.Println("Don't actually os.Exit()")
}

6
cmds/gui-example/Makefile Normal file
View File

@ -0,0 +1,6 @@
run: build
./gui-example
build:
GO111MODULE="off" go -v get .
GO111MODULE="off" go build

105
cmds/gui-example/demo-window.go Normal file
View File

@ -0,0 +1,105 @@
package main
import "log"
import "reflect"
import "git.wit.org/wit/gui"
import "github.com/davecgh/go-spew/spew"
func demoClick (n *gui.Node) {
log.Println("demoClick() Dumping node:")
n.Dump()
}
var username = "jcarr"
var hostname = "fire"
func newClick (n *gui.Node) {
var tmp []string
junk := "ssh -v " + username + "@" + hostname
log.Println("junk = " , junk)
xterm(junk)
log.Println("tmp = " , reflect.ValueOf(tmp).Kind())
// spew.Dump(tmp)
}
func addDemoTab(n *gui.Node, title string) {
newNode := n.AddTab(title, nil)
if (gui.Config.Debug) {
newNode.Dump()
}
newNode.ListChildren(false)
groupNode1 := newNode.AddGroup("group 1")
cbNode := groupNode1.AddComboBox("username", "root", "jcarr", "hugo")
cbNode.OnChanged(func () {
username = cbNode.GetText()
})
groupNode1.AddComboBox("demoCombo3", "foo 3", "bar", "stuff")
groupNode1.Dump()
butNode1 := groupNode1.AddButton("button1", demoClick)
butNode1.Dump()
butNode2 := groupNode1.AddButton("button2", newClick)
butNode2.Dump()
groupNode2 := newNode.AddGroup("group 2")
groupNode2.AddComboBox("demoCombo2", "more 1", "more 2", "more 3")
gNode := newNode.AddGroup("domU")
makeSSHbutton(gNode, "hugo@www", "www.wit.org")
makeSSHbutton(gNode, "check.lab", "check.lab.wit.org")
makeSSHbutton(gNode, "gobuild.lab", "gobuild.lab.wit.org")
makeSSHbutton(gNode, "gobuild2.lab", "gobuild2.lab.wit.org")
/////////////////////////////// Column DNS ////////////////////////////////
gNode = newNode.AddGroup("dns")
makeSSHbutton(gNode, "bind.wit.org", "bind.wit.org")
makeSSHbutton(gNode, "ns1.wit.com", "ns1.wit.com")
makeSSHbutton(gNode, "ns2.wit.com", "ns2.wit.com")
makeSSHbutton(gNode, "coredns", "coredns.lab.wit.org")
/////////////////////////////// PHYS 530 //////////////////////////////////
gNode = newNode.AddGroup("phys 530")
// makeXtermButton(gNode, "openwrt", "SUBDOMAIN", "ssh -4 -v root@openwrt")
gNode.AddButton("openwrt", func (*gui.Node) {
stuff := "ssh -4 -v root@openwrt"
xterm(stuff)
})
makeSSHbutton (gNode, "mirrors", "mirrors.wit.org")
makeSSHbutton (gNode, "node004", "node004.lab.wit.org")
makeSSHbutton (gNode, "lenovo-z70", "lenovo-z70.lab.wit.org")
/////////////////////////////// PHYS 522 //////////////////////////////////
gNode = newNode.AddGroup("phys 522")
// makeXtermButton(gNode, "openwrt2", "SUBDOMAIN", "ssh -4 -v root@openwrt2")
gNode.AddButton("openwrt2", func (*gui.Node) {
stuff := "ssh -4 -v root@openwrt2"
xterm(stuff)
})
makeSSHbutton (gNode, "fire.lab", "fire.lab.wit.org")
makeSSHbutton (gNode, "predator", "predator.lab.wit.org")
/////////////////////////////// FLOAT /////////////////////////////////////
gNode = newNode.AddGroup("float")
makeSSHbutton(gNode, "root@asus-n501vw", "asus-n501vw.lab.wit.org")
}
func makeSSHbutton (n *gui.Node, name string, hostname string) {
bNode := n.AddButton(name, func (*gui.Node) {
var tmp []string
if (username == "") {
username = "root"
}
junk := "ssh -v " + username + "@" + hostname
log.Println("junk = " , junk)
log.Println("username = '" + username + "'")
xterm(junk)
log.Println("tmp = " , reflect.ValueOf(tmp).Kind())
spew.Dump(tmp)
})
bNode.Dump()
}

68
cmds/gui-example/main.go Normal file
View File

@ -0,0 +1,68 @@
package main
import (
"log"
"os"
"time"
"git.wit.org/wit/gui"
)
// This initializes the first window
//
// Then starts a goroutine to demonstrate how to
// inject things into the GUI
func main() {
log.Println("Starting my Control Panel")
go gui.Main(initGUI)
watchGUI()
}
// This initializes the first window
func initGUI() {
gui.Config.Title = "WIT GUI Window Demo 1"
gui.Config.Width = 640
gui.Config.Height = 480
gui.Config.Exit = myExit
node1 := gui.NewWindow()
addDemoTab(node1, "A Simple Tab Demo")
gui.Config.Title = "WIT GUI Window Demo 2"
gui.Config.Width = 640
gui.Config.Height = 240
gui.Config.Exit = myExit
node2 := gui.NewWindow()
node2.DemoAndlabsUiTab("A Simple andlabs/ui Tab Demo")
}
// This demonstrates how to properly interact with the GUI
// You can not involke the GUI from external goroutines in most cases.
func watchGUI() {
var i = 1
for {
log.Println("Waiting", i, "seconds")
i += 1
time.Sleep(1 * time.Second)
if i == 4 {
log.Println("Opening a Debug Window via the gui.Queue()")
gui.Config.Width = 800
gui.Config.Height = 300
gui.Config.Exit = myDebugExit
gui.Queue(gui.DebugWindow)
}
}
}
func myExit(n *gui.Node) {
log.Println()
log.Println("Entered myExit() on node.Name =", n.Name)
log.Println()
os.Exit(0)
}
func myDebugExit(n *gui.Node) {
log.Println("Entered myDebugExit() on node.Name =", n.Name)
log.Println("Don't actually os.Exit()")
}

99
cmds/gui-example/os.go Normal file
View File

@ -0,0 +1,99 @@
package main
import "log"
import "strings"
import "os"
import "os/exec"
import "io/ioutil"
import "errors"
// import "bufio"
// import "github.com/davecgh/go-spew/spew"
/*
import "time"
import "runtime"
import "runtime/debug"
import "runtime/pprof"
import "git.wit.org/wit/gui"
import "git.wit.org/wit/shell"
import "github.com/gobuffalo/packr"
*/
func runSimpleCommand(s string) {
cmd := strings.TrimSpace(s) // this is like 'chomp' in perl
cmd = strings.TrimSuffix(cmd, "\n") // this is like 'chomp' in perl
cmdArgs := strings.Fields(cmd)
runLinuxCommand(cmdArgs)
}
var geom string = "120x30+500+500"
func xterm(cmd string) {
var tmp []string
var argsXterm = []string{"nohup", "xterm", "-geometry", geom}
tmp = append(argsXterm, "-hold", "-e", cmd)
log.Println("xterm cmd=", cmd)
go runCommand(tmp)
}
func runCommand(cmdArgs []string) {
log.Println("runCommand() START", cmdArgs)
process := exec.Command(cmdArgs[0], cmdArgs[1:len(cmdArgs)]...)
// process := exec.Command("xterm", "-e", "ping localhost")
log.Println("runCommand() process.Start()")
process.Start()
log.Println("runCommand() process.Wait()")
err := process.Wait()
lookupError(err)
log.Println("runCommand() NEED TO CHECK THE TIME HERE TO SEE IF THIS WORKED")
log.Println("runCommand() OTHERWISE INFORM THE USER")
log.Println("runCommand() END", cmdArgs)
}
func lookupError(err error) {
var (
ee *exec.ExitError
pe *os.PathError
)
if errors.As(err, &ee) {
log.Println("ran, but non-zero exit code =", ee.ExitCode()) // ran, but non-zero exit code
} else if errors.As(err, &pe) {
log.Printf("os.PathError = %v", pe) // "no such file ...", "permission denied" etc.
} else if err != nil {
log.Printf("something really bad happened general err = %v", err) // something really bad happened!
if exitError, ok := err.(*exec.ExitError); ok {
log.Printf("exitError.ExitCode() is %d\n", exitError.ExitCode())
}
} else {
log.Println("success! // ran without error (exit code zero)")
}
}
func runLinuxCommand(cmdArgs []string) (string, error) {
process := exec.Command(cmdArgs[0], cmdArgs[1:len(cmdArgs)]...)
process.Stdin = os.Stdin
process.Stderr = os.Stderr
stdOut, err := process.StdoutPipe()
if err != nil {
return "", err
}
if err := process.Start(); err != nil {
return "", err
}
bytes, err := ioutil.ReadAll(stdOut)
if err != nil {
return "", err
}
err = process.Wait()
lookupError(err)
log.Println(string(bytes))
return string(bytes), err
}

27
cmds/helloworld/main.go Normal file
View File

@ -0,0 +1,27 @@
// This creates a simple hello world window
package main
import (
"git.wit.org/wit/gui"
)
func main() {
gui.Main(initGUI)
}
// This initializes the first window
func initGUI() {
gui.Config.Title = "Hello World golang wit/gui Window"
gui.Config.Width = 640
gui.Config.Height = 480
node1 := gui.NewWindow()
addDemoTab(node1, "A Simple Tab Demo")
addDemoTab(node1, "A Second Tab")
}
func addDemoTab(n *gui.Node, title string) {
newNode := n.AddTab(title, nil)
groupNode1 := newNode.AddGroup("group 1")
groupNode1.AddComboBox("demoCombo2", "more 1", "more 2", "more 3")
}

355
debug-window.go Normal file
View File

@ -0,0 +1,355 @@
package gui
import (
"log"
// "fmt"
"strconv"
"github.com/andlabs/ui"
_ "github.com/andlabs/ui/winmanifest"
"github.com/davecgh/go-spew/spew"
)
var names = make([]string, 100)
var nodeNames = make([]string, 100)
func DebugWindow() {
Config.Title = "DebugWindow()"
node := NewWindow()
node.DebugTab("WIT GUI Debug Tab")
}
// TODO: remove this crap
// What does this actually do?
// It populates the nodeNames in a map. No, not a map, an array.
// What is the difference again? (other than one being in order and a predefined length)
func addNodeName(c *ui.Combobox, s string, id string) {
c.Append(s)
nodeNames[y] = id
y = y + 1
}
func makeWindowDebug() *ui.Box {
hbox := ui.NewHorizontalBox()
hbox.SetPadded(true)
/////////////////////////////////////////////////////
vbox := addGroup(hbox, "range Data.WindowMap")
cbox := ui.NewCombobox()
for name, _ := range Data.WindowMap {
if (Config.Debug) {
log.Println("range Data.WindowMap() name =", name)
}
addName(cbox, name)
}
cbox.SetSelected(0)
vbox.Append(cbox, false)
cbox.OnSelected(func(*ui.Combobox) {
x := cbox.Selected()
log.Println("x =", x)
log.Println("names[x] =", names[x])
dumpBox(names[x])
})
/////////////////////////////////////////////////////
vbox = addGroup(hbox, "Debug Window")
b1 := addButton(vbox, "dumpBox(window)")
b1.OnClicked(func(*ui.Button) {
x := cbox.Selected()
log.Println("x =", x)
log.Println("names[x] =", names[x])
dumpBox(names[x])
})
b2 := addButton(vbox, "SetMargined(tab)")
b2.OnClicked(func(*ui.Button) {
x := cbox.Selected()
log.Println("x =", x)
log.Println("FindWindow; names[x] =", names[x])
gw := FindWindow(names[x])
if gw == nil {
return
}
if gw.UiTab == nil {
return
}
if gw.TabNumber == nil {
return
}
scs := spew.ConfigState{MaxDepth: 1}
scs.Dump(gw)
log.Println("gui.DumpBoxes()\tWindow.UiTab =", gw.UiTab)
log.Println("gui.DumpBoxes()\tWindow.TabNumber =", *gw.TabNumber)
gw.UiTab.SetMargined(*gw.TabNumber, true)
})
b3 := addButton(vbox, "Hide(tab)")
b3.OnClicked(func(*ui.Button) {
x := cbox.Selected()
log.Println("x =", x)
log.Println("FindWindow; names[x] =", names[x])
gw := FindWindow(names[x])
if gw == nil {
return
}
if gw.UiTab == nil {
return
}
gw.UiTab.Hide()
})
b4 := addButton(vbox, "Show(tab)")
b4.OnClicked(func(*ui.Button) {
x := cbox.Selected()
log.Println("x =", x)
log.Println("FindWindow; names[x] =", names[x])
gw := FindWindow(names[x])
if gw == nil {
return
}
if gw.UiTab == nil {
return
}
gw.UiTab.Show()
})
b5 := addButton(vbox, "Delete(tab)")
b5.OnClicked(func(*ui.Button) {
x := cbox.Selected()
log.Println("x =", x)
log.Println("FindWindow; names[x] =", names[x])
gw := FindWindow(names[x])
if gw == nil {
return
}
if gw.UiTab == nil {
return
}
if gw.TabNumber == nil {
return
}
gw.UiTab.Delete(*gw.TabNumber)
})
/////////////////////////////////////////////////////
vbox = addGroup(hbox, "Global Debug")
dump3 := addButton(vbox, "Dump Windows")
dump3.OnClicked(func(*ui.Button) {
DumpWindows()
})
dump2 := addButton(vbox, "Dump Boxes")
dump2.OnClicked(func(*ui.Button) {
DumpBoxes()
})
dump1 := addButton(vbox, "Dump MAP")
dump1.OnClicked(func(*ui.Button) {
DumpMap()
})
/////////////////////////////////////////////////////
nodeBox := addGroup(hbox, "Windows:")
nodeCombo := ui.NewCombobox()
for name, node := range Data.NodeMap {
if (Config.Debug) {
log.Println("range Data.NodeMap() name =", name)
}
tmp := node.id + " (" + name + ")"
addNodeName(nodeCombo, tmp, node.id)
}
nodeCombo.SetSelected(0)
nodeBox.Append(nodeCombo, false)
nodeCombo.OnSelected(func(*ui.Combobox) {
y := nodeCombo.Selected()
log.Println("y =", y)
log.Println("nodeNames[y] =", nodeNames[y])
node := Data.findId(nodeNames[y])
if (node != nil) {
node.Dump()
}
})
/////////////////////////////////////////////////////
vbox = addGroup(hbox, "Node Debug")
n1 := addButton(vbox, "Data.DumpNodeMap()")
n1.OnClicked(func(*ui.Button) {
Data.DumpNodeMap()
})
n1 = addButton(vbox, "Data.ListChildren(false)")
n1.OnClicked(func(*ui.Button) {
Data.ListChildren(false)
})
n1 = addButton(vbox, "Data.ListChildren(true)")
n1.OnClicked(func(*ui.Button) {
Data.ListChildren(true)
})
n1 = addButton(vbox, "Node.Dump()")
n1.OnClicked(func(*ui.Button) {
y := nodeCombo.Selected()
log.Println("y =", y)
log.Println("nodeNames[y] =", nodeNames[y])
node := Data.findId(nodeNames[y])
if (node != nil) {
node.Dump()
}
})
n1 = addButton(vbox, "Node.ListChildren(false)")
n1.OnClicked(func(*ui.Button) {
y := nodeCombo.Selected()
log.Println("y =", y)
log.Println("nodeNames[y] =", nodeNames[y])
node := Data.findId(nodeNames[y])
if (node != nil) {
node.ListChildren(false)
}
})
n1 = addButton(vbox, "Node.ListChildren(true)")
n1.OnClicked(func(*ui.Button) {
y := nodeCombo.Selected()
log.Println("y =", y)
log.Println("nodeNames[y] =", nodeNames[y])
node := Data.findId(nodeNames[y])
if (node != nil) {
node.ListChildren(true)
}
})
n1 = addButton(vbox, "Node.AddDebugTab")
n1.OnClicked(func(*ui.Button) {
y := nodeCombo.Selected()
log.Println("y =", y)
log.Println("nodeNames[y] =", nodeNames[y])
node := Data.findId(nodeNames[y])
if (node != nil) {
node.DebugTab("added this DebugTab")
}
})
n1 = addButton(vbox, "Node.DemoAndlabsUiTab")
n1.OnClicked(func(*ui.Button) {
y := nodeCombo.Selected()
log.Println("y =", y)
log.Println("nodeNames[y] =", nodeNames[y])
node := Data.findId(nodeNames[y])
if (node != nil) {
node.DemoAndlabsUiTab("ran gui.AddDemoAndlabsUiTab() " + strconv.Itoa(Config.counter))
}
})
return hbox
}
// TODO: remove this crap
var x int = 0
var y int = 0
// TODO: remove this crap
func addName(c *ui.Combobox, s string) {
c.Append(s)
names[x] = s
x = x + 1
}
func addGroup(b *ui.Box, name string) *ui.Box {
group := ui.NewGroup(name)
group.SetMargined(true)
b.Append(group, true)
vbox := ui.NewVerticalBox()
vbox.SetPadded(true)
group.SetChild(vbox)
return vbox
}
func dumpBox(s string) {
var name string
var window *GuiWindow
for name, window = range Data.WindowMap {
if name != s {
continue
}
log.Println("gui.DumpBoxes() MAP: ", name)
if window.TabNumber == nil {
log.Println("gui.DumpBoxes() \tWindows.TabNumber = nil")
} else {
log.Println("gui.DumpBoxes() \tWindows.TabNumber =", *window.TabNumber)
}
log.Println("gui.DumpBoxes()\tWindow.name =", window.Name)
// log.Println("gui.DumpBoxes()\tWindow.UiWindow type =", reflect.TypeOf(window.UiWindow))
log.Println("gui.DumpBoxes()\tWindow.UiWindow =", window.UiWindow)
log.Println("gui.DumpBoxes()\tWindow.UiTab =", window.UiTab)
log.Println("gui.dumpBox() BoxMap START")
for name, abox := range window.BoxMap {
log.Printf("gui.DumpBoxes() \tBOX mapname=%-12s abox.Name=%-12s", name, abox.Name)
abox.Dump()
if name == "MAINBOX" {
if Config.Debug {
scs := spew.ConfigState{MaxDepth: 1}
scs.Dump(abox.UiBox)
}
}
}
log.Println("gui.dumpBox() BoxMap END")
if window.UiTab != nil {
pages := window.UiTab.NumPages()
log.Println("gui.DumpBoxes()\tWindow.UiTab.NumPages() =", pages)
tabSetMargined(window.UiTab)
if Config.Debug {
scs := spew.ConfigState{MaxDepth: 2}
scs.Dump(window.UiTab)
}
}
}
}
func addButton(box *ui.Box, name string) *ui.Button {
button := ui.NewButton(name)
button.OnClicked(func(*ui.Button) {
log.Println("Should do something here")
})
box.Append(button, false)
return button
}
func (n *Node) DebugTab(title string) {
newNode := n.AddTab(title, makeWindowDebug())
if (Config.DebugNode) {
newNode.Dump()
}
tabSetMargined(newNode.uiTab)
}
// This sets _all_ the tabs to Margin = true
//
// TODO: do proper tab tracking (will be complicated). low priority
func tabSetMargined(tab *ui.Tab) {
if (Config.DebugTabs) {
log.Println("tabSetMargined() IGNORE THIS")
}
c := tab.NumPages()
for i := 0; i < c; i++ {
if (Config.DebugTabs) {
log.Println("tabSetMargined() i =", i)
}
tab.SetMargined(i, true)
}
}

115
debug.go
View File

@ -1,26 +1,27 @@
package gui
import "log"
import "time"
import "fmt"
// import "reflect"
import (
"fmt"
"log"
"time"
// import "github.com/andlabs/ui"
// import _ "github.com/andlabs/ui/winmanifest"
import "github.com/davecgh/go-spew/spew"
// import pb "git.wit.com/wit/witProtobuf"
"github.com/davecgh/go-spew/spew"
)
// WatchGUI() opens a goroutine
//
// this watches the GUI primarily to process protobuf's
// this is pointless or wrong but I use it for debugging
//
// From that goroutine, it dumps out debugging information every 4 seconds
/*
TODO: add configuration triggers on what to dump out
TODO: allow this to be sent to /var/log, syslogd, systemd's journalctl, etc
*/
func WatchGUI() {
count := 0
for {
if (count > 20) {
if count > 20 {
log.Println("Sleep() in watchGUI()")
if (Config.Debug) {
if Config.Debug {
DumpBoxes()
}
count = 0
@ -30,10 +31,26 @@ func WatchGUI() {
}
}
func DumpWindows() {
for name, _ := range Data.WindowMap {
log.Println("gui.DumpWindows() window =", name)
}
}
func DumpMap() {
for name, window := range Data.WindowMap {
log.Println("gui.DumpBoxes() MAP: ", name)
log.Println("gui.DumpBoxes() BOXES:", name)
for name, abox := range window.BoxMap {
log.Printf("gui.DumpBoxes() \tBOX mapname=%-12s abox.Name=%-12s", name, abox.Name)
}
}
}
func DumpBoxes() {
for name, window := range Data.WindowMap {
log.Println("gui.DumpBoxes() MAP: ", name)
if (window.TabNumber == nil) {
if window.TabNumber == nil {
log.Println("gui.DumpBoxes() \tWindows.TabNumber = nil")
} else {
log.Println("gui.DumpBoxes() \tWindows.TabNumber =", *window.TabNumber)
@ -41,16 +58,17 @@ func DumpBoxes() {
log.Println("gui.DumpBoxes()\tWindow.name =", window.Name)
// log.Println("gui.DumpBoxes()\tWindow.UiWindow type =", reflect.TypeOf(window.UiWindow))
log.Println("gui.DumpBoxes()\tWindow.UiWindow =", window.UiWindow)
log.Println("gui.DumpBoxes()\tWindow.UiTab =", window.UiTab)
for name, abox := range window.BoxMap {
log.Printf("gui.DumpBoxes() \tBOX mapname=%-12s abox.Name=%-12s", name, abox.Name)
if (name == "MAINBOX") {
if (Config.Debug) {
if name == "MAINBOX" {
if Config.Debug {
scs := spew.ConfigState{MaxDepth: 1}
scs.Dump(abox.UiBox)
}
}
}
if (window.UiTab != nil) {
if window.UiTab != nil {
// log.Println("gui.DumpBoxes()\tWindow.UiTab type =", reflect.TypeOf(window.UiTab))
// log.Println("gui.DumpBoxes()\tWindow.UiTab =", window.UiTab)
pages := window.UiTab.NumPages()
@ -61,20 +79,20 @@ func DumpBoxes() {
// tmp := spew.NewDefaultConfig()
// tmp.MaxDepth = 2
// tmp.Dump(window.UiTab)
if (Config.Debug) {
if Config.Debug {
scs := spew.ConfigState{MaxDepth: 2}
scs.Dump(window.UiTab)
}
}
}
/*
for i, window := range Data.Windows {
if (window.TabNumber == nil) {
log.Println("gui.DumpBoxes() Data.Windows", i, "Name =", window.Name, "TabNumber = nil")
} else {
log.Println("gui.DumpBoxes() Data.Windows", i, "Name =", window.Name, "TabNumber =", *window.TabNumber)
for i, window := range Data.Windows {
if (window.TabNumber == nil) {
log.Println("gui.DumpBoxes() Data.Windows", i, "Name =", window.Name, "TabNumber = nil")
} else {
log.Println("gui.DumpBoxes() Data.Windows", i, "Name =", window.Name, "TabNumber =", *window.TabNumber)
}
}
}
*/
}
@ -86,10 +104,57 @@ func addTableTab() {
var b TableColumnData
b.CellType = foo
b.Heading = fmt.Sprintf("heading%d", key)
b.Heading = fmt.Sprintf("heading%d", key)
parts = append(parts, b)
}
log.Println("Sleep for 1 second, then try to add new tabs")
time.Sleep(1 * time.Second)
}
func (dn *GuiData) DumpNodeMap() {
log.Println("DebugDataNodeMap():")
for name, node := range dn.NodeMap {
log.Println("\tNode =", node.id, node.Width, node.Height, name)
if (node.children == nil) {
log.Println("\t\tNo children")
} else {
log.Println("\t\tHas children:", node.children)
}
// node.SetName("yahoo")
// log.Println("\tData.NodeMap node =", node)
}
}
/*
func DebugDataNodeChildren() {
if Data.NodeMap == nil {
log.Println("DebugDataNodeChildren() NodeMap == nil")
return
}
log.Println("DebugDataNodeChildren():")
for name, node := range Data.NodeMap {
log.Println("\tNode name =", node.Width, node.Height, name)
if (node.children == nil) {
log.Println("\t\tNo children")
break
}
log.Println("\t\tHas children:", node.children)
}
}
*/
func (dn *GuiData) ListChildren(dump bool) {
if Data.NodeMap == nil {
log.Println("gui.Data.ListChildren() Data.NodeMap == nil")
return
}
log.Println("gui.Data.ListChildren() Data.NodeMap:")
for name, node := range Data.NodeMap {
log.Println("\tgui.Data.ListChildren() node =", node.id, node.Width, node.Height, name)
if (dump == true) {
node.Dump()
}
node.ListChildren(dump)
}
}

84
demo-window-andlabs-ui.go Normal file
View File

@ -0,0 +1,84 @@
package gui
import "log"
import "github.com/andlabs/ui"
import _ "github.com/andlabs/ui/winmanifest"
// This will create a tab in a window using direct
// calls to andlabs/ui. This can be used to bypass
// the obvuscation added in this package if it is desired
// or needed.
func (n *Node) DemoAndlabsUiTab(title string) {
newNode := n.AddTab(title, makeAndlabsUiTab())
if (Config.DebugNode) {
newNode.Dump()
}
tabSetMargined(newNode.uiTab)
}
func makeAndlabsUiTab() *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(47, 100)
slider := ui.NewSlider(21, 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)
ecbox.OnChanged(func(*ui.EditableCombobox) {
log.Println("test")
test := ecbox.Text()
log.Println("test=", test)
})
rb := ui.NewRadioButtons()
rb.Append("Radio Button 1")
rb.Append("Radio Button 2")
rb.Append("Radio Button 3")
vbox.Append(rb, false)
return hbox
}

28
demo-window.go Normal file
View File

@ -0,0 +1,28 @@
package gui
// import "log"
import "github.com/andlabs/ui"
import _ "github.com/andlabs/ui/winmanifest"
var mybox *ui.Box
func (n *Node) AddGroup(title string) *Node {
if (n == nil) {
return nil
}
hbox := n.uiBox
if (hbox == nil) {
return n
}
group := ui.NewGroup(title)
group.SetMargined(true)
hbox.Append(group, true)
vbox := ui.NewVerticalBox()
vbox.SetPadded(true)
group.SetChild(vbox)
newNode := n.AddNode(title)
newNode.uiBox = vbox
return newNode
}

81
doc.go Normal file
View File

@ -0,0 +1,81 @@
/*
Package gui implements a abstraction layer for Go visual elements in
a cross platform way.
A quick overview of the features, some general design guidelines
and principles for how this package should generally work:
* GUI elements are stored in a tree of nodes
* When in doubt, it's ok to guess. We will return something close.
* It tries to make your code simple
Quick Start
This section demonstrates how to quickly get started with spew. See the
sections below for further details on formatting and configuration options.
// This creates a simple hello world window
package main
import (
"git.wit.org/wit/gui"
)
func main() {
gui.Main(initGUI)
}
// This initializes the first window
func initGUI() {
gui.Config.Title = "Hello World golang wit/gui Window"
gui.Config.Width = 640
gui.Config.Height = 480
node1 := gui.NewWindow()
addDemoTab(node1, "A Simple Tab Demo")
addDemoTab(node1, "A Second Tab")
}
func addDemoTab(n *gui.Node, title string) {
newNode := n.AddTab(title, nil)
groupNode1 := newNode.AddGroup("group 1")
groupNode1.AddComboBox("demoCombo2", "more 1", "more 2", "more 3")
}
Configuration Options
Configuration of the GUI is handled by fields in the ConfigType type. For
convenience, all of the top-level functions use a global state available
via the gui.Config global.
The following configuration options are available:
* Width
When creating a new window, this is the width
* Height
When creating a new window, this is the height
* Debug
When 'true' log more output
Toolkit Usage
Right now, this abstraction is built on top of the go package 'andlabs/ui'
which does the cross platform support.
The next step is to intent is to allow this to work directly against GTK and QT.
It should be able to add Fyne, WASM, native macos & windows, android, etc.
Errors
Since it is possible for custom Stringer/error interfaces to panic, spew
detects them and handles them internally by printing the panic information
inline with the output. Since spew is intended to provide deep pretty printing
capabilities on structures, it intentionally does not return any errors.
Debugging
To dump variables with full newlines, indentation, type, and pointer
information this uses spew.Dump()
*/
package gui

42
entry.go
View File

@ -10,29 +10,49 @@ import "github.com/davecgh/go-spew/spew"
// functions for handling text entry boxes
func NewLabel(box *GuiBox, text string) {
box.UiBox.Append(ui.NewLabel(text), false)
box.Append(ui.NewLabel(text), false)
}
func GetText(box *GuiBox, name string) string {
if (box == nil) {
log.Println("gui.GetText() ERROR box == nil")
return ""
}
if (box.Window.EntryMap == nil) {
func (n *Node) NewLabel(text string) *Node {
// make new node here
// n.Append(ui.NewLabel(text), false)
newNode := makeNode(n, text, 333, 334)
newNode.Dump()
// panic("node.NewLabel()")
n.Append(newNode)
return newNode
}
func (b *GuiBox) GetText(name string) string {
if (b.Window.EntryMap == nil) {
log.Println("gui.GetText() ERROR b.Box.Window.EntryMap == nil")
return ""
}
spew.Dump(box.Window.EntryMap)
if (box.Window.EntryMap[name] == nil) {
spew.Dump(b.Window.EntryMap)
if (b.Window.EntryMap[name] == nil) {
log.Println("gui.GetText() ERROR box.Window.EntryMap[", name, "] == nil ")
return ""
}
e := box.Window.EntryMap[name]
e := b.Window.EntryMap[name]
log.Println("gui.GetText() box.Window.EntryMap[", name, "] = ", e.UiEntry.Text())
log.Println("gui.GetText() END")
return e.UiEntry.Text()
}
func (n *Node) SetText(value string) error {
log.Println("gui.SetText() value =", value)
if (n.uiText != nil) {
n.uiText.SetText(value)
return nil
}
if (n.uiButton != nil) {
n.uiButton.SetText(value)
return nil
}
return nil
}
func SetText(box *GuiBox, name string, value string) error {
if (box == nil) {
return fmt.Errorf("gui.SetText() ERROR box == nil")
@ -42,7 +62,7 @@ func SetText(box *GuiBox, name string, value string) error {
}
spew.Dump(box.Window.EntryMap)
if (box.Window.EntryMap[name] == nil) {
return fmt.Errorf("gui.SetText() ERROR box.Window.EntryMap[", name, "] == nil ")
return fmt.Errorf("gui.SetText() ERROR box.Window.EntryMap[" + name + "] == nil ")
}
e := box.Window.EntryMap[name]
log.Println("gui.SetText() box.Window.EntryMap[", name, "] = ", e.UiEntry.Text())

45
example_test.go Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package gui_test
import (
"git.wit.org/wit/gui"
)
// This example demonstrates how to create a NewWindow()
//
// Interacting with a GUI in a cross platform fashion adds some
// unusual problems. To obvuscate those, andlabs/ui starts a
// goroutine that interacts with the native gui toolkits
// on the Linux, MacOS, Windows, etc.
//
// Because of this oddity, to initialize a new window, the
// function is not passed any arguements and instead passes
// the information via the Config type.
//
func ExampleNewWindow() {
// Define the name and size
gui.Config.Title = "WIT GUI Window 1"
gui.Config.Width = 640
gui.Config.Height = 480
// Create the Window
gui.NewWindow()
// Output:
// You get a window
}

156
find.go Normal file
View File

@ -0,0 +1,156 @@
package gui
import (
"log"
"os"
"github.com/andlabs/ui"
_ "github.com/andlabs/ui/winmanifest"
// "github.com/davecgh/go-spew/spew"
)
func (n *Node) FindTab() *ui.Tab {
return n.uiTab
}
func (n *Node) FindControl() *ui.Control {
return n.uiControl
}
func (n *Node) FindBox() *GuiBox {
if (n.box != nil) {
return n.box
}
if (n.parent != nil) {
p := n.parent
return p.box
}
return n.box
}
func (n *Node) FindWindowBox() *GuiBox {
if (n.box == nil) {
panic("SERIOUS ERROR n.box == nil in FindWindowBox()")
}
return n.box
}
func (w *GuiWindow) FindNode() *Node {
return w.node
}
func (b *GuiBox) FindNode() *Node {
log.Println("gui.FindNode() on GuiBox")
if b.node != nil {
return b.node
}
Data.ListChildren(true)
b.Dump()
log.Println("gui.FindNode() on GuiBox is nil")
os.Exit(-1)
return nil
}
func FindWindow(s string) *GuiWindow {
for name, window := range Data.WindowMap {
if name == s {
return window
}
}
log.Printf("COULD NOT FIND WINDOW " + s)
return nil
}
func FindBox(s string) *GuiBox {
for name, window := range Data.WindowMap {
if name != s {
continue
}
for name, abox := range window.BoxMap {
log.Printf("gui.DumpBoxes() \tBOX mapname=%-12s abox.Name=%-12s", name, abox.Name)
return abox
}
log.Println("gui.FindBox() NEED TO INIT WINDOW name =", name)
}
log.Println("gui.FindBox() COULD NOT FIND BOX", s)
return nil
}
func FindNode(name string) *Node {
if Data.NodeMap == nil {
log.Println("gui.FindNode() gui.Data.NodeMap == nil")
return nil
}
log.Println("gui.FindNode() searching Data.NodeMap:")
for id, node := range Data.NodeMap {
log.Println("\tData.NodeMap name =", node.Width, node.Height, id)
node.Dump()
if (name == node.Name) {
return node
}
newNode := findByName(node, name)
if (newNode != nil) {
return newNode
}
log.Println("gui.FindNode() could not find node name =", name)
os.Exit(-1)
}
log.Println("gui.FindNode() could not find node name =", name)
return nil
}
func (dn *GuiData) findId(id string) *Node {
if Data.NodeMap == nil {
log.Println("gui.Data.findId() map == nil")
return nil
}
// log.Println("Dumping Data.NodeMap:")
for name, node := range Data.NodeMap {
// log.Println("\tData.NodeMap name =", node.id, node.Width, node.Height, name)
if (id == node.id) {
log.Println("\tgui.Data.findId() found node =", node.id, node.Width, node.Height, name)
return node
}
// TODO: fix // Oct 9
// node.findId(id)
}
return nil
}
func findByIdDFS(node *Node, id string) *Node {
log.Println("findByIdDFS()", id, node)
node.Dump()
if node.id == id {
log.Println("Found node id =", id, node)
return node
}
if len(node.children) > 0 {
for _, child := range node.children {
newNode := findByIdDFS(child, id)
if (newNode != nil) {
return newNode
}
}
}
return nil
}
func findByName(node *Node, name string) *Node {
log.Println("findByName()", name, node)
node.Dump()
if node.Name == name {
log.Println("findByName() Found node name =", name, node)
return node
}
if len(node.children) > 0 {
for _, child := range node.children {
newNode := findByName(child, name)
if (newNode != nil) {
return newNode
}
}
}
return nil
}

9
go.mod Normal file
View File

@ -0,0 +1,9 @@
module git.wit.org/wit/gui
go 1.17
require (
github.com/andlabs/ui v0.0.0-20200610043537-70a69d6ae31e
github.com/davecgh/go-spew v1.1.1
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d
)

8
go.sum Normal file
View File

@ -0,0 +1,8 @@
github.com/andlabs/ui v0.0.0-20200610043537-70a69d6ae31e h1:wSQCJiig/QkoUnpvelSPbLiZNWvh2yMqQTQvIQqSUkU=
github.com/andlabs/ui v0.0.0-20200610043537-70a69d6ae31e/go.mod h1:5G2EjwzgZUPnnReoKvPWVneT8APYbyKkihDVAHUi0II=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d h1:RNPAfi2nHY7C2srAV8A49jpsYr0ADedCk1wq6fTMTvs=
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

27
gui.go
View File

@ -1,11 +1,14 @@
package gui
import "log"
// import "time"
import "regexp"
import (
"github.com/andlabs/ui" // import "time"
"log"
"regexp"
import "github.com/andlabs/ui"
import _ "github.com/andlabs/ui/winmanifest" // the _ means we only need this for the init()
_ "github.com/andlabs/ui/winmanifest"
)
// the _ means we only need this for the init()
const Xaxis = 0 // box that is horizontal
const Yaxis = 1 // box that is vertical
@ -13,13 +16,21 @@ const Yaxis = 1 // box that is vertical
func init() {
log.Println("gui.init() has been run")
Data.buttonMap = make(map[*ui.Button]*GuiButton)
Data.WindowMap = make(map[string]*GuiWindow)
Data.buttonMap = make(map[*ui.Button]*GuiButton)
Data.WindowMap = make(map[string]*GuiWindow)
Data.NodeMap = make(map[string]*Node)
Data.NodeSlice = make([]*Node, 0)
Config.counter = 0
Config.prefix = "wit"
Config.DebugNode = false
Config.DebugTabs = false
}
func GuiInit() {
ui.OnShouldQuit(func() bool {
ui.Quit()
ui.Quit()
return true
})
}

34
main.go Normal file
View File

@ -0,0 +1,34 @@
package gui
import (
"log"
"github.com/andlabs/ui"
_ "github.com/andlabs/ui/winmanifest"
)
func Main(f func()) {
log.Println("Starting gui.Main() (using gtk via andlabs/ui)")
ui.Main(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: gui.Queue(addNewTabForColorSelection())
func Queue(f func()) {
log.Println("Sending function to gui.Main() (using gtk via andlabs/ui)")
ui.QueueMain(f)
}
/*
func ExampleWindow() {
log.Println("START gui.ExampleWindow()")
Config.Title = "ExampleWindow"
node := NewWindow()
node.AddDebugTab("jcarr Debug")
}
*/

271
new-structs.go Normal file
View File

@ -0,0 +1,271 @@
package gui
import (
"log"
"fmt"
// "reflect"
// "github.com/davecgh/go-spew/spew"
"github.com/andlabs/ui"
_ "github.com/andlabs/ui/winmanifest"
)
type Element int
// https://ieftimov.com/post/golang-datastructures-trees/
const (
Unknown Element = iota
Window
Tab
Box
Label
Combo
)
func (s Element) String() string {
switch s {
case Window:
return "window"
case Tab:
return "tab"
case Box:
return "box"
case Label:
return "label"
case Combo:
return "combo"
}
return "unknown"
}
type Node struct {
id string
Name string
Width int
Height int
parent *Node
children []*Node
window *GuiWindow
box *GuiBox
custom func(*Node)
uiControl *ui.Control
uiButton *ui.Button
uiWindow *ui.Window
uiTab *ui.Tab
uiBox *ui.Box
uiText *ui.EditableCombobox
}
func (n *Node) Parent() *Node {
return n.parent
}
func (n *Node) Window() *Node {
return n.parent
}
func (n *Node) Dump() {
log.Println("gui.Node.Dump() id = ", n.id)
log.Println("gui.Node.Dump() Name = ", n.Name)
log.Println("gui.Node.Dump() Width = ", n.Width)
log.Println("gui.Node.Dump() Height = ", n.Height)
if (n.parent == nil) {
log.Println("gui.Node.Dump() parent = nil")
} else {
log.Println("gui.Node.Dump() parent = ", n.parent.id)
}
log.Println("gui.Node.Dump() children = ", n.children)
log.Println("gui.Node.Dump() window = ", n.window)
log.Println("gui.Node.Dump() box = ", n.box)
log.Println("gui.Node.Dump() uiWindow = ", n.uiWindow)
log.Println("gui.Node.Dump() uiTab = ", n.uiTab)
log.Println("gui.Node.Dump() uiBox = ", n.uiBox)
log.Println("gui.Node.Dump() uiControl = ", n.uiControl)
log.Println("gui.Node.Dump() uiButton = ", n.uiButton)
if (n.id == "") {
panic("gui.Node.Dump() id == nil")
}
}
func (n *Node) SetBox(box *GuiBox) {
n.box = box
}
func (n *Node) SetName(name string) {
// n.uiType.SetName(name)
if (n.uiWindow != nil) {
log.Println("node is a window. setting title =", name)
n.uiWindow.SetTitle(name)
return
}
log.Println("*ui.Control =", n.uiControl)
return
}
func (n *Node) Append(child *Node) {
// if (n.UiBox == nil) {
// return
// }
n.children = append(n.children, child)
if (Config.Debug) {
log.Println("child node:")
child.Dump()
log.Println("parent node:")
n.Dump()
}
// time.Sleep(3 * time.Second)
}
func (n *Node) List() {
findByIdDFS(n, "test")
}
var listChildrenParent *Node
var listChildrenDepth int = 0
func indentPrintln(depth int, format string, a ...interface{}) {
var tabs string
for i := 0; i < depth; i++ {
tabs = tabs + "\t"
}
// newFormat := tabs + strconv.Itoa(depth) + " " + format
newFormat := tabs + format
log.Println(newFormat, a)
}
func (n *Node) ListChildren(dump bool) {
indentPrintln(listChildrenDepth, "\t", n.id, n.Width, n.Height, n.Name)
if (dump == true) {
n.Dump()
}
if len(n.children) == 0 {
if (n.parent == nil) {
} else {
if (Config.DebugNode) {
log.Println("\t\t\tparent =",n.parent.id)
}
if (listChildrenParent != nil) {
if (Config.DebugNode) {
log.Println("\t\t\tlistChildrenParent =",listChildrenParent.id)
}
if (listChildrenParent.id != n.parent.id) {
log.Println("parent.child does not match child.parent")
panic("parent.child does not match child.parent")
}
}
}
if (Config.DebugNode) {
log.Println("\t\t", n.id, "has no children")
}
return
}
for _, child := range n.children {
// log.Println("\t\t", child.id, child.Width, child.Height, child.Name)
if (child.parent != nil) {
if (Config.DebugNode) {
log.Println("\t\t\tparent =",child.parent.id)
}
} else {
log.Println("\t\t\tno parent")
panic("no parent")
}
if (dump == true) {
child.Dump()
}
if (Config.DebugNode) {
if (child.children == nil) {
log.Println("\t\t", child.id, "has no children")
} else {
log.Println("\t\t\tHas children:", child.children)
}
}
listChildrenParent = n
listChildrenDepth += 1
child.ListChildren(dump)
listChildrenDepth -= 1
}
return
}
// The parent Node needs to be the raw Window
// The 'stuff' Node needs to be the contents of the tab
//
// This function should make a new node with the parent and
// the 'stuff' Node as a child
func (n *Node) AddTabNode(title string, b *GuiBox) *Node {
var newNode *Node
parent := n
newNode = parent.makeNode(title, 444, 400 + Config.counter)
newNode.uiTab = parent.uiTab
newNode.box = b
if (Config.DebugNode) {
fmt.Println("")
log.Println("parent:")
parent.Dump()
fmt.Println("")
log.Println("newNode:")
newNode.Dump()
}
if (newNode.uiTab == nil) {
log.Println("wit/gui/ AddTabNode() Something went wrong tab == nil")
// TODO: try to find the tab or window and make them if need be
return newNode
}
newNode.uiTab.Append(title, b.UiBox)
return newNode
}
func (n *Node) AddTab(title string, uiC *ui.Box) *Node {
parent := n
log.Println("gui.Node.AddTab() START name =", title)
if parent.uiWindow == nil {
parent.Dump()
log.Println("gui.Node.AddTab() ERROR ui.Window == nil")
return nil
}
if parent.box == nil {
parent.Dump()
panic("gui.AddTab() ERROR box == nil")
}
if parent.uiTab == nil {
inittab := ui.NewTab() // no, not that 'inittab'
parent.uiWindow.SetChild(inittab)
parent.uiWindow.SetMargined(true)
parent.uiTab = inittab
// parent.Dump()
// panic("gui.AddTab() ERROR uiTab == nil")
}
tab := parent.uiTab
parent.uiWindow.SetMargined(true)
if (uiC == nil) {
hbox := ui.NewHorizontalBox()
hbox.SetPadded(true)
uiC = hbox
}
tab.Append(title, uiC)
newNode := parent.makeNode(title, 555, 600 + Config.counter)
newNode.uiTab = tab
newNode.uiBox = uiC
// panic("gui.AddTab() after makeNode()")
tabSetMargined(newNode.uiTab)
return newNode
}

266
structs.go
View File

@ -1,37 +1,53 @@
package gui
import "image/color"
import "golang.org/x/image/font"
import (
"image/color"
"log"
import "github.com/andlabs/ui"
import _ "github.com/andlabs/ui/winmanifest"
"github.com/andlabs/ui"
"golang.org/x/image/font"
_ "github.com/andlabs/ui/winmanifest"
)
//
// All GUI Data Structures and functions that are external
// If you need cross platform support, these might only
// be the safe way to interact with the GUI
//
var Data GuiData
var Config GuiConfig
var Data GuiData
var Config GuiConfig
type GuiConfig struct {
Width int
Height int
Debug bool
DebugTable bool
Exit func(*GuiWindow)
Title string
Width int
Height int
Exit func(*Node)
Debug bool
DebugNode bool
DebugTabs bool
DebugTable bool
DebugWindow bool
depth int
counter int // used to make unique ID's
prefix string
}
type GuiData struct {
// a fallback default function to handle mouse events
// a fallback default function to handle mouse events
// if nothing else is defined to handle them
MouseClick func(*GuiButton)
MouseClick func(*GuiButton)
// A map of all the entry boxes
AllEntries []*GuiEntry
WindowMap map[string]*GuiWindow
AllEntries []*GuiEntry
WindowMap map[string]*GuiWindow
// Windows []*GuiWindow
// Store access to everything via binary tree's
NodeMap map[string]*Node
NodeArray []*Node
NodeSlice []*Node
// A map of all buttons everywhere on all
// windows, all tabs, across all goroutines
@ -39,8 +55,14 @@ type GuiData struct {
//
// This has to work this way because of how
// andlabs/ui & andlabs/libui work
AllButtons []*GuiButton
buttonMap map[*ui.Button]*GuiButton
AllButtons []*GuiButton
buttonMap map[*ui.Button]*GuiButton
}
type GuiTab struct {
Name string // field for human readable name
Number int // the andlabs/ui tab index
Window *GuiWindow // the parent Window
}
//
@ -62,34 +84,97 @@ type GuiData struct {
// can destroy and replace it with something else
//
type GuiWindow struct {
Name string // field for human readable name
Width int
Height int
Axis int // does it add items to the X or Y axis
TabNumber *int // the andlabs/ui tab index
Name string // field for human readable name
Width int
Height int
Axis int // does it add items to the X or Y axis
TabNumber *int // the andlabs/ui tab index
// the callback function to make the window contents
// MakeWindow func(*GuiBox) *GuiBox
// the components of the window
BoxMap map[string]*GuiBox
EntryMap map[string]*GuiEntry
Area *GuiArea
BoxMap map[string]*GuiBox
EntryMap map[string]*GuiEntry
Area *GuiArea
node *Node
// andlabs/ui abstraction mapping
UiWindow *ui.Window
UiTab *ui.Tab // if this != nil, the window is 'tabbed'
UiWindow *ui.Window
UiTab *ui.Tab // if this != nil, the window is 'tabbed'
}
func (w *GuiWindow) Dump() {
log.Println("gui.GuiWindow.Dump() Name = ", w.Name)
log.Println("gui.GuiWindow.Dump() node = ", w.node)
log.Println("gui.GuiWindow.Dump() Width = ", w.Width)
log.Println("gui.GuiWindow.Dump() Height = ", w.Height)
}
// GuiBox is any type of ui.Hbox or ui.Vbox
// There can be lots of these for each GuiWindow
type GuiBox struct {
Name string // field for human readable name
Axis int // does it add items to the X or Y axis
Window *GuiWindow // the parent Window
Name string // field for human readable name
Axis int // does it add items to the X or Y axis
Window *GuiWindow // the parent Window
node *Node
// andlabs/ui abstraction mapping
UiBox *ui.Box
UiBox *ui.Box
}
func (b *GuiBox) Dump() {
log.Println("gui.GuiBox.Dump() Name = ", b.Name)
log.Println("gui.GuiBox.Dump() Axis = ", b.Axis)
log.Println("gui.GuiBox.Dump() GuiWindow = ", b.Window)
log.Println("gui.GuiBox.Dump() node = ", b.node)
log.Println("gui.GuiBox.Dump() UiBox = ", b.UiBox)
}
func (b *GuiBox) SetTitle(title string) {
log.Println("DID IT!", title)
if b.Window == nil {
return
}
if b.Window.UiWindow == nil {
return
}
b.Window.UiWindow.SetTitle(title)
return
}
func (w *GuiWindow) SetNode(n *Node) {
if (w.node != nil) {
w.Dump()
panic("gui.SetNode() Error not nil")
}
w.node = n
if (w.node == nil) {
w.Dump()
panic("gui.SetNode() node == nil")
}
}
func (b *GuiBox) SetNode(n *Node) {
if (b.node != nil) {
b.Dump()
panic("gui.SetNode() Error not nil")
}
b.node = n
if (b.node == nil) {
b.Dump()
panic("gui.SetNode() node == nil")
}
}
func (b *GuiBox) Append(child ui.Control, x bool) {
if b.UiBox == nil {
panic("GuiBox.Append() can't work. UiBox == nil")
return
}
b.UiBox.Append(child, x)
}
// Note: every mouse click is handled
@ -97,32 +182,32 @@ type GuiBox struct {
// the user clicks it. You could probably
// call this 'GuiMouseClick'
type GuiButton struct {
Name string // field for human readable name
Box *GuiBox // what box the button click was in
Name string // field for human readable name
Box *GuiBox // what box the button click was in
// a callback function for the main application
Custom func (*GuiButton)
Values interface {}
Color color.RGBA
Custom func(*GuiButton)
Values interface{}
Color color.RGBA
// andlabs/ui abstraction mapping
B *ui.Button
FB *ui.FontButton
CB *ui.ColorButton
B *ui.Button
FB *ui.FontButton
CB *ui.ColorButton
}
// text entry fields
type GuiEntry struct {
Name string // field for human readable name
Edit bool
Last string // the last value
Normalize func (string) string // function to 'normalize' the data
Name string // field for human readable name
Edit bool
Last string // the last value
Normalize func(string) string // function to 'normalize' the data
B *GuiButton
Box *GuiBox
B *GuiButton
Box *GuiBox
// andlabs/ui abstraction mapping
UiEntry *ui.Entry
UiEntry *ui.Entry
}
//
@ -130,20 +215,21 @@ type GuiEntry struct {
// AREA STRUCTURES START
// AREA STRUCTURES START
//
type GuiArea struct{
Button *GuiButton // what button handles mouse events
Box *GuiBox
type GuiArea struct {
Button *GuiButton // what button handles mouse events
Box *GuiBox
UiAttrstr *ui.AttributedString
UiArea *ui.Area
UiAttrstr *ui.AttributedString
UiArea *ui.Area
}
type FontString struct {
S string
Size int
F font.Face
W font.Weight
S string
Size int
F font.Face
W font.Weight
}
//
// AREA STRUCTURES END
// AREA STRUCTURES END
@ -161,18 +247,18 @@ type FontString struct {
// to the GUI. This is the "authoritative" data.
//
type TableData struct {
RowCount int // This is the number of 'rows' which really means data elements not what the human sees
RowWidth int // This is how wide each row is
Rows []RowData // This is all the table data by row
generatedColumnTypes []ui.TableValue // generate this dynamically
RowCount int // This is the number of 'rows' which really means data elements not what the human sees
RowWidth int // This is how wide each row is
Rows []RowData // This is all the table data by row
generatedColumnTypes []ui.TableValue // generate this dynamically
Cells [20]CellData
Human [20]HumanMap
Cells [20]CellData
Human [20]HumanMap
Box *GuiBox
Box *GuiBox
lastRow int
lastColumn int
lastRow int
lastColumn int
}
//
@ -191,44 +277,44 @@ type TableData struct {
// TODO: re-add images and the progress bar (works in andlabs/ui)
//
type HumanCellData struct {
Name string // what kind of row is this?
Text string
TextID int
Color color.RGBA
ColorID int
Button *GuiButton
Name string // what kind of row is this?
Text string
TextID int
Color color.RGBA
ColorID int
Button *GuiButton
}
type HumanMap struct {
Name string // what kind of row is this?
TextID int
ColorID int
Name string // what kind of row is this?
TextID int
ColorID int
}
type TableColumnData struct {
Index int
CellType string
Heading string
Color string
Index int
CellType string
Heading string
Color string
}
type CellData struct {
Index int
HumanID int
Name string // what type of cell is this?
Index int
HumanID int
Name string // what type of cell is this?
}
// hmm. will this stand the test of time?
type RowData struct {
Name string // what kind of row is this?
Status string // status of the row?
/*
// TODO: These may or may not be implementable
// depending on if it's possible to detect the bgcolor or what row is selected
click func() // what function to call if the user clicks on it
doubleclick func() // what function to call if the user double clicks on it
*/
HumanData [20]HumanCellData
Name string // what kind of row is this?
Status string // status of the row?
/*
// TODO: These may or may not be implementable
// depending on if it's possible to detect the bgcolor or what row is selected
click func() // what function to call if the user clicks on it
doubleclick func() // what function to call if the user double clicks on it
*/
HumanData [20]HumanCellData
}
//

12
table.go
View File

@ -98,12 +98,12 @@ func InitColumns(mh *TableData, parts []TableColumnData) {
}
func AddTableTab(gw *GuiWindow, name string, rowcount int, parts []TableColumnData) *TableData {
box := InitWindow(gw, name, Yaxis)
return AddTableBox(box, name, rowcount, parts)
node := NewWindow()
b := node.box
return b.AddTableBox(name, rowcount, parts)
}
func AddTableBox(box *GuiBox, name string, rowcount int, parts []TableColumnData) *TableData {
func (b *GuiBox) AddTableBox(name string, rowcount int, parts []TableColumnData) *TableData {
mh := new(TableData)
mh.RowCount = rowcount
@ -142,9 +142,9 @@ func AddTableBox(box *GuiBox, name string, rowcount int, parts []TableColumnData
// is this needed?
// gw.BoxMap[name] = box
mh.Box = box
mh.Box = b
box.UiBox.Append(table, true)
b.UiBox.Append(table, true)
return mh
}

3
tableCallbacks.go
View File

@ -30,7 +30,8 @@ func (mh *TableData) ColumnTypes(m *ui.TableModel) []ui.TableValue {
}
// TODO: Figure out why this is being called 1000 times a second (10 times for each row & column)
// Nevermind this TODO. Who gives a shit. This is a really smart way to treat the OS toolkits
//
// Nevermind that TODO. Who gives a shit. This is a really smart way to treat the OS toolkits
func (mh *TableData) CellValue(m *ui.TableModel, row, column int) ui.TableValue {
if (Config.DebugTable) {
log.Println("CellValue() row, column =", row, column)

289
window.go
View File

@ -1,50 +1,13 @@
package gui
import "log"
import "time"
// import "regexp"
import (
"log"
"fmt"
"strconv"
import "github.com/andlabs/ui"
import _ "github.com/andlabs/ui/winmanifest"
func StartNewWindow(bg bool, name string, axis int, callback func(*GuiBox) *GuiBox) {
log.Println("StartNewWindow() Create a new window")
if (bg) {
log.Println("StartNewWindow() START NEW GOROUTINE for ui.Main()")
go ui.Main(func() {
log.Println("gui.StartNewWindow() inside ui.Main() in NEW goroutine")
// InitWindow must be called from within ui.Main()
box := InitWindow(nil, name, axis)
box = callback(box)
window := box.Window
log.Println("StartNewWindow() box =", box)
runWindow(window.UiWindow)
})
time.Sleep(500 * time.Millisecond) // this might make it more stable on windows?
} else {
log.Println("StartNewWindow() WAITING for ui.Main()")
ui.Main(func() {
log.Println("gui.StartNewWindow() inside ui.Main()")
// InitWindow must be called from within ui.Main()
box := InitWindow(nil, name, axis)
box = callback(box)
window := box.Window
log.Println("StartNewWindow() box =", box)
runWindow(window.UiWindow)
})
}
}
// This creates the raw andlabs/ui Window
func runWindow(uiWindow *ui.Window) {
log.Println("runWindow() START ui.Window.Show()")
uiWindow.Show()
}
"github.com/andlabs/ui"
_ "github.com/andlabs/ui/winmanifest"
)
func MessageWindow(gw *GuiWindow, msg1 string, msg2 string) {
ui.MsgBox(gw.UiWindow, msg1, msg2)
@ -54,91 +17,17 @@ func ErrorWindow(gw *GuiWindow, msg1 string, msg2 string) {
ui.MsgBoxError(gw.UiWindow, msg1, msg2)
}
//
// This creates a new 'window' (which is just a tab in the window)
// This is this way because on Linux you can have more than one
// actual window but that does not appear to work on the MacOS or Windows
//
func InitWindow(gw *GuiWindow, name string, axis int) *GuiBox {
window := Data.WindowMap[name]
if (window != nil) {
box := window.BoxMap["MAINBOX"]
log.Println("gui.InitWindow() tab already exists name =", name)
ErrorWindow(box.Window, "Create Window Error", "Window " + name + " already exists")
return nil
}
log.Println("InitGuiWindow() START")
var newGuiWindow GuiWindow
newGuiWindow.Height = Config.Height
newGuiWindow.Width = Config.Width
newGuiWindow.Axis = axis
newGuiWindow.Name = name
// This is the first window. One must create it here
if (gw == nil) {
log.Println("initWindow() ADDING ui.NewWindow()")
newGuiWindow.UiWindow = ui.NewWindow(name, int(newGuiWindow.Width), int(newGuiWindow.Height), true)
newGuiWindow.UiWindow.SetBorderless(false)
newGuiWindow.UiWindow.OnClosing(func(*ui.Window) bool {
log.Println("initTabWindow() OnClosing() THIS WINDOW IS CLOSING newGuiWindow=", newGuiWindow)
// newGuiWindow.UiWindow.Destroy()
if (Config.Exit == nil) {
ui.Quit()
} else {
// allow a custom exit function
Config.Exit(&newGuiWindow)
}
return true
})
newGuiWindow.UiTab = ui.NewTab()
newGuiWindow.UiWindow.SetChild(newGuiWindow.UiTab)
newGuiWindow.UiWindow.SetMargined(true)
tmp := 0
newGuiWindow.TabNumber = &tmp
} else {
newGuiWindow.UiWindow = gw.UiWindow
newGuiWindow.UiTab = gw.UiTab
}
newGuiWindow.BoxMap = make(map[string]*GuiBox)
newGuiWindow.EntryMap = make(map[string]*GuiEntry)
// Data.Windows = append(Data.Windows, &newGuiWindow)
if (newGuiWindow.UiTab == nil) {
tabnum := 0
newGuiWindow.TabNumber = &tabnum
} else {
tabnum := newGuiWindow.UiTab.NumPages()
newGuiWindow.TabNumber = &tabnum
}
Data.WindowMap[newGuiWindow.Name] = &newGuiWindow
var box *GuiBox
if (axis == Xaxis) {
box = HardBox(&newGuiWindow, Xaxis, name)
} else {
box = HardBox(&newGuiWindow, Yaxis, name)
}
log.Println("InitGuiWindow() END *GuiWindow =", &newGuiWindow)
return box
}
func DeleteWindow(name string) {
log.Println("gui.DeleteWindow() START name =", name)
window := Data.WindowMap[name]
if (window == nil) {
if window == nil {
log.Println("gui.DeleteWindow() NO WINDOW WITH name =", name)
return
}
log.Println("gui.DumpBoxes() MAP: ", name)
log.Println("gui.DumpBoxes()\tWindow.name =", window.Name)
if (window.TabNumber == nil) {
if window.TabNumber == nil {
log.Println("gui.DumpBoxes() \tWindows.TabNumber = nil")
}
tab := *window.TabNumber
@ -156,11 +45,11 @@ func DeleteWindow(name string) {
// renumber tabs here
for name, window := range Data.WindowMap {
log.Println("gui.DumpBoxes() MAP: ", name)
if (window.TabNumber == nil) {
if window.TabNumber == nil {
log.Println("gui.DumpBoxes() \tWindows.TabNumber = nil")
} else {
log.Println("gui.DumpBoxes() \tWindows.TabNumber =", *window.TabNumber)
if (tab < *window.TabNumber) {
if tab < *window.TabNumber {
log.Println("gui.DumpBoxes() \tSubtracting 1 from TabNumber")
*window.TabNumber -= 1
log.Println("gui.DumpBoxes() \tWindows.TabNumber is now =", *window.TabNumber)
@ -168,3 +57,159 @@ func DeleteWindow(name string) {
}
}
}
func makeNode(parent *Node, title string, x int, y int) *Node {
var node Node
node.Name = title
node.Width = x
node.Height = y
id := Config.prefix + strconv.Itoa(Config.counter)
Config.counter += 1
node.id = id
// panic("gui.makeNode() START")
if (parent == nil) {
if (Data.NodeMap[title] != nil) {
log.Println("Duplicate window name =", title)
// TODO: just change the 'title' to something unique
panic(fmt.Sprintf("Duplicate window name = %s\n", title))
return nil
}
// panic("gui.makeNode() before NodeMap()")
Data.NodeMap[title] = &node
Data.NodeArray = append(Data.NodeArray, &node)
Data.NodeSlice = append(Data.NodeSlice, &node)
// panic("gui.makeNode() after NodeMap()")
return &node
} else {
// panic("gui.makeNode() before Append()")
parent.Append(&node)
// panic("gui.makeNode() after Append()")
}
node.parent = parent
return &node
}
func (parent *Node) makeNode(title string, x int, y int) *Node {
var node Node
node.Name = title
node.Width = x
node.Height = y
id := Config.prefix + strconv.Itoa(Config.counter)
Config.counter += 1
node.id = id
parent.Append(&node)
node.parent = parent
return &node
}
func (n *Node) AddNode(title string) *Node {
var node Node
node.Name = title
node.Width = n.Width
node.Height = n.Height
id := Config.prefix + strconv.Itoa(Config.counter)
Config.counter += 1
node.id = id
n.Append(&node)
node.parent = n
return &node
}
func (n *Node) uiNewWindow(title string, x int, y int) {
w := ui.NewWindow(title, x, y, false)
w.SetBorderless(false)
f := Config.Exit
w.OnClosing(func(*ui.Window) bool {
if (Config.Debug) {
log.Println("ui.Window().OnClosing()")
}
if (f != nil) {
f(n)
}
return true
})
w.SetMargined(true)
w.Show()
n.uiWindow = w
// w.node = &node
return
}
func mapWindow(parent *Node, window *ui.Window, title string, x int, y int) *Node {
log.Println("gui.WindowMap START title =", title)
if Data.WindowMap[title] != nil {
log.Println("Data.WindowMap[title] already exists title =", title)
title = title + Config.prefix + strconv.Itoa(Config.counter)
Config.counter += 1
}
if Data.WindowMap[title] != nil {
log.Println("Data.WindowMap[title] already exists title =", title)
panic("Data.WindowMap[newGuiWindow.Name] already exists")
return nil
}
var newGuiWindow GuiWindow
newGuiWindow.Width = x
newGuiWindow.Height = y
newGuiWindow.Name = title
newGuiWindow.UiWindow = window
newGuiWindow.BoxMap = make(map[string]*GuiBox)
newGuiWindow.EntryMap = make(map[string]*GuiEntry)
Data.WindowMap[newGuiWindow.Name] = &newGuiWindow
var box GuiBox
box.Window = &newGuiWindow
box.Name = title
node := makeNode(parent, title, x, y)
node.box = &box
node.uiWindow = window
box.node = node
newGuiWindow.BoxMap["jcarrInitTest"] = &box
return node
}
// This routine creates a blank window with a Title and size (W x H)
//
// This routine can not have any arguements due to the nature of how
// it can be passed via the 'andlabs/ui' queue which, because it is
// cross platform, must pass UI changes into the OS threads (that is
// my guess).
func NewWindow() *Node {
title := Config.Title
w := Config.Width
h := Config.Height
var n *Node
n = mapWindow(nil, nil, title, w, h)
box := n.box
log.Println("gui.NewWindow() title = box.Name =", box.Name)
n.uiNewWindow(box.Name, w, h)
window := n.uiWindow
f := Config.Exit
ui.OnShouldQuit(func() bool {
log.Println("createWindow().Destroy() on node.Name =", n.Name)
if (f != nil) {
f(n)
}
return true
})
box.Window.UiWindow = window
if(n.uiWindow == nil) {
panic("node.uiWindow == nil. This should never happen")
}
return n
}