README ¶
go.uik getting started
Overview
The purpose of this document is to show you some examples of how to use go.uik. You should should have some basic knowledge of go (golang).
Before we start coding we have to understand some basics: go.uik works on Windows, Linux and OSX. This is possible because it uses different back ends. Early there was three files in every project to manage those back ends.
- wde_darwin.go
- wde_linux.go
- wde_windows.go
Each of them imports a specific back end, e.g.
Now, it replaced by adding to go.wde import go.wde/init import.
"github.com/skelterjohn/go.wde"
_ "github.com/skelterjohn/go.wde/init"
import _ "github.com/skelterjohn/go.wde/cocoa"
For now we just have to know that we need those tree files in the directory of our project.
Hello World
This example shows how to create a window with the title "Hello World".
The first part is easy, we define the package and import the needed packages.
package main
import (
"fmt"
"github.com/skelterjohn/geom"
"github.com/kirillDanshin/go.uik"
"github.com/skelterjohn/go.wde"
)
Now we create a function which we'll later start as a goroutine. To create a new window we use uik.NewWindow
and check if there are any errors. uik.NewWindow
returns a pointer to a WindowFoundation
, a WindowFoundation
wraps a wde.Window
.
func hello() {
w, err := uik.NewWindow(nil, 320, 480)
if err != nil {
fmt.Println(err)
return
}
}
Now we have a window, but no title, so let's set one by using w.W.SetTitle("Hello World")
. w.W
is our window (remember, w
is the WindowFoundation
. SetTitle
is obviously the function to set the window title.
The next line w.Show()
makes our WindowFoundation
visible on the screen.
w.W.SetTitle("Hello World")
w.Show()
This is the code of our Hello World program:
package main
import (
"fmt"
"github.com/skelterjohn/geom"
"github.com/kirillDanshin/go.uik"
"github.com/skelterjohn/go.wde"
_ "github.com/skelterjohn/go.wde/init"
)
func main() {
go hello()
wde.Run()
}
func hello() {
wbounds := geom.Rect{
Max: geom.Coord{480, 320},
}
w, err := uik.NewWindow(nil, int(wbounds.Max.X), int(wbounds.Max.Y))
if err != nil {
fmt.Println(err)
return
}
w.W.SetTitle("Hello World")
w.Show()
}
You can build it (if you don't use three wde_ files variant, you can use go run. otherwise go run doesn't work, because go run doesn't care about the three wde_ files).
$ go build /path/to/your/helloworld
After running this, you'll get a hello
file in you current directory (to start it ./hello
). But there's a problem, we can't close the window, this will be solved next. For now just press Ctrl + c
on the console where you started the hello
program.
The Close Event
The program works, but we don't end it properly. We have to add a close event to the window to end the program when the window is being closed.
First we create a channel of type interface{}
(no specific type), buffer size is one. isDone
is a function variable, the function itself gets an event, it checks if this event is of type uid.CloseEvent
(type assertation). If the event is of type uik.CloseEvent
, accept
will be true
and we're done.
done := make(chan interface{}, 1)
isDone := func(e interface{}) (accept, done bool) {
_, accept = e.(uik.CloseEvent)
done = accept
return
}
The next line
w.Block.Subscribe <- uik.Subscription{isDone, done}
does the subscription.
Finally we have our channel done
that blocks, until the close event happened. After this we close our window and call wde.Stop()
to end our back end.
<-done
w.W.Close()
wde.Stop()
Finally we start hello()
as go routine in main()
and start the back end with wde.Run()
.
func main() {
go hello()
wde.Run()
}
This is the complete example:
package main
import (
"fmt"
"github.com/skelterjohn/go.uik"
"github.com/skelterjohn/go.wde"
"github.com/skelterjohn/go.wde/init"
)
func main() {
go hello()
wde.Run()
}
func hello() {
w, err := uik.NewWindow(nil, 480, 320)
if err != nil {
fmt.Println(err)
return
}
w.W.SetTitle("Hello World")
w.Show()
// Here we set up a subscription on the window's close events.
done := make(chan interface{}, 1)
isDone := func(e interface{}) (accept, done bool) {
_, accept = e.(uik.CloseEvent)
done = accept
return
}
w.Block.Subscribe <- uik.Subscription{isDone, done}
// once a close event comes in on the subscription, end the program
<-done
w.W.Close()
wde.Stop()
}
Documentation ¶
There is no documentation for this package.