1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
# gui
Package gui implements a abstraction layer for Go visual elements.
Definitions:
* Toolkit: the underlying GUI library (MacOS gui, Windows gui, gtk, qt, etc)
* Node: A binary tree of all the underlying widgets
Principles:
* Make code using this package simple to use
* Hide complexity internally here
* Isolate the GUI toolkit
* Widget names should try to match [Wikipedia Graphical widget]
* When in doubt, search upward in the binary tree
* It's ok to guess. Try to do something sensible.
Quick Start
```go
// This creates a simple hello world window
package main
import (
"log"
"git.wit.org/wit/gui"
)
var window *gui.Node // This is the beginning of the binary tree of widgets
// go will sit here until the window exits
func main() {
gui.Init()
gui.Main(helloworld)
}
// This initializes the first window and 2 tabs
func helloworld() {
gui.Config.Title = "Hello World golang wit/gui Window"
gui.Config.Width = 640
gui.Config.Height = 480
window := gui.NewWindow()
addTab(window, "A Simple Tab Demo")
addTab(window, "A Second Tab")
}
func addTab(w *gui.Node, title string) {
tab := w.NewTab(title)
group := tab.NewGroup("foo bar")
group.NewButton("hello", func() {
log.Println("world")
})
}
```
## Debian Build
This worked on debian sid on 2022/10/20
I didn't record the dependances needed
```go
GO111MODULE="off" go get -v -t -u git.wit.org/wit/gui
cd ~/go/src/git.wit.org/wit/gui/cmds/helloworld/
GO111MODULE="off" go build -v -x
[./helloworld](./helloworld)
```
Toolkits
* andlabs - [https://github.com/andlabs/ui](https://github.com/andlabs/ui)
* gocui - [https://github.com/awesome-gocui/gocui](https://github.com/awesome-gocui/gocui)
The next step is to allow this to work against go-gtk and go-qt.
TODO: Add Fyne, WASM, native macos & windows, android and
hopefully also things like libSDL, faiface/pixel, slint
## Bugs
"The author's idea of friendly may differ to that of many other people."
-- quote from the minimalistic window manager 'evilwm'
## References
Useful links and other
external things which might be useful
* [Wikipedia Graphical widget](https://en.wikipedia.org/wiki/Graphical_widget)
* [GO Style Guide](https://google.github.io/styleguide/go/index) Code this way
* [MS Windows Application Library Kit](https://github.com/lxn/walk)
* [Federated git pull](https://github.com/forgefed/forgefed) Hopefully this will work for me with gitea
* [Github mirror](https://github.com/wit-go/gui) This repo on mirror. Hopefully I won't have to use this.
* [WIT GO projects](https://go.wit.org/) Attempt to model go.uber.org
## Functions
### func [GetDebug](/structs.go#L25)
`func GetDebug() bool`
### func [GetDebugToolkit](/structs.go#L37)
`func GetDebugToolkit() bool`
### func [IndentPrintln](/structs.go#L188)
`func IndentPrintln(a ...interface{})`
### func [Init](/main.go#L41)
`func Init()`
### func [LoadToolkit](/plugin.go#L37)
`func LoadToolkit(name string)`
loads and initializes a toolkit (andlabs/ui, gocui, etc)
### func [Main](/main.go#L56)
`func Main(f func())`
### func [Queue](/main.go#L77)
`func Queue(f func())`
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(NewWindow())
### func [SetDebug](/structs.go#L29)
`func SetDebug(s bool)`
### func [SetDebugToolkit](/structs.go#L41)
`func SetDebugToolkit(s bool)`
### func [ShowDebugValues](/structs.go#L45)
`func ShowDebugValues()`
### func [StandardClose](/main.go#L83)
`func StandardClose(n *Node)`
The window is destroyed but the application does not quit
### func [StandardExit](/main.go#L90)
`func StandardExit(n *Node)`
The window is destroyed but the application does not quit
### func [Watchdog](/watchdog.go#L16)
`func Watchdog()`
This program sits here.
If you exit here, the whole thing will os.Exit()
This goroutine can be used like a watchdog timer
## Types
### type [GuiConfig](/structs.go#L68)
`type GuiConfig struct { ... }`
#### Variables
```golang
var Config GuiConfig
```
### type [GuiOptions](/structs.go#L56)
`type GuiOptions struct { ... }`
This struct can be used with go-arg
### type [Node](/structs.go#L87)
`type Node struct { ... }`
The Node is simply the name and the size of whatever GUI element exists
#### func [NewWindow](/window.go#L15)
`func NewWindow() *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).
### type [Symbol](/plugin.go#L17)
`type Symbol any`
## Sub Packages
* [toolkit](./toolkit)
---
Readme created from Go doc with [goreadme](https://github.com/posener/goreadme)
|
