func TestWebView_URI(t *testing.T) { setup() defer teardown() mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {}) wantURI := server.URL + "/" var gotURI string webView.Connect("notify::uri", func() { glib.IdleAdd(func() bool { gotURI = webView.URI() if gotURI != "" { gtk.MainQuit() } return false }) }) glib.IdleAdd(func() bool { webView.LoadURI(server.URL) return false }) gtk.Main() if wantURI != gotURI { t.Errorf("want URI %q, got %q", wantURI, gotURI) } }
func TestWebView_RunJavaScript(t *testing.T) { webView := NewWebView() defer webView.Destroy() wantResultString := "abc" webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) { switch loadEvent { case LoadFinished: webView.RunJavaScript(`document.getElementById("foo").innerHTML`, func(result *gojs.Value, err error) { if err != nil { t.Errorf("RunJavaScript error: %s", err) } resultString := webView.JavaScriptGlobalContext().ToStringOrDie(result) if wantResultString != resultString { t.Errorf("want result string %q, got %q", wantResultString, resultString) } gtk.MainQuit() }) } }) glib.IdleAdd(func() bool { webView.LoadHTML(`<p id=foo>abc</p>`, "") return false }) gtk.Main() }
func TestWebView_LoadHTML(t *testing.T) { webView := NewWebView() defer webView.Destroy() loadOk := false webView.Connect("load-failed", func() { t.Errorf("load failed") }) webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) { switch loadEvent { case LoadFinished: loadOk = true gtk.MainQuit() } }) glib.IdleAdd(func() bool { webView.LoadHTML("<p>hello</p>", "") return false }) gtk.Main() if !loadOk { t.Error("!loadOk") } }
func TestWebView_Title(t *testing.T) { webView := NewWebView() defer webView.Destroy() wantTitle := "foo" var gotTitle string webView.Connect("notify::title", func() { glib.IdleAdd(func() bool { gotTitle = webView.Title() if gotTitle != "" { gtk.MainQuit() } return false }) }) glib.IdleAdd(func() bool { webView.LoadHTML("<html><head><title>"+wantTitle+"</title></head><body></body></html>", "") return false }) gtk.Main() if wantTitle != gotTitle { t.Errorf("want title %q, got %q", wantTitle, gotTitle) } }
func TestWebView_RunJavaScript_exception(t *testing.T) { webView := NewWebView() defer webView.Destroy() wantErr := errors.New("An exception was raised in JavaScript") webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) { switch loadEvent { case LoadFinished: webView.RunJavaScript(`throw new Error("foo")`, func(result *gojs.Value, err error) { if result != nil { ctx := webView.JavaScriptGlobalContext() t.Errorf("want result == nil, got %q", ctx.ToStringOrDie(result)) } if !reflect.DeepEqual(wantErr, err) { t.Errorf("want error %q, got %q", wantErr, err) } gtk.MainQuit() }) } }) glib.IdleAdd(func() bool { webView.LoadHTML(`<p></p>`, "") return false }) gtk.Main() }
func TestWebView_GetSnapshot(t *testing.T) { webView := NewWebView() defer webView.Destroy() webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) { switch loadEvent { case LoadFinished: webView.GetSnapshot(func(img *image.RGBA, err error) { if err != nil { t.Errorf("GetSnapshot error: %q", err) } if img.Pix == nil { t.Error("!img.Pix") } if img.Stride == 0 || img.Rect.Max.X == 0 || img.Rect.Max.Y == 0 { t.Error("!img.Stride or !img.Rect.Max.X or !img.Rect.Max.Y") } gtk.MainQuit() }) } }) glib.IdleAdd(func() bool { webView.LoadHTML(`<p id=foo>abc</p>`, "") return false }) gtk.Main() }
func TestWebView_LoadURI_load_failed(t *testing.T) { webView := NewWebView() defer webView.Destroy() loadFailed := false loadFinished := false webView.Connect("load-failed", func() { loadFailed = true }) webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) { switch loadEvent { case LoadFinished: loadFinished = true gtk.MainQuit() } }) glib.IdleAdd(func() bool { // Load a bad URL to trigger load failure. webView.LoadURI("http://127.0.0.1:99999") return false }) gtk.Main() if !loadFailed { t.Error("!loadFailed") } if !loadFinished { t.Error("!loadFinished") } }
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. list, err := gtk.ListBoxNew() if err != nil { log.Fatal("Unable to create label:", err) } gtkList = list // Add the label to the window. win.Add(gtkList) // Set the default window size. win.SetDefaultSize(640/2, 1136/2) // Recursively show all widgets contained in this window. win.ShowAll() // Begin executing the GTK main loop. This blocks until // gtk.MainQuit() is run. go getEntries() gtk.Main() }
func backgroundOrchestrator(launcher launchers.Launcher, bootDescriptorPath string, guiOutcomeChannel chan guiOutcomeStruct) { outcome := runEngineWithGtk(launcher, bootDescriptorPath) userInterface := outcome.userInterface err := outcome.err log.SetCallback(func(level logging.Level, message string) {}) log.Debug("Result returned by the background routine. Is UI available? %v", userInterface != nil) if err != nil { log.Warning("Err is: %v", err) if userInterface != nil { switch err.(type) { case *engine.ExecutionCanceled: break default: userInterface.ShowError(err.Error()) } } } log.Debug("Now programmatically quitting GTK") gtk.MainQuit() guiOutcomeChannel <- outcome }
func main() { gtk.Init(nil) go func() { appdbus.StandAlone(TVPlay.NewApplet) gtk.MainQuit() }() gtk.Main() }
/*At this moment Visionect specific*/ func TestTimeoutAdd(t *testing.T) { runtime.LockOSThread() glib.TimeoutAdd(2500, func(s string) bool { t.Log(s) gtk.MainQuit() return false }, "TimeoutAdd executed") gtk.Main() }
func main() { gtk.Init(nil) win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL) panicIfNotNil(err) win.Connect("destroy", func() { gtk.MainQuit() }) win.SetDefaultSize(1280, 720) win.SetTitle("mauIRC Desktop") // Create a new grid widget to arrange child widgets grid, err := gtk.GridNew() panicIfNotNil(err) grid.SetOrientation(gtk.ORIENTATION_VERTICAL) loginLabel, err := gtk.LabelNew("Log in to mauIRC") panicIfNotNil(err) email, err := gtk.EntryNew() panicIfNotNil(err) password, err := gtk.EntryNew() panicIfNotNil(err) password.SetVisibility(false) btn, err := gtk.ButtonNewWithLabel("Log in") panicIfNotNil(err) grid.Attach(loginLabel, 0, 2, 1, 1) grid.Attach(email, 0, 3, 1, 1) grid.Attach(password, 0, 4, 1, 1) grid.Attach(btn, 0, 5, 1, 1) //grid.Attach(nb, 1, 1, 1, 2) //nb.SetHExpand(true) //nb.SetVExpand(true) /*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)*/ win.Add(grid) win.ShowAll() gtk.Main() }
func setup_window(title string) *gtk.Window { win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL) if err != nil { log.Fatal("Unable to create window:", err) } win.SetTitle(title) win.Connect("destroy", func() { gtk.MainQuit() }) win.SetDefaultSize(800, 600) win.SetPosition(gtk.WIN_POS_CENTER) return win }
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 NewMainWindow() *MainWindow { self := new(MainWindow) var err error self.Window, err = gtk.WindowNew(gtk.WINDOW_TOPLEVEL) if err != nil { log.Fatal("Failed to load GTK") } self.Board = board.NewBoard() self.InitializeWidgets() self.Window.Connect("destroy", func() { gtk.MainQuit() }) self.Window.SetDefaultSize(640, 560) return self }
func Example() { runtime.LockOSThread() gtk.Init(nil) webView := webkit2.NewWebView() defer webView.Destroy() webView.Connect("load-failed", func() { fmt.Println("Load failed.") }) webView.Connect("load-changed", func(_ *glib.Object, i int) { loadEvent := webkit2.LoadEvent(i) switch loadEvent { case webkit2.LoadFinished: fmt.Println("Load finished.") fmt.Printf("Title: %q\n", webView.Title()) fmt.Printf("URI: %s\n", webView.URI()) webView.RunJavaScript("window.location.hostname", func(val *gojs.Value, err error) { if err != nil { fmt.Println("JavaScript error.") } else { fmt.Printf("Hostname (from JavaScript): %q\n", val) } gtk.MainQuit() }) } }) glib.IdleAdd(func() bool { webView.LoadURI("https://www.google.com/") return false }) gtk.Main() // output: // Load finished. // Title: "Google" // URI: https://www.google.com/ // Hostname (from JavaScript): "www.google.com" }
// TestConnectNotifySignal ensures that property notification signals (those // whose name begins with "notify::") are queried by the name "notify" (with the // "::" and the property name omitted). This is because the signal is "notify" // and the characters after the "::" are not recognized by the signal system. // // See // https://developer.gnome.org/gobject/stable/gobject-The-Base-Object-Type.html#GObject-notify // for background, and // https://developer.gnome.org/gobject/stable/gobject-Signals.html#g-signal-new // for the specification of valid signal names. func TestConnectNotifySignal(t *testing.T) { runtime.LockOSThread() // Create any GObject that has defined properties. spacing := 0 box, _ := gtk.BoxNew(gtk.ORIENTATION_HORIZONTAL, spacing) // Connect to a "notify::" signal to listen on property changes. box.Connect("notify::spacing", func() { gtk.MainQuit() }) glib.IdleAdd(func(s string) bool { t.Log(s) spacing++ box.SetSpacing(spacing) return true }, "IdleAdd executed") gtk.Main() }
func TestWebView_LoadURI(t *testing.T) { setup() defer teardown() responseOk := false mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) { w.Write([]byte("abc")) responseOk = true }) loadFinished := false webView.Connect("load-failed", func() { t.Errorf("load failed") }) webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) { switch loadEvent { case LoadFinished: loadFinished = true gtk.MainQuit() } }) glib.IdleAdd(func() bool { webView.LoadURI(server.URL) return false }) gtk.Main() if !responseOk { t.Error("!responseOk") } if !loadFinished { t.Error("!loadFinished") } }
func main() { gtk.Init(nil) win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL) if err != nil { log.Fatal("Impossible de créer la fenêtre :", err) } win.SetTitle("GoBox a0.1") win.Connect("destroy", func() { gtk.MainQuit() }) grid, err := gtk.GridNew() if err != nil { log.Fatal("Impossible de créer la grille :", err) } label1, err := gtk.LabelNew("Adresse IP / Port : ") if err != nil { log.Fatal("Impossible de créer le label IP :", err) } label3, err := gtk.LabelNew("Dossier à synchroniser : ") if err != nil { log.Fatal("Impossible de créer le label Dossier :", err) } entry1, err := gtk.EntryNew() if err != nil { log.Fatal("Impossible de créer le champ IP :", err) } entry2, err := gtk.EntryNew() if err != nil { log.Fatal("Impossible de créer le champ Port :", err) } entry3, err := gtk.EntryNew() if err != nil { log.Fatal("Impossible de créer le champ Dossier :", err) } btn, err := gtk.ButtonNewWithLabel("Lancer la synchronisation") if err != nil { log.Fatal("Impossible de créer le bouton synchronisation :", err) } /*btn2, err := gtk.FileChooserButtonNew("Choix") if err != nil { log.Fatal("Impossible de créer le bouton choix :", err) }*/ grid.SetOrientation(gtk.ORIENTATION_HORIZONTAL) //Attach(child IWidget, left, top, width, height int) grid.Add(label1) grid.SetOrientation(gtk.ORIENTATION_HORIZONTAL) grid.Add(entry1) grid.Add(entry2) grid.SetOrientation(gtk.ORIENTATION_VERTICAL) grid.Add(label3) grid.Add(entry3) grid.Attach(btn, 1, 2, 1, 2) btn.Connect("clicked", func() { /*dialog, _ := gtk.DialogNew() filechooser, _ := gtk.FileChooserWidgetNew(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) dialog.AddButton("Valider", gtk.RESPONSE_ACCEPT) dialog.AddButton("Annuler", gtk.RESPONSE_CANCEL) dialog.SetTitle("Choisir le dossier a synchroniser") box, _ := dialog.GetContentArea() box.Add(filechooser) box.ShowAll() log.Print("Clic lancer synchro")*/ filechooserdialog, _ := gtk.FileChooserDialogNewWith1Button( "Choisissez un fichier ...", //btn.GetTopLevelAsWindow(), win, gtk.FILE_CHOOSER_ACTION_OPEN, "Valider", gtk.RESPONSE_ACCEPT) /*filter := gtk.NewFileFilter() filter.AddPattern("*.go") filechooserdialog.AddFilter(filter)*/ filechooserdialog.Response(func() { println(filechooserdialog.GetFilename()) filechooserdialog.Destroy() }) filechooserdialog.Run() }) /* nbChildAll, err := gtk.LabelNew("Tous mes fichiers sont ici") if err != nil { log.Fatal("Unable to create button:", err) } nbTabAll, err := gtk.LabelNew("Tout") if err != nil { log.Fatal("Unable to create label:", err) } nbChildMusic, err := gtk.LabelNew("Toute ma musique est ici") if err != nil { log.Fatal("Unable to create button:", err) } nbTabMusic, err := gtk.LabelNew("Musique") if err != nil { log.Fatal("Unable to create label:", err) } nbChildPhotos, err := gtk.LabelNew("Toutes mes photos sont ici") if err != nil { log.Fatal("Unable to create button:", err) } nbTabPhotos, err := gtk.LabelNew("Photos") if err != nil { log.Fatal("Unable to create label:", err) } nbChildVideos, err := gtk.LabelNew("Toutes mes vidéos sont ici") if err != nil { log.Fatal("Unable to create button:", err) } nbTabVideos, err := gtk.LabelNew("Vidéos") if err != nil { log.Fatal("Unable to create label:", err) } nb.AppendPage(nbChildAll, nbTabAll) nb.AppendPage(nbChildMusic, nbTabMusic) nb.AppendPage(nbChildPhotos, nbTabPhotos) nb.AppendPage(nbChildVideos, nbTabVideos)*/ win.Add(grid) win.SetDefaultSize(200, 250) win.ShowAll() gtk.Main() }
func (u *gtkUI) quit() { // TODO: we should probably disconnect before quitting, if any account is connected gtk.MainQuit() }
func NewGtkUserInterface(launcher launchers.Launcher) (userInterface *GtkUserInterface, err error) { userInterface = &GtkUserInterface{ launcher: launcher, } gladeDescriptorPath := filepath.Join( filepath.Dir(launcher.GetExecutable()), "moondeploy.glade") runOnUIThreadAndWait(func() interface{} { builder, err := gtk.BuilderNew() if err != nil { panic(err) } err = builder.AddFromFile(gladeDescriptorPath) if err != nil { panic(err) } windowObject, err := builder.GetObject("mainWindow") if err != nil { panic(err) } window := windowObject.(*gtk.Window) userInterface.window = window launcher := userInterface.launcher window.SetTitle(launcher.GetTitle()) window.SetIconFromFile(launcher.GetIconPathAsPng()) window.Connect("destroy", func() { window.Destroy() userInterface.window = nil gtk.MainQuit() userInterface.closedByUser = true }) appLabelObject, err := builder.GetObject("appLabel") if err != nil { panic(err) } userInterface.appLabel = appLabelObject.(*gtk.Label) headerLabelObject, err := builder.GetObject("headerLabel") if err != nil { panic(err) } userInterface.headerLabel = headerLabelObject.(*gtk.Label) statusLabelObject, err := builder.GetObject("statusLabel") if err != nil { panic(err) } userInterface.statusLabel = statusLabelObject.(*gtk.Label) progressBarObject, err := builder.GetObject("progressBar") if err != nil { panic(err) } userInterface.progressBar = progressBarObject.(*gtk.ProgressBar) return nil }) return userInterface, nil }
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 (o *source) ClickedQuit() { gtk.MainQuit() }
func (m *GoAppMenu) Init() { var err error m.menubar, err = gtk.MenuBarNew() if err != nil { log.Fatal("Unable to create menubar:", err) } m.menuFile, err = gtk.MenuNew() if err != nil { log.Fatal("Unable to create menuFile:", err) } m.filemenu, err = gtk.MenuItemNewWithLabel("File") if err != nil { log.Fatal("Unable to create filemenu:", err) } m.fileNewSg, err = gtk.MenuItemNewWithLabel("New Signal Graph") if err != nil { log.Fatal("Unable to create fileNewSg:", err) } m.fileNewLib, err = gtk.MenuItemNewWithLabel("New Library") if err != nil { log.Fatal("Unable to create fileNewLib:", err) } m.fileNewPlat, err = gtk.MenuItemNewWithLabel("New Platform") if err != nil { log.Fatal("Unable to create fileNewPlat:", err) } m.fileNewMap, err = gtk.MenuItemNewWithLabel("New Mapping") if err != nil { log.Fatal("Unable to create fileNewPlat:", err) } m.fileOpen, err = gtk.MenuItemNewWithLabel("Open") if err != nil { log.Fatal("Unable to create fileOpen:", err) } m.fileSave, err = gtk.MenuItemNewWithLabel("Save") if err != nil { log.Fatal("Unable to create fileSave:", err) } m.fileSaveAs, err = gtk.MenuItemNewWithLabel("Save As") if err != nil { log.Fatal("Unable to create fileSaveAs:", err) } m.fileClose, err = gtk.MenuItemNewWithLabel("Close") if err != nil { log.Fatal("Unable to create fileClose:", err) } m.fileQuit, err = gtk.MenuItemNewWithLabel("Quit") if err != nil { log.Fatal("Unable to create fileQuit:", err) } m.menuFile.Append(m.fileNewSg) m.menuFile.Append(m.fileNewLib) m.menuFile.Append(m.fileNewPlat) m.menuFile.Append(m.fileNewMap) x, _ := gtk.SeparatorMenuItemNew() m.menuFile.Append(x) m.menuFile.Append(m.fileOpen) m.menuFile.Append(m.fileSave) m.menuFile.Append(m.fileSaveAs) x, _ = gtk.SeparatorMenuItemNew() m.menuFile.Append(x) m.menuFile.Append(m.fileClose) x, _ = gtk.SeparatorMenuItemNew() m.menuFile.Append(x) m.menuFile.Append(m.fileQuit) m.filemenu.SetSubmenu(m.menuFile) m.menubar.Append(m.filemenu) m.fileQuit.Connect("activate", func() { gtk.MainQuit() }) m.menuEdit, err = gtk.MenuNew() if err != nil { log.Fatal("Unable to create menuEdit:", err) } m.editmenu, err = gtk.MenuItemNewWithMnemonic("_Edit") if err != nil { log.Fatal("Unable to create editmenu:", err) } m.editUndo, err = gtk.MenuItemNewWithMnemonic("_Undo") if err != nil { log.Fatal("Unable to create editUndo:", err) } m.editRedo, err = gtk.MenuItemNewWithMnemonic("_Redo") if err != nil { log.Fatal("Unable to create editRedo:", err) } m.editNew, err = gtk.MenuItemNewWithMnemonic("_New Element") if err != nil { log.Fatal("Unable to create editNew:", err) } m.editEdit, err = gtk.MenuItemNewWithMnemonic("_Edit") if err != nil { log.Fatal("Unable to create editEdit:", err) } m.editCopy, err = gtk.MenuItemNewWithMnemonic("_Copy") if err != nil { log.Fatal("Unable to create editCopy:", err) } m.editDelete, err = gtk.MenuItemNewWithMnemonic("_Delete") if err != nil { log.Fatal("Unable to create editDelete:", err) } m.editPaste, err = gtk.MenuItemNewWithMnemonic("_Paste") if err != nil { log.Fatal("Unable to create editPaste:", err) } m.menuEdit.Append(m.editUndo) m.menuEdit.Append(m.editRedo) x, _ = gtk.SeparatorMenuItemNew() m.menuEdit.Append(x) m.menuEdit.Append(m.editNew) m.menuEdit.Append(m.editEdit) m.menuEdit.Append(m.editDelete) x, _ = gtk.SeparatorMenuItemNew() m.menuEdit.Append(x) m.menuEdit.Append(m.editCopy) m.menuEdit.Append(m.editPaste) m.editmenu.SetSubmenu(m.menuEdit) m.menubar.Append(m.editmenu) m.menuView, err = gtk.MenuNew() if err != nil { log.Fatal("Unable to create menuView:", err) } m.viewmenu, err = gtk.MenuItemNewWithMnemonic("_View") if err != nil { log.Fatal("Unable to create viewmenu:", err) } m.viewExpand, err = gtk.MenuItemNewWithMnemonic("E_xpand") if err != nil { log.Fatal("Unable to create viewExpand:", err) } m.viewCollapse, err = gtk.MenuItemNewWithMnemonic("Co_llapse") if err != nil { log.Fatal("Unable to create viewCollapse:", err) } m.menuView.Append(m.viewExpand) m.menuView.Append(m.viewCollapse) m.viewmenu.SetSubmenu(m.menuView) m.menubar.Append(m.viewmenu) m.menuAbout, err = gtk.MenuNew() if err != nil { log.Fatal("Unable to create menuEdit:", err) } m.aboutmenu, err = gtk.MenuItemNewWithLabel("About") if err != nil { log.Fatal("Unable to create filemenu:", err) } m.aboutAbout, err = gtk.MenuItemNewWithLabel("About...") if err != nil { log.Fatal("Unable to create filemenu:", err) } m.aboutHelp, err = gtk.MenuItemNewWithLabel("Help") if err != nil { log.Fatal("Unable to create filemenu:", err) } m.menuAbout.Append(m.aboutAbout) x, _ = gtk.SeparatorMenuItemNew() m.menuAbout.Append(x) m.menuAbout.Append(m.aboutHelp) m.aboutmenu.SetSubmenu(m.menuAbout) m.menubar.Append(m.aboutmenu) log.Println("GoAppMenu initialized") }