func main() {
// Initialize GTK without parsing any command line arguments.
gtk.Init(nil)
// Create a new toplevel window, set its title, and connect it to the
// "destroy" signal to exit the GTK main loop when it is destroyed.
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if err != nil {
log.Fatal("Unable to create window:", err)
}
win.SetTitle("Simple Example")
win.Connect("destroy", func() {
gtk.MainQuit()
})
// Create a new label widget to show in the window.
l, err := gtk.LabelNew("Hello, gotk3!")
if err != nil {
log.Fatal("Unable to create label:", err)
}
// Add the label to the window.
win.Add(l)
// Set the default window size.
win.SetDefaultSize(800, 600)
// Recursively show all widgets contained in this window.
win.ShowAll()
// Begin executing the GTK main loop. This blocks until
// gtk.MainQuit() is run.
gtk.Main()
}
func main() {
gtk.Init(nil)
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if err != nil {
log.Fatal("Unable to create window:", err)
}
win.Connect("destroy", func() {
gtk.MainQuit()
})
win.Add(windowWidget())
// Native GTK is not thread safe, and thus, gotk3's GTK bindings may not
// be used from other goroutines. Instead, glib.IdleAdd() must be used
// to add a function to run in the GTK main loop when it is in an idle
// state.
//
// Two examples of using glib.IdleAdd() are shown below. The first runs
// a user created function, LabelSetTextIdle, and passes it two
// arguments for a label and the text to set it with. The second calls
// (*gtk.Label).SetText directly, passing in only the text as an
// argument.
//
// If the function passed to glib.IdleAdd() returns one argument, and
// that argument is a bool, this return value will be used in the same
// manner as a native g_idle_add() call. If this return value is false,
// the function will be removed from executing in the GTK main loop's
// idle state. If the return value is true, the function will continue
// to execute when the GTK main loop is in this state.
go func() {
for {
time.Sleep(time.Second)
s := fmt.Sprintf("Set a label %d time(s)!", nSets)
_, err := glib.IdleAdd(LabelSetTextIdle, topLabel, s)
if err != nil {
log.Fatal("IdleAdd() failed:", err)
}
nSets++
s = fmt.Sprintf("Set a label %d time(s)!", nSets)
_, err = glib.IdleAdd(bottomLabel.SetText, s)
if err != nil {
log.Fatal("IdleAdd() failed:", err)
}
nSets++
}
}()
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if err != nil {
log.Fatal("Unable to create window:", err)
}
win.Connect("destroy", func() {
gtk.MainQuit()
})
win.Add(windowWidget())
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
win := setupWindow("Go Feature Timeline")
treeView, listStore := setupTreeView()
win.Add(treeView)
// Add some rows to the list store
addRow(listStore, "r57", "Gofix command added for rewriting code for new APIs")
addRow(listStore, "r60", "URL parsing moved to new \"url\" package")
addRow(listStore, "go1.0", "Rune type introduced as alias for int32")
addRow(listStore, "go1.1", "Race detector added to tools")
addRow(listStore, "go1.2", "Limit for number of threads added")
addRow(listStore, "go1.3", "Support for various BSD's, Plan 9 and Solaris")
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
win := setupWindow()
box, _ := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 0)
win.Add(box)
tv := setupTextView(box)
props := []*BoolProperty{
&BoolProperty{"cursor visible", (*tv).GetCursorVisible, (*tv).SetCursorVisible},
&BoolProperty{"editable", (*tv).GetEditable, (*tv).SetEditable},
&BoolProperty{"overwrite", (*tv).GetOverwrite, (*tv).SetOverwrite},
&BoolProperty{"accepts tab", (*tv).GetAcceptsTab, (*tv).SetAcceptsTab},
}
setupPropertyCheckboxes(tv, box, props)
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
// gui boilerplate
win, _ := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
da, _ := gtk.DrawingAreaNew()
win.Add(da)
win.SetTitle("Arrow keys")
win.Connect("destroy", gtk.MainQuit)
win.ShowAll()
// Data
unitSize := 20.0
x := 0.0
y := 0.0
keyMap := map[uint]func(){
KEY_LEFT: func() { x-- },
KEY_UP: func() { y-- },
KEY_RIGHT: func() { x++ },
KEY_DOWN: func() { y++ },
}
// Event handlers
da.Connect("draw", func(da *gtk.DrawingArea, cr *cairo.Context) {
cr.SetSourceRGB(0, 0, 0)
cr.Rectangle(x*unitSize, y*unitSize, unitSize, unitSize)
cr.Fill()
})
win.Connect("key-press-event", func(win *gtk.Window, ev *gdk.Event) {
keyEvent := &gdk.EventKey{ev}
if move, found := keyMap[keyEvent.KeyVal()]; found {
move()
win.QueueDraw()
}
})
gtk.Main()
}
func main() {
gtk.Init(nil)
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if err != nil {
log.Fatal("Unable to create window:", err)
}
win.SetTitle("Grid Example")
win.Connect("destroy", func() {
gtk.MainQuit()
})
// Create a new grid widget to arrange child widgets
grid, err := gtk.GridNew()
if err != nil {
log.Fatal("Unable to create grid:", err)
}
// gtk.Grid embeds an Orientable struct to simulate the GtkOrientable
// GInterface. Set the orientation from the default horizontal to
// vertical.
grid.SetOrientation(gtk.ORIENTATION_VERTICAL)
// Create some widgets to put in the grid.
lab, err := gtk.LabelNew("Just a label")
if err != nil {
log.Fatal("Unable to create label:", err)
}
btn, err := gtk.ButtonNewWithLabel("Button with label")
if err != nil {
log.Fatal("Unable to create button:", err)
}
entry, err := gtk.EntryNew()
if err != nil {
log.Fatal("Unable to create entry:", err)
}
spnBtn, err := gtk.SpinButtonNewWithRange(0.0, 1.0, 0.001)
if err != nil {
log.Fatal("Unable to create spin button:", err)
}
nb, err := gtk.NotebookNew()
if err != nil {
log.Fatal("Unable to create notebook:", err)
}
// Calling (*gtk.Container).Add() with a gtk.Grid will add widgets next
// to each other, in the order they were added, to the right side of the
// last added widget when the grid is in a horizontal orientation, and
// at the bottom of the last added widget if the grid is in a vertial
// orientation. Using a grid in this manner works similar to a gtk.Box,
// but unlike gtk.Box, a gtk.Grid will respect its child widget's expand
// and margin properties.
grid.Add(btn)
grid.Add(lab)
grid.Add(entry)
grid.Add(spnBtn)
// Widgets may also be added by calling (*gtk.Grid).Attach() to specify
// where to place the widget in the grid, and optionally how many rows
// and columns to span over.
//
// Additional rows and columns are automatically added to the grid as
// necessary when new widgets are added with (*gtk.Container).Add(), or,
// as shown in this case, using (*gtk.Grid).Attach().
//
// In this case, a notebook is added beside the widgets inserted above.
// The notebook widget is inserted with a left position of 1, a top
// position of 1 (starting at the same vertical position as the button),
// a width of 1 column, and a height of 2 rows (spanning down to the
// same vertical position as the entry).
//
// This example also demonstrates how not every area of the grid must
// contain a widget. In particular, the area to the right of the label
// and the right of spin button have contain no widgets.
grid.Attach(nb, 1, 1, 1, 2)
nb.SetHExpand(true)
nb.SetVExpand(true)
// Add a child widget and tab label to the notebook so it renders.
nbChild, err := gtk.LabelNew("Notebook content")
if err != nil {
log.Fatal("Unable to create button:", err)
}
nbTab, err := gtk.LabelNew("Tab label")
if err != nil {
log.Fatal("Unable to create label:", err)
}
nb.AppendPage(nbChild, nbTab)
// Add the grid to the window, and show all widgets.
win.Add(grid)
win.ShowAll()
gtk.Main()
}
func init() {
gtk.Init(nil)
}