func main() { FreeConsole() gtk.Init(nil) screenHeight := gdk.ScreenHeight() screenWidth := gdk.ScreenWidth() window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetTitle("mgc") window.SetIconName("gtk-about") window.Connect("destroy", func() { gtk.MainQuit() }) vbox := gtk.NewVBox(false, 0) menubar := gtk.NewMenuBar() vbox.PackStart(menubar, false, false, 0) menu := gtk.NewMenuItemWithMnemonic("_File") menubar.Append(menu) submenu := gtk.NewMenu() menu.SetSubmenu(submenu) menuitem := gtk.NewMenuItemWithMnemonic("E_xit") menuitem.Connect("activate", func() { gtk.MainQuit() }) submenu.Append(menuitem) hpaned := gtk.NewHPaned() leftFrame := gtk.NewFrame("") rightFrame := gtk.NewFrame("") leftLabel := gtk.NewLabel("Left") rightLabel := gtk.NewLabel("Right") leftFrame.Add(leftLabel) rightFrame.Add(rightLabel) hpaned.Pack1(leftFrame, true, false) hpaned.Pack2(rightFrame, true, false) vbox.Add(hpaned) window.Add(vbox) window.SetSizeRequest(screenWidth/4*3, screenHeight/4*3) window.ShowAll() gtk.Main() }
func main() { gtk.Init(&os.Args) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetTitle("GTK Notebook") window.Connect("destroy", gtk.MainQuit) notebook := gtk.NewNotebook() for n := 1; n <= 10; n++ { page := gtk.NewFrame("demo" + strconv.Itoa(n)) notebook.AppendPage(page, gtk.NewLabel("demo"+strconv.Itoa(n))) vbox := gtk.NewHBox(false, 1) prev := gtk.NewButtonWithLabel("go prev") prev.Clicked(func() { notebook.PrevPage() }) vbox.Add(prev) next := gtk.NewButtonWithLabel("go next") next.Clicked(func() { notebook.NextPage() }) vbox.Add(next) page.Add(vbox) } window.Add(notebook) window.SetSizeRequest(400, 200) window.ShowAll() gtk.Main() }
func CreateActivatableDemo(vbox *gtk.VBox) { action_entry := gtk.NewAction("ActionEntry", "Button attached to Action", "", gtk.STOCK_INFO) action_entry.Connect("activate", func() { fmt.Println("Action clicked") }) frame1 := gtk.NewFrame("GtkActivatable interface demonstration") frame1.SetBorderWidth(5) hbox2 := gtk.NewHBox(false, 5) hbox2.SetSizeRequest(400, 50) hbox2.SetBorderWidth(5) button1 := gtk.NewButton() button1.SetSizeRequest(250, 0) button1.SetRelatedAction(action_entry) hbox2.PackStart(button1, false, false, 0) hbox2.PackStart(gtk.NewVSeparator(), false, false, 0) button2 := gtk.NewButtonWithLabel("Hide Action") button2.SetSizeRequest(150, 0) button2.Connect("clicked", func() { action_entry.SetVisible(false) fmt.Println("Hide Action") }) hbox2.PackStart(button2, false, false, 0) button3 := gtk.NewButtonWithLabel("Unhide Action") button3.SetSizeRequest(150, 0) button3.Connect("clicked", func() { action_entry.SetVisible(true) fmt.Println("Show Action") }) hbox2.PackStart(button3, false, false, 0) frame1.Add(hbox2) vbox.PackStart(frame1, false, true, 0) }
// KeyboardHandler handle events from keyboard func KeyboardHandler(event chan *keyhandler.KeyPressEvent, window *gtk.Window, repl *gtk.Entry, URLEntry *gtk.Entry, notebook *gtk.Notebook) { for { kpe := <-event log.Printf("[DEBUG] KeyPressEvent : %v", kpe) gdk.ThreadsEnter() switch kpe.KeyVal { case gdk.KEY_Escape: repl.SetVisible(false) break case gdk.KEY_colon: if !repl.IsFocus() && !URLEntry.IsFocus() { repl.SetVisible(true) repl.GrabFocus() repl.SetText(":") repl.SetPosition(1) } break case gdk.KEY_Return: if repl.IsFocus() { text := repl.GetText() log.Printf("Repl text : %s", text) if len(text) > 0 { command.Run(text, window, "") } repl.SetText("") } break // case gdk.KEY_w: // if kpe.GetModifier() == keyhandler.CTRL { // log.Printf("[DEBUG] nb : %d", notebook.GetNPages()) // notebook.RemovePage(notebook.GetCurrentPage()) // log.Printf("[DEBUG] nb : %d", notebook.GetNPages()) // } // break case gdk.KEY_t: if kpe.GetModifier() == keyhandler.CTRL { log.Printf("[DEBUG] New tab") log.Printf("[DEBUG] nb : %d", notebook.GetNPages()) log.Printf("[DEBUG] current : %d", notebook.GetCurrentPage()) tab := ui.NewBrowser("") page := gtk.NewFrame("") //fmt.Sprintf("%d", notebook.GetNPages()+1)) notebook.AppendPage(page, gtk.NewLabel("New tab")) page.Add(tab.VBox) log.Printf("[DEBUG] nb : %d", notebook.GetNPages()) notebook.ShowAll() } break case gdk.KEY_q: if kpe.GetModifier() == keyhandler.CTRL { gtk.MainQuit() } break } gdk.ThreadsLeave() } }
// Constructor function // 1. Create Components // 2. Setup Layout // 3. Event - Callback func (this *UI) Construct() { defer catch() // 1. Creating Components // ---- ---- ---- ---- ---- ---- ---- ---- // Create the Main Window // Set title & size this.Win = gtk.NewWindow(gtk.WINDOW_TOPLEVEL) if this.Win == nil { panic("UI::Construct() : Window allocation Failed") } window := this.Win // Window aliasin window.SetTitle("0x_Calculator") // SetTitle this.Calc_Frame = gtk.NewFrame("Calculation") this.Nums_Frame = gtk.NewFrame("Numbers") this.Oper_Frame = gtk.NewFrame("Operation") this.Lbl_prev = gtk.NewLabel("(Previous)") this.Lbl_lhs = gtk.NewLabel("(LHS)") this.Lbl_rhs = gtk.NewLabel("(RHS)") this.Btn_map = make(map[string]*gtk.Button) this.Ch_Event = make(chan interface{}) this.csr = NONE // There is no operator this.radix = CVT_DEC // Decimal radix format this.op_code = OP_XXX // Nothing // 2. Setup Layout // ---- ---- ---- ---- ---- ---- ---- ---- this.init_Calc() this.init_Nums() this.init_Oper() this.put_frames() // 3. Event - Callback connection // ---- ---- ---- ---- ---- ---- ---- ---- this.init_Events() // 4. Left overs // ---- ---- ---- ---- ---- ---- ---- ---- window.SetSizeRequest(UI_Width, UI_Height) window.ShowAll() }
// ShortTime creates a GTK fullscreen window for the shorttime clients. // No username/password required, only click 'start' button to log in func ShortTime(client string, minutes int) (user string) { // Inital window configuration window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) defer window.Destroy() window.Fullscreen() window.SetKeepAbove(true) window.SetTitle("Mycel Login") // Build GUI frame := gtk.NewFrame("Logg deg på " + client) frame.SetLabelAlign(0.5, 0.5) var imageLoader *gdkpixbuf.Loader imageLoader, _ = gdkpixbuf.NewLoaderWithMimeType("image/png") imageLoader.Write(logo_png()) imageLoader.Close() logo := gtk.NewImageFromPixbuf(imageLoader.GetPixbuf()) info := gtk.NewLabel("") info.SetMarkup("<span foreground='red'>Dette er en korttidsmaskin\nMaks " + strconv.Itoa(minutes) + " minutter!</span>") button := gtk.NewButtonWithLabel("\nStart\n") vbox := gtk.NewVBox(false, 20) vbox.SetBorderWidth(20) vbox.Add(logo) vbox.Add(info) vbox.Add(button) frame.Add(vbox) center := gtk.NewAlignment(0.5, 0.5, 0, 0) center.Add(frame) window.Add(center) // Connect GUI event signals to function callbacks button.Connect("clicked", func() { gtk.MainQuit() }) window.Connect("delete-event", func() bool { return true }) window.ShowAll() gtk.Main() return "Anonym" }
func (g *Gui) buildList(vbox *gtk.VBox) { frame := gtk.NewFrame("Device List") framebox := gtk.NewVBox(false, 1) frame.Add(framebox) vbox.Add(frame) g.Status = gtk.NewStatusbar() vbox.PackStart(g.Status, false, false, 0) g.Store = gtk.NewListStore(glib.G_TYPE_STRING, glib.G_TYPE_STRING) treeview := gtk.NewTreeView() framebox.Add(treeview) treeview.SetModel(g.Store) treeview.AppendColumn(gtk.NewTreeViewColumnWithAttributes("Device", gtk.NewCellRendererText(), "text", 0)) treeview.AppendColumn(gtk.NewTreeViewColumnWithAttributes("Name", gtk.NewCellRendererText(), "text", 1)) treeview.GetSelection().SetMode(gtk.SELECTION_SINGLE) controls := gtk.NewHBox(true, 0) g.Start = gtk.NewButtonWithLabel("Start Sync") g.Start.Clicked(func() { var iter gtk.TreeIter var device glib.GValue selection := treeview.GetSelection() if selection.CountSelectedRows() > 0 { selection.GetSelected(&iter) g.Store.GetValue(&iter, 0, &device) MainGui.notify("Start Writing On: " + device.GetString()) doWrite(device.GetString()) } else { MainGui.notify("No Active Selection") } }) controls.Add(g.Start) g.Recheck = gtk.NewButtonWithLabel("Rescan") g.Recheck.Clicked(func() { devices := SearchValid() MainGui.Store.Clear() for _, x := range devices { MainGui.appendItem("/dev/hidraw"+strconv.FormatUint(x.SeqNum(), 10), x.SysAttrValue("product")) } MainGui.notify("Scanning Done") }) controls.Add(g.Recheck) framebox.PackStart(controls, false, false, 0) }
func newBiomeEditFrame() *biomeEditFrame { frm := &biomeEditFrame{ Frame: gtk.NewFrame("Edit Biome"), applyBtn: gtk.NewButtonWithLabel("Apply"), idInput: gtk.NewEntry(), snowLineInput: gtk.NewEntry(), nameInput: gtk.NewEntry(), colorInput: gtk.NewColorButton(), } frm.idInput.SetSizeRequest(40, -1) frm.snowLineInput.SetSizeRequest(40, -1) frm.idInput.Connect("changed", frm.unlockApply) frm.nameInput.Connect("changed", frm.unlockApply) frm.snowLineInput.Connect("changed", frm.unlockApply) frm.applyBtn.SetSensitive(false) vbox := gtk.NewVBox(false, 0) hbox := gtk.NewHBox(false, 0) frm.idInput.SetTooltipText("The data value of the Biome [0-255]") frm.snowLineInput.SetTooltipText(fmt.Sprintf("Height (Y coordinate) at which snowfall starts (-1 or %d for no snowfall, 0 for always snowy)", mcmap.ChunkSizeY)) hbox.PackStart(gtk.NewLabel("Color:"), false, false, 0) hbox.PackStart(frm.colorInput, false, false, 3) hbox.PackStart(gtk.NewLabel("ID:"), false, false, 0) hbox.PackStart(frm.idInput, false, false, 3) hbox.PackStart(gtk.NewLabel("Snowline:"), false, false, 0) hbox.PackStart(frm.snowLineInput, false, false, 3) hbox.PackStart(gtk.NewLabel("Name:"), false, false, 0) hbox.PackStart(frm.nameInput, true, true, 3) vbox.PackStart(hbox, false, false, 0) vbox.PackStart(frm.applyBtn, false, false, 3) frm.Add(vbox) frm.applyBtn.Connect("clicked", frm.doApply) return frm }
func main() { var menuitem *gtk.MenuItem gtk.Init(nil) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetPosition(gtk.WIN_POS_CENTER) window.SetTitle("GTK Go!") window.SetIconName("gtk-dialog-info") window.Connect("destroy", func(ctx *glib.CallbackContext) { println("got destroy!", ctx.Data().(string)) gtk.MainQuit() }, "foo") //-------------------------------------------------------- // GtkVBox //-------------------------------------------------------- vbox := gtk.NewVBox(false, 1) //-------------------------------------------------------- // GtkMenuBar //-------------------------------------------------------- menubar := gtk.NewMenuBar() vbox.PackStart(menubar, false, false, 0) //-------------------------------------------------------- // GtkVPaned //-------------------------------------------------------- vpaned := gtk.NewVPaned() vbox.Add(vpaned) //-------------------------------------------------------- // GtkFrame //-------------------------------------------------------- frame1 := gtk.NewFrame("Demo") framebox1 := gtk.NewVBox(false, 1) frame1.Add(framebox1) frame2 := gtk.NewFrame("Demo") framebox2 := gtk.NewVBox(false, 1) frame2.Add(framebox2) vpaned.Pack1(frame1, false, false) vpaned.Pack2(frame2, false, false) //-------------------------------------------------------- // GtkImage //-------------------------------------------------------- dir, _ := path.Split(os.Args[0]) imagefile := path.Join(dir, "../../data/go-gtk-logo.png") label := gtk.NewLabel("Go Binding for GTK") label.ModifyFontEasy("DejaVu Serif 15") framebox1.PackStart(label, false, true, 0) //-------------------------------------------------------- // GtkEntry //-------------------------------------------------------- entry := gtk.NewEntry() entry.SetText("Hello world") framebox1.Add(entry) image := gtk.NewImageFromFile(imagefile) framebox1.Add(image) //-------------------------------------------------------- // GtkScale //-------------------------------------------------------- scale := gtk.NewHScaleWithRange(0, 100, 1) scale.Connect("value-changed", func() { println("scale:", int(scale.GetValue())) }) framebox2.Add(scale) //-------------------------------------------------------- // GtkHBox //-------------------------------------------------------- buttons := gtk.NewHBox(false, 1) //-------------------------------------------------------- // GtkButton //-------------------------------------------------------- button := gtk.NewButtonWithLabel("Button with label") button.Clicked(func() { println("button clicked:", button.GetLabel()) messagedialog := gtk.NewMessageDialog( button.GetTopLevelAsWindow(), gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, entry.GetText()) messagedialog.Response(func() { println("Dialog OK!") //-------------------------------------------------------- // GtkFileChooserDialog //-------------------------------------------------------- filechooserdialog := gtk.NewFileChooserDialog( "Choose File...", button.GetTopLevelAsWindow(), gtk.FILE_CHOOSER_ACTION_OPEN, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) filter := gtk.NewFileFilter() filter.AddPattern("*.go") filechooserdialog.AddFilter(filter) filechooserdialog.Response(func() { println(filechooserdialog.GetFilename()) filechooserdialog.Destroy() }) filechooserdialog.Run() messagedialog.Destroy() }) messagedialog.Run() }) buttons.Add(button) //-------------------------------------------------------- // GtkFontButton //-------------------------------------------------------- fontbutton := gtk.NewFontButton() fontbutton.Connect("font-set", func() { println("title:", fontbutton.GetTitle()) println("fontname:", fontbutton.GetFontName()) println("use_size:", fontbutton.GetUseSize()) println("show_size:", fontbutton.GetShowSize()) }) buttons.Add(fontbutton) framebox2.PackStart(buttons, false, false, 0) buttons = gtk.NewHBox(false, 1) //-------------------------------------------------------- // GtkToggleButton //-------------------------------------------------------- togglebutton := gtk.NewToggleButtonWithLabel("ToggleButton with label") togglebutton.Connect("toggled", func() { if togglebutton.GetActive() { togglebutton.SetLabel("ToggleButton ON!") } else { togglebutton.SetLabel("ToggleButton OFF!") } }) buttons.Add(togglebutton) //-------------------------------------------------------- // GtkCheckButton //-------------------------------------------------------- checkbutton := gtk.NewCheckButtonWithLabel("CheckButton with label") checkbutton.Connect("toggled", func() { if checkbutton.GetActive() { checkbutton.SetLabel("CheckButton CHECKED!") } else { checkbutton.SetLabel("CheckButton UNCHECKED!") } }) buttons.Add(checkbutton) //-------------------------------------------------------- // GtkRadioButton //-------------------------------------------------------- buttonbox := gtk.NewVBox(false, 1) radiofirst := gtk.NewRadioButtonWithLabel(nil, "Radio1") buttonbox.Add(radiofirst) buttonbox.Add(gtk.NewRadioButtonWithLabel(radiofirst.GetGroup(), "Radio2")) buttonbox.Add(gtk.NewRadioButtonWithLabel(radiofirst.GetGroup(), "Radio3")) buttons.Add(buttonbox) //radiobutton.SetMode(false); radiofirst.SetActive(true) framebox2.PackStart(buttons, false, false, 0) //-------------------------------------------------------- // GtkVSeparator //-------------------------------------------------------- vsep := gtk.NewVSeparator() framebox2.PackStart(vsep, false, false, 0) //-------------------------------------------------------- // GtkComboBoxEntry //-------------------------------------------------------- combos := gtk.NewHBox(false, 1) comboboxentry := gtk.NewComboBoxEntryNewText() comboboxentry.AppendText("Monkey") comboboxentry.AppendText("Tiger") comboboxentry.AppendText("Elephant") comboboxentry.Connect("changed", func() { println("value:", comboboxentry.GetActiveText()) }) combos.Add(comboboxentry) //-------------------------------------------------------- // GtkComboBox //-------------------------------------------------------- combobox := gtk.NewComboBoxNewText() combobox.AppendText("Peach") combobox.AppendText("Banana") combobox.AppendText("Apple") combobox.SetActive(1) combobox.Connect("changed", func() { println("value:", combobox.GetActiveText()) }) combos.Add(combobox) framebox2.PackStart(combos, false, false, 0) //-------------------------------------------------------- // GtkTextView //-------------------------------------------------------- swin := gtk.NewScrolledWindow(nil, nil) swin.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) swin.SetShadowType(gtk.SHADOW_IN) textview := gtk.NewTextView() var start, end gtk.TextIter buffer := textview.GetBuffer() buffer.GetStartIter(&start) buffer.Insert(&start, "Hello ") buffer.GetEndIter(&end) buffer.Insert(&end, "World!") tag := buffer.CreateTag("bold", map[string]string{ "background": "#FF0000", "weight": "700"}) buffer.GetStartIter(&start) buffer.GetEndIter(&end) buffer.ApplyTag(tag, &start, &end) swin.Add(textview) framebox2.Add(swin) buffer.Connect("changed", func() { println("changed") }) //-------------------------------------------------------- // GtkMenuItem //-------------------------------------------------------- cascademenu := gtk.NewMenuItemWithMnemonic("_File") menubar.Append(cascademenu) submenu := gtk.NewMenu() cascademenu.SetSubmenu(submenu) menuitem = gtk.NewMenuItemWithMnemonic("E_xit") menuitem.Connect("activate", func() { gtk.MainQuit() }) submenu.Append(menuitem) cascademenu = gtk.NewMenuItemWithMnemonic("_View") menubar.Append(cascademenu) submenu = gtk.NewMenu() cascademenu.SetSubmenu(submenu) checkmenuitem := gtk.NewCheckMenuItemWithMnemonic("_Disable") checkmenuitem.Connect("activate", func() { vpaned.SetSensitive(!checkmenuitem.GetActive()) }) submenu.Append(checkmenuitem) menuitem = gtk.NewMenuItemWithMnemonic("_Font") menuitem.Connect("activate", func() { fsd := gtk.NewFontSelectionDialog("Font") fsd.SetFontName(fontbutton.GetFontName()) fsd.Response(func() { println(fsd.GetFontName()) fontbutton.SetFontName(fsd.GetFontName()) fsd.Destroy() }) fsd.SetTransientFor(window) fsd.Run() }) submenu.Append(menuitem) cascademenu = gtk.NewMenuItemWithMnemonic("_Help") menubar.Append(cascademenu) submenu = gtk.NewMenu() cascademenu.SetSubmenu(submenu) menuitem = gtk.NewMenuItemWithMnemonic("_About") menuitem.Connect("activate", func() { dialog := gtk.NewAboutDialog() dialog.SetName("Go-Gtk Demo!") dialog.SetProgramName("demo") dialog.SetAuthors(authors()) dir, _ := path.Split(os.Args[0]) imagefile := path.Join(dir, "../../data/mattn-logo.png") pixbuf, _ := gdkpixbuf.NewFromFile(imagefile) dialog.SetLogo(pixbuf) dialog.SetLicense("The library is available under the same terms and conditions as the Go, the BSD style license, and the LGPL (Lesser GNU Public License). The idea is that if you can use Go (and Gtk) in a project, you should also be able to use go-gtk.") dialog.SetWrapLicense(true) dialog.Run() dialog.Destroy() }) submenu.Append(menuitem) //-------------------------------------------------------- // GtkStatusbar //-------------------------------------------------------- statusbar := gtk.NewStatusbar() context_id := statusbar.GetContextId("go-gtk") statusbar.Push(context_id, "GTK binding for Go!") framebox2.PackStart(statusbar, false, false, 0) //-------------------------------------------------------- // Event //-------------------------------------------------------- window.Add(vbox) window.SetSizeRequest(600, 600) window.ShowAll() gtk.Main() }
func main() { flag.Parse() common.SetDefaultGtkTheme() runtime.GOMAXPROCS(runtime.NumCPU()) rclient = &remoton.Client{Prefix: "/remoton", TLSConfig: &tls.Config{}} sigs := make(chan os.Signal, 1) signal.Notify(sigs, syscall.SIGHUP, syscall.SIGINT, syscall.SIGABRT, syscall.SIGKILL, syscall.SIGTERM) go func() { <-sigs chatSrv.Terminate() tunnelSrv.Terminate() }() gtk.Init(nil) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetPosition(gtk.WIN_POS_CENTER) window.SetTitle("REMOTON SUPPORT") window.Connect("destroy", func() { gtk.MainQuit() chatSrv.Terminate() tunnelSrv.Terminate() }) window.SetIcon(common.GetIconGdkPixbuf()) appLayout := gtk.NewVBox(false, 1) menu := gtk.NewMenuBar() appLayout.Add(menu) cascademenu := gtk.NewMenuItemWithMnemonic("_Help") menu.Append(cascademenu) submenu := gtk.NewMenu() cascademenu.SetSubmenu(submenu) menuitem := gtk.NewMenuItemWithMnemonic("_About") menuitem.Connect("activate", func() { dialog := common.GtkAboutDialog() dialog.SetProgramName("Support Desktop") dialog.Run() dialog.Destroy() }) submenu.Append(menuitem) hpaned := gtk.NewHPaned() appLayout.Add(hpaned) //--- //CHAT //--- frameChat := gtk.NewFrame("Chat") chatBox := gtk.NewVBox(false, 1) frameChat.Add(chatBox) swinChat := gtk.NewScrolledWindow(nil, nil) chatHistory := gtk.NewTextView() swinChat.Add(chatHistory) chatEntry := gtk.NewEntry() chatEntry.Connect("key-press-event", func(ctx *glib.CallbackContext) { arg := ctx.Args(0) event := *(**gdk.EventKey)(unsafe.Pointer(&arg)) if event.Keyval == gdk.KEY_Return { msgToSend := chatEntry.GetText() chatSrv.Send(msgToSend) chatHistorySend(chatHistory, msgToSend) chatEntry.SetText("") } }) chatSrv.OnRecv(func(msg string) { log.Println(msg) chatHistoryRecv(chatHistory, msg) }) chatBox.Add(chatEntry) chatBox.Add(swinChat) //--- //CONTROL //--- frameControl := gtk.NewFrame("Control") controlBox := gtk.NewVBox(false, 1) frameControl.Add(controlBox) controlBox.Add(gtk.NewLabel("Machine ID")) machineIDEntry := gtk.NewEntry() controlBox.Add(machineIDEntry) controlBox.Add(gtk.NewLabel("Machine AUTH")) machineAuthEntry := gtk.NewEntry() controlBox.Add(machineAuthEntry) controlBox.Add(gtk.NewLabel("Server")) serverEntry := gtk.NewEntry() serverEntry.SetText("localhost:9934") if os.Getenv("REMOTON_SERVER") != "" { serverEntry.SetText(os.Getenv("REMOTON_SERVER")) serverEntry.SetEditable(false) } controlBox.Add(serverEntry) btnCert := gtk.NewFileChooserButton("Cert", gtk.FILE_CHOOSER_ACTION_OPEN) controlBox.Add(btnCert) btn := gtk.NewButtonWithLabel("Connect") started := false btn.Clicked(func() { if *insecure { rclient.TLSConfig.InsecureSkipVerify = true } else { certPool, err := common.GetRootCAFromFile(btnCert.GetFilename()) if err != nil { dialogError(window, err) return } rclient.TLSConfig.RootCAs = certPool } session := &remoton.SessionClient{Client: rclient, ID: machineIDEntry.GetText(), APIURL: "https://" + serverEntry.GetText()} if !started { err := chatSrv.Start(session) if err != nil { dialogError(btn.GetTopLevelAsWindow(), err) return } err = tunnelSrv.Start(session, machineAuthEntry.GetText()) if err != nil { dialogError(btn.GetTopLevelAsWindow(), err) return } btn.SetLabel("Disconnect") started = true } else { chatSrv.Terminate() tunnelSrv.Terminate() btn.SetLabel("Connect") started = false } }) controlBox.Add(btn) hpaned.Pack1(frameControl, false, false) hpaned.Pack2(frameChat, false, false) window.Add(appLayout) window.ShowAll() gtk.Main() }
// Login creates a GTK fullscreen window where users can log inn. // It returns when a user successfully authenticates. func Login(hostAPI, client string, extraMinutes, agel, ageh int) (user string, minutes int, userType string) { // Inital window configuration window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) defer window.Destroy() window.Fullscreen() window.SetKeepAbove(true) window.SetTitle("Mycel Login") // Build GUI frame := gtk.NewFrame("Logg deg på " + client) frame.SetLabelAlign(0.5, 0.5) var imageLoader *gdkpixbuf.Loader imageLoader, _ = gdkpixbuf.NewLoaderWithMimeType("image/png") imageLoader.Write(logo_png()) imageLoader.Close() logo := gtk.NewImageFromPixbuf(imageLoader.GetPixbuf()) button := gtk.NewButtonWithLabel("Logg inn") userlabel := gtk.NewLabel("Lånenummer/brukernavn") pinlabel := gtk.NewLabel("PIN-kode/passord") table := gtk.NewTable(3, 2, false) userentry := gtk.NewEntry() userentry.SetMaxLength(10) userentry.SetSizeRequest(150, 23) pinentry := gtk.NewEntry() pinentry.SetVisibility(false) pinentry.SetMaxLength(10) table.Attach(userlabel, 0, 1, 0, 1, gtk.FILL, gtk.FILL, 7, 5) table.Attach(userentry, 1, 2, 0, 1, gtk.FILL, gtk.FILL, 7, 5) table.Attach(pinlabel, 0, 1, 1, 2, gtk.FILL, gtk.FILL, 7, 5) table.Attach(pinentry, 1, 2, 1, 2, gtk.FILL, gtk.FILL, 7, 5) table.Attach(button, 1, 2, 2, 3, gtk.FILL, gtk.FILL, 7, 5) error := gtk.NewLabel("") vbox := gtk.NewVBox(false, 20) vbox.SetBorderWidth(20) vbox.Add(logo) vbox.Add(table) vbox.Add(error) frame.Add(vbox) center := gtk.NewAlignment(0.5, 0.5, 0, 0) center.Add(frame) window.Add(center) // Functions to validate and check responses checkResponse := func(username, password string) { user, err := authenticate(hostAPI, username, password) if err != nil { log.Println("authentication API call failed: ", err) //error.SetMarkup("<span foreground='red'>Fikk ikke kontakt med server, vennligst prøv igjen!</span>") error.SetMarkup("<span foreground='red'>Feil lånenummer/brukernavn eller PIN/passord</span>") return } if !user.Authenticated { error.SetMarkup("<span foreground='red'>" + user.Message + "</span>") return } if user.Minutes+extraMinutes <= 0 && user.Type != "G" { error.SetMarkup("<span foreground='red'>Beklager, du har brukt opp kvoten din for i dag!</span>") return } if user.Type == "G" && user.Minutes <= 0 { error.SetMarkup("<span foreground='red'>Beklager, du har brukt opp kvoten din for i dag!</span>") return } if user.Age < agel || user.Age > ageh { error.SetMarkup("<span foreground='red'>Denne maskinen er kun for de mellom " + strconv.Itoa(agel) + " og " + strconv.Itoa(ageh) + "</span>") return } // sucess! userType = user.Type minutes = user.Minutes // set printer billing //LNUMMER cmd := exec.Command("/bin/sh", "-c", "/usr/bin/lpoptions -p publikumsskriver -o job-billing="+username) output, err := cmd.CombinedOutput() if err != nil { log.Println("failed to set printer billing options: ", string(output)) } gtk.MainQuit() return } validate := func(ctx *glib.CallbackContext) { arg := ctx.Args(0) kev := *(**gdk.EventKey)(unsafe.Pointer(&arg)) username := userentry.GetText() password := pinentry.GetText() if kev.Keyval == gdk.KEY_Return { if username == "" && password == "" { return } if username != "" && password == "" { pinentry.GrabFocus() return } if password != "" && username == "" { userentry.GrabFocus() return } checkResponse(username, password) return } } // Connect GUI event signals to function callbacks pinentry.Connect("key-press-event", validate) userentry.Connect("key-press-event", validate) button.Connect("clicked", func() { username := userentry.GetText() password := pinentry.GetText() if (username == "") || (password == "") { error.SetMarkup("<span foreground='red'>Skriv inn ditt lånenummer og PIN-kode</span>") userentry.GrabFocus() return } checkResponse(username, password) }) window.Connect("delete-event", func() bool { return true }) window.ShowAll() gtk.Main() user = userentry.GetText() return }
func win_start() { defer catch() // Panic Handler // Initiate GTK gtk.Init(&os.Args) // Window Setup // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- // Create the Main Window // Set title & size win := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) win.SetTitle("0x_Calc") // on Exit -> Quit the program win.Connect("destroy", gtk.MainQuit) box_win := gtk.NewVBox(Homogeneous, Default_Spacing) // Menu Bar // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- /* // Vertical Box for menu box_menu := gtk.NewVBox(false, 1) // MenuBar - menu mb_menu := gtk.NewMenuBar() box_menu.PackStart(mb_menu, false, false, 0) // Menu Items // [File] mi_file := gtk.NewMenuItemWithMnemonic("_File2") mb_menu.Append(mi_file) // Submenu for [File] subm_file := gtk.NewMenu() mi_file.SetSubmenu(subm_file) mi_exit := gtk.NewMenuItemWithMnemonic("_Exit2") mb_menu.Append(mi_exit) mi_exit.Connect("activate", func() { gtk.MainQuit() }) // Add the menubox win.Add(box_menu) */ // Frame - Calculation // This frame contains radix(16,10,8) and result labels // ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== fm_calc := gtk.NewFrame("Calculation") // (inner) Box of Calculation fm_calc_box := gtk.NewHBox(false, 1) fm_calc.Add(fm_calc_box) // Box for Radix Buttons. box_rdx := gtk.NewVBox(false, 1) btn_hex := button("Hex") // [Hex] : Hexadecimal btn_dec := gtk.NewButtonWithLabel("Dec") // [Dec] : Decimal btn_oct := gtk.NewButtonWithLabel("Oct") // [Oct] : Octal box_rdx.Add(btn_hex) box_rdx.Add(btn_dec) box_rdx.Add(btn_oct) // Box for Result Labels box_labels := gtk.NewVBox(false, 1) lbl_prev := gtk.NewLabel("Previous Result") // Previous Calculation lbl_late := gtk.NewLabel("Current Result") // Latest Calculaltion box_labels.Add(lbl_prev) box_labels.Add(lbl_late) // Add both Boxes (Radix & Result) to frame box fm_calc_box.Add(box_rdx) fm_calc_box.Add(box_labels) // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- // Frame - Numbers // This frame contains number buttons for calculation // Hexadecimal : 0 ~ 9, A ~ F // Decimal : 0 ~ 9 // Octal : 0 ~ 7 // ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== fm_nums := gtk.NewFrame("Numbers") // (inner) Box of Numbers fm_nums_box := gtk.NewVBox(false, 1) fm_nums.Add(fm_nums_box) // Table Initialization // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- tbl_nums := gtk.NewTable(5, 4, false) // Jagged slice of buttons // nums := [][]*gtk.Button{} // Button for Number num := [17]*gtk.Button{ // 0~7 : Oct button("0"), button("1"), button("2"), button("3"), button("4"), button("5"), button("6"), button("7"), // 0~9 : Dec button("8"), button("9"), // 0~F : Hex button("A"), button("B"), button("C"), button("D"), button("E"), button("F"), } // Place buttons into the table tbl_nums.Attach(num[0], 0, 1, 3, 4, gtk.FILL, gtk.FILL, 1, 1) // 0 tbl_nums.Attach(num[1], 0, 1, 2, 3, gtk.FILL, gtk.FILL, 1, 1) // 1 tbl_nums.Attach(num[2], 1, 2, 2, 3, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[3], 2, 3, 2, 3, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[4], 0, 1, 1, 2, gtk.FILL, gtk.FILL, 1, 1) // 4 tbl_nums.Attach(num[5], 1, 2, 1, 2, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[6], 2, 3, 1, 2, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[7], 0, 1, 0, 1, gtk.FILL, gtk.FILL, 1, 1) // 7 tbl_nums.Attach(num[8], 1, 2, 0, 1, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[9], 2, 3, 0, 1, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[10], 3, 4, 2, 3, gtk.FILL, gtk.FILL, 1, 1) // A tbl_nums.Attach(num[11], 4, 5, 2, 3, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[12], 3, 4, 1, 2, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[13], 4, 5, 1, 2, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[14], 3, 4, 0, 1, gtk.FILL, gtk.FILL, 1, 1) tbl_nums.Attach(num[15], 4, 5, 0, 1, gtk.FILL, gtk.FILL, 1, 1) // F // Add the table to box fm_nums_box.Add(tbl_nums) // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- // Frame - Operations // This frame contains operations. // ADD, SUB, MUL, DIV, MOD // AND, OR, XOR, NOT // LSHFT, RSHFT // ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== ==== fm_oper := gtk.NewFrame("Operations") // (inner) Box of Operations fm_oper_box := gtk.NewVBox(false, 1) fm_oper.Add(fm_oper_box) tbl_opers := gtk.NewTable(5, 3, false) // Operation Buttons // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- // Button for Number // 'oper' is Jagged slice of buttons oper := [][]*gtk.Button{} // slice of Arithmetic oper_arit := []*gtk.Button{ button("ADD"), button("SUB"), button("MUL"), button("DIV"), button("MOD")} // slice of Bitwise oper_bit := []*gtk.Button{ button("AND"), button("OR"), button("XOR"), button("NOT")} // slice of Bit Shift oper_shft := []*gtk.Button{ button("LSHIFT"), button("RSHIFT")} // Compose the jagged slice oper = append(oper, oper_arit) oper = append(oper, oper_bit) oper = append(oper, oper_shft) // Iterate jagged slice and place them into the table for r, btn_slice := range oper { // r : row // btn_slice : slice of buttons for c, btn := range btn_slice { // c : column // btn == btn_slice[c] == oper[row][col] // Place the button to table tbl_opers.Attach(btn, uint(c), uint(c)+1, uint(r), uint(r)+1, gtk.FILL, gtk.FILL, 1, 1) } } fm_oper_box.Add(tbl_opers) // Place buttons into the table // tbl_opers.Attach(oper[0], 0, 1, 3, 4, gtk.FILL, gtk.FILL, 5, 1) // 0 // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- // Frame Positionings // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- vpan1 := gtk.NewVPaned() vpan1.Pack1(fm_calc, No_Resize, No_Shrink) hpan1 := gtk.NewHPaned() hpan1.Pack1(fm_nums, No_Resize, No_Shrink) hpan1.Pack2(fm_oper, No_Resize, No_Shrink) vpan1.Pack2(hpan1, No_Resize, No_Shrink) box_win.Add(vpan1) // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- fmt.Println("UI Over?") win.Add(box_win) win.SetSizeRequest(UI_Width, UI_Height) win.ShowAll() // Start the UI gtk.Main() }
func main() { gtk.Init(nil) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetPosition(gtk.WIN_POS_CENTER) window.SetTitle("GTK Go!") window.SetIconName("gtk-dialog-info") window.Connect("destroy", func(ctx *glib.CallbackContext) { fmt.Println("got destroy!", ctx.Data().(string)) gtk.MainQuit() }, "foo") //-------------------------------------------------------- // GtkVBox //-------------------------------------------------------- vbox := gtk.NewVBox(false, 1) //-------------------------------------------------------- // GtkMenuBar //-------------------------------------------------------- menubar := gtk.NewMenuBar() vbox.PackStart(menubar, false, false, 0) //-------------------------------------------------------- // GtkVPaned //-------------------------------------------------------- vpaned := gtk.NewVPaned() vbox.Add(vpaned) //-------------------------------------------------------- // GtkFrame //-------------------------------------------------------- frame1 := gtk.NewFrame("Demo") framebox1 := gtk.NewVBox(false, 1) //frame2 := gtk.NewFrame("Demo") //framebox2 := gtk.NewVBox(false, 1) //frame2.Add(framebox2) frame1.Add(framebox1) vpaned.Pack1(frame1, false, false) //vpaned.Pack1(frame2, false, false) entry := gtk.NewEntry() entry.SetText("Hej") framebox1.Add(entry) //vbox.PackStart(menubar, false, false, 0) imagefile := "texy1.png" image := gtk.NewImageFromFile(imagefile) framebox1.Add(image) button := gtk.NewButtonWithLabel("Calculate!") button.Clicked(func() { handlestring(entry.GetText()) image.SetFromFile("temp.png") }) framebox1.Add(button) window.Add(vbox) window.SetSizeRequest(600, 600) window.ShowAll() gtk.Main() }
func main() { gtk.Init(nil) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetPosition(gtk.WIN_POS_CENTER) window.SetTitle("GoMADScan") window.SetIconName("GoMADScan-info") window.Connect("destroy", func(ctx *glib.CallbackContext) { // fmt.Println("got destroy!", ctx.Data().(string)) gtk.MainQuit() }, "") //-------------------------------------------------------- // GtkVBox //-------------------------------------------------------- vbox := gtk.NewVBox(false, 1) //-------------------------------------------------------- // GtkMenuBar //-------------------------------------------------------- menubar := gtk.NewMenuBar() vbox.PackStart(menubar, false, false, 0) //-------------------------------------------------------- // GtkVPaned //-------------------------------------------------------- vpaned := gtk.NewVPaned() vbox.Add(vpaned) //-------------------------------------------------------- // GtkFrame //-------------------------------------------------------- frame1 := gtk.NewFrame("") framebox1 := gtk.NewVBox(false, 1) frame1.Add(framebox1) frame2 := gtk.NewFrame("Column index for search (0: all columns)") framebox2 := gtk.NewVBox(false, 1) frame2.Add(framebox2) vpaned.Pack1(frame1, false, false) vpaned.Pack2(frame2, false, false) //-------------------------------------------------------- // GtkImage //-------------------------------------------------------- dir := os.Getenv("GOPATH") if dir == "" { dir = filepath.Join(os.Getenv("HOME"), "/go") } imagefile := filepath.Join(dir, "/src/github.com/carushi/GoMADScan/image/logo.png") label := gtk.NewLabel("Go-based Modification associated database scanner") label.ModifyFontEasy("DejaVu Serif 15") framebox1.PackStart(label, false, true, 0) image := gtk.NewImageFromFile(imagefile) framebox1.Add(image) //-------------------------------------------------------- // Data input and output filename //-------------------------------------------------------- arg := arguments{ 0, filepath.Join(dir, "/src/github.com/carushi/GoMADScan/data/Sample_modification_site"), filepath.Join(dir, "/src/github.com/carushi/GoMADScan/data/Ras_gene_synonym.txt"), filepath.Join(dir, "/src/github.com/carushi/GoMADScan/data/output.txt"), false, true, "\t"} //-------------------------------------------------------- // GtkScale //-------------------------------------------------------- scale := gtk.NewHScaleWithRange(0, 20, 1) scale.Connect("value-changed", func() { arg.column = int(scale.GetValue()) // fmt.Println("scale:", int(scale.GetValue())) }) framebox2.Add(scale) //-------------------------------------------------------- // InputArea //-------------------------------------------------------- ientry := gtk.NewEntry() ientry.SetText(arg.inputPath) inputs := gtk.NewHBox(false, 1) button := gtk.NewButtonWithLabel("Choose input file") button.Clicked(func() { //-------------------------------------------------------- // GtkFileChooserDialog //-------------------------------------------------------- filechooserdialog := gtk.NewFileChooserDialog( "Choose File...", button.GetTopLevelAsWindow(), gtk.FILE_CHOOSER_ACTION_OPEN, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) filter := gtk.NewFileFilter() filter.AddPattern("*") filechooserdialog.AddFilter(filter) filechooserdialog.Response(func() { arg.inputPath = filechooserdialog.GetFilename() ientry.SetText(arg.inputPath) filechooserdialog.Destroy() }) filechooserdialog.Run() }) inputs.Add(button) inputs.Add(ientry) framebox2.PackStart(inputs, false, false, 0) fentry := gtk.NewEntry() fentry.SetText(arg.filterPath) inputs = gtk.NewHBox(false, 1) button = gtk.NewButtonWithLabel("Choose keyword file") button.Clicked(func() { //-------------------------------------------------------- // GtkFileChooserDialog //-------------------------------------------------------- filechooserdialog := gtk.NewFileChooserDialog( "Choose File...", button.GetTopLevelAsWindow(), gtk.FILE_CHOOSER_ACTION_OPEN, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) filter := gtk.NewFileFilter() filter.AddPattern("*") filechooserdialog.AddFilter(filter) filechooserdialog.Response(func() { arg.filterPath = filechooserdialog.GetFilename() fentry.SetText(arg.filterPath) filechooserdialog.Destroy() }) filechooserdialog.Run() }) inputs.Add(button) inputs.Add(fentry) framebox2.PackStart(inputs, false, false, 0) oentry := gtk.NewEntry() oentry.SetText(arg.outputPath) inputs = gtk.NewHBox(false, 1) button = gtk.NewButtonWithLabel("Choose output file") button.Clicked(func() { //-------------------------------------------------------- // GtkFileChooserDialog //-------------------------------------------------------- filechooserdialog := gtk.NewFileChooserDialog( "Choose File...", button.GetTopLevelAsWindow(), gtk.FILE_CHOOSER_ACTION_OPEN, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) filter := gtk.NewFileFilter() filter.AddPattern("*") filechooserdialog.AddFilter(filter) filechooserdialog.Response(func() { arg.outputPath = filechooserdialog.GetFilename() oentry.SetText(arg.outputPath) filechooserdialog.Destroy() }) filechooserdialog.Run() }) inputs.Add(button) inputs.Add(oentry) framebox2.PackStart(inputs, false, false, 0) buttons := gtk.NewHBox(false, 1) //-------------------------------------------------------- // GtkCheckButton //-------------------------------------------------------- checkbutton := gtk.NewCheckButtonWithLabel("Case-insensitive (lower/upper)") checkbutton.Connect("toggled", func() { if checkbutton.GetActive() { arg.ignoreCase = true } else { arg.ignoreCase = false } }) buttons.Add(checkbutton) checkMatchButton := gtk.NewCheckButtonWithLabel("Partial matching / Perfect matching") checkMatchButton.Connect("toggled", func() { if checkMatchButton.GetActive() { arg.perfectMatch = false } else { arg.perfectMatch = true } }) buttons.Add(checkMatchButton) combobox := gtk.NewComboBoxText() for _, delim := range delimName { combobox.AppendText(delim) } combobox.SetActive(0) combobox.Connect("changed", func() { fmt.Println("value:", combobox.GetActiveText()) arg.delim = combobox.GetActiveText() }) buttons.Add(combobox) //-------------------------------------------------------- // GtkTextView //-------------------------------------------------------- swin := gtk.NewScrolledWindow(nil, nil) swin.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) swin.SetShadowType(gtk.SHADOW_IN) textview := gtk.NewTextView() // var start, end gtk.TextIter var end gtk.TextIter buffer := textview.GetBuffer() swin.Add(textview) //-------------------------------------------------------- // Run button //-------------------------------------------------------- runbutton := gtk.NewButtonWithLabel("Run") runbutton.Clicked(func() { arg.inputPath = ientry.GetText() arg.filterPath = fentry.GetText() arg.outputPath = oentry.GetText() num, err := getKeysearchWords(arg) buffer.GetStartIter(&end) if err != nil { log.Println(err) buffer.Insert(&end, err.Error()+"\n") } else { buffer.Insert(&end, "GoMADScan found "+strconv.Itoa(num)+ " modification sites.\nThe result is written into "+arg.outputPath+".\n") } }) buttons.Add(runbutton) framebox2.PackStart(buttons, false, false, 0) //-------------------------------------------------------- // GtkVSeparator //-------------------------------------------------------- vsep := gtk.NewVSeparator() framebox2.PackStart(vsep, false, false, 0) //-------------------------------------------------------- // GtkTextView //-------------------------------------------------------- framebox2.Add(swin) // buffer.Connect("changed", func() { // // fmt.Println("changed") // }) //-------------------------------------------------------- // GtkMenuItem //-------------------------------------------------------- cascademenu := gtk.NewMenuItemWithMnemonic("_File") menubar.Append(cascademenu) submenu := gtk.NewMenu() cascademenu.SetSubmenu(submenu) var menuitem *gtk.MenuItem menuitem = gtk.NewMenuItemWithMnemonic("_Exit") menuitem.Connect("activate", func() { gtk.MainQuit() }) submenu.Append(menuitem) cascademenu = gtk.NewMenuItemWithMnemonic("_View") menubar.Append(cascademenu) submenu = gtk.NewMenu() cascademenu.SetSubmenu(submenu) checkmenuitem := gtk.NewCheckMenuItemWithMnemonic("_Disable") checkmenuitem.Connect("activate", func() { vpaned.SetSensitive(!checkmenuitem.GetActive()) }) submenu.Append(checkmenuitem) cascademenu = gtk.NewMenuItemWithMnemonic("_Help") menubar.Append(cascademenu) submenu = gtk.NewMenu() cascademenu.SetSubmenu(submenu) menuitem = gtk.NewMenuItemWithMnemonic("_About") menuitem.Connect("activate", func() { dialog := gtk.NewAboutDialog() dialog.SetName("GoMADScan") dialog.SetProgramName("GoMADScan") dialog.SetAuthors(authors()) dialog.SetLicense("LGPL v3") dialog.SetWrapLicense(true) dialog.Run() dialog.Destroy() }) submenu.Append(menuitem) //-------------------------------------------------------- // GtkStatusbar //-------------------------------------------------------- statusbar := gtk.NewStatusbar() context_id := statusbar.GetContextId("GoMADScan v0") statusbar.Push(context_id, "Simple search GUI") framebox2.PackStart(statusbar, false, false, 0) //-------------------------------------------------------- // Event //-------------------------------------------------------- window.Add(vbox) window.SetSizeRequest(600, 600) window.ShowAll() gtk.Main() }
func main() { var menuitem *gtk.MenuItem gtk.Init(nil) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetPosition(gtk.WIN_POS_CENTER) window.SetTitle("GoBox a0.1") window.SetIconName("gtk-dialog-info") window.Connect("destroy", func(ctx *glib.CallbackContext) { println("got destroy!", ctx.Data().(string)) gtk.MainQuit() }, "foo") //-------------------------------------------------------- // GtkVBox //-------------------------------------------------------- vbox := gtk.NewVBox(false, 1) //-------------------------------------------------------- // GtkMenuBar //-------------------------------------------------------- menubar := gtk.NewMenuBar() vbox.PackStart(menubar, false, false, 0) //-------------------------------------------------------- // GtkVPaned //-------------------------------------------------------- vpaned := gtk.NewVPaned() vbox.Add(vpaned) //-------------------------------------------------------- // GtkFrame //-------------------------------------------------------- frame1 := gtk.NewFrame("Dossier et Paramètres") framebox1 := gtk.NewVBox(false, 1) frame1.Add(framebox1) frame2 := gtk.NewFrame("Fonctions") framebox2 := gtk.NewVBox(false, 1) frame2.Add(framebox2) vpaned.Pack1(frame1, false, false) vpaned.Pack2(frame2, false, false) //-------------------------------------------------------- // GtkImage //-------------------------------------------------------- /*dir, _ := path.Split(os.Args[0]) //imagefile := path.Join(dir, "../../mattn/go-gtk/data/go-gtk-logo.png") imagefile := path.Join(dir, "./go-gtk-logo.png") println(dir)*/ label := gtk.NewLabel("GoBox a0.1") label.ModifyFontEasy("DejaVu Serif 15") framebox1.PackStart(label, false, true, 0) //-------------------------------------------------------- // GtkEntry //-------------------------------------------------------- champIp := gtk.NewEntry() champIp.SetText("10.0.0.1") framebox1.Add(champIp) champPort := gtk.NewEntry() champPort.SetText("80") framebox1.Add(champPort) folder := "./" /*image := gtk.NewImageFromFile(imagefile) framebox1.Add(image)*/ buttons := gtk.NewHBox(false, 1) //-------------------------------------------------------- // GtkButton //-------------------------------------------------------- button := gtk.NewButtonWithLabel("Choisir le dossier") button.Clicked(func() { //-------------------------------------------------------- // GtkFileChooserDialog //-------------------------------------------------------- filechooserdialog := gtk.NewFileChooserDialog( "Sélectionnez le dossier ...", button.GetTopLevelAsWindow(), gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) /*filter := gtk.NewFileFilter() filter.AddPattern("*.go") filechooserdialog.AddFilter(filter)*/ filechooserdialog.Response(func() { println(filechooserdialog.GetFilename()) folder = filechooserdialog.GetFilename() + "/" filechooserdialog.Destroy() }) filechooserdialog.Run() }) buttons.Add(button) //-------------------------------------------------------- // GtkToggleButton //-------------------------------------------------------- togglebutton := gtk.NewToggleButtonWithLabel("Lancer la synchronisation") togglebutton.Connect("toggled", func() { if togglebutton.GetActive() { togglebutton.SetLabel("Synchronisation ON") //Appel fonction synchro avec paramètres println(folder, champIp.GetText(), champPort.GetText()) sync(folder, champIp.GetText(), champPort.GetText()) } else { togglebutton.SetLabel("Synchronisation OFF") } }) buttons.Add(togglebutton) framebox2.PackStart(buttons, false, false, 0) //-------------------------------------------------------- // GtkVSeparator //-------------------------------------------------------- vsep := gtk.NewVSeparator() framebox2.PackStart(vsep, false, false, 0) //-------------------------------------------------------- // GtkMenuItem //-------------------------------------------------------- cascademenu := gtk.NewMenuItemWithMnemonic("_Fichier") menubar.Append(cascademenu) submenu := gtk.NewMenu() cascademenu.SetSubmenu(submenu) menuitem = gtk.NewMenuItemWithMnemonic("Q_uitter") menuitem.Connect("activate", func() { gtk.MainQuit() }) submenu.Append(menuitem) cascademenu = gtk.NewMenuItemWithMnemonic("_Aide") menubar.Append(cascademenu) submenu = gtk.NewMenu() cascademenu.SetSubmenu(submenu) auteurs := gtk.NewEntry() auteurs.SetText("Application crée en MCS par Olivier CANO et Adrien CHAPELET") menuitem = gtk.NewMenuItemWithMnemonic("À_ propos") menuitem.Connect("activate", func() { messagedialog := gtk.NewMessageDialog( button.GetTopLevelAsWindow(), gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, auteurs.GetText()) messagedialog.Response(func() { messagedialog.Destroy() }) messagedialog.Run() }) submenu.Append(menuitem) //-------------------------------------------------------- // GtkStatusbar //-------------------------------------------------------- statusbar := gtk.NewStatusbar() context_id := statusbar.GetContextId("go-gtk") statusbar.Push(context_id, "En attente de synchronisation") framebox2.PackStart(statusbar, false, false, 0) //-------------------------------------------------------- // Event //-------------------------------------------------------- window.Add(vbox) window.SetSizeRequest(500, 300) window.ShowAll() gtk.Main() }
func main() { flag.Parse() runtime.GOMAXPROCS(runtime.NumCPU()) common.SetDefaultGtkTheme() machinePassword = uuid.New()[:4] clremoton = newClient(&remoton.Client{Prefix: "/remoton", TLSConfig: &tls.Config{}}) sigs := make(chan os.Signal, 1) signal.Notify(sigs, syscall.SIGHUP, syscall.SIGINT, syscall.SIGABRT, syscall.SIGKILL, syscall.SIGTERM) go func() { <-sigs clremoton.Terminate() }() gtk.Init(nil) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetPosition(gtk.WIN_POS_CENTER) window.SetTitle("REMOTON CLIENT") window.Connect("destroy", func(ctx *glib.CallbackContext) { gtk.MainQuit() clremoton.Terminate() }, "quit") window.SetIcon(common.GetIconGdkPixbuf()) appLayout := gtk.NewVBox(false, 1) menu := gtk.NewMenuBar() appLayout.Add(menu) cascademenu := gtk.NewMenuItemWithMnemonic("_Help") menu.Append(cascademenu) submenu := gtk.NewMenu() cascademenu.SetSubmenu(submenu) menuitem := gtk.NewMenuItemWithMnemonic("_About") menuitem.Connect("activate", func() { dialog := common.GtkAboutDialog() dialog.SetProgramName("Client Desktop") dialog.SetComments("Share your desktop secure") dialog.Run() dialog.Destroy() }) submenu.Append(menuitem) hpaned := gtk.NewHPaned() appLayout.Add(hpaned) statusbar := gtk.NewStatusbar() contextID := statusbar.GetContextId("remoton-desktop-client") //--- //CONTROL //--- frameControl := gtk.NewFrame("Controls") controlBox := gtk.NewVBox(false, 1) frameControl.Add(controlBox) controlBox.Add(gtk.NewLabel("MACHINE ID")) machineIDEntry := gtk.NewEntry() machineIDEntry.SetEditable(false) controlBox.Add(machineIDEntry) machineAuthEntry := gtk.NewEntry() machineAuthEntry.SetEditable(false) controlBox.Add(machineAuthEntry) controlBox.Add(gtk.NewLabel("Server")) serverEntry := gtk.NewEntry() serverEntry.SetText("127.0.0.1:9934") if os.Getenv("REMOTON_SERVER") != "" { serverEntry.SetText(os.Getenv("REMOTON_SERVER")) serverEntry.SetEditable(false) } controlBox.Add(serverEntry) controlBox.Add(gtk.NewLabel("Auth Server")) authServerEntry := gtk.NewEntry() authServerEntry.SetText("public") controlBox.Add(authServerEntry) var getCertFilename func() string localCert := filepath.Join(filepath.Dir(os.Args[0]), "cert.pem") if _, err := os.Stat(localCert); err == nil || os.IsExist(err) { controlBox.Add(gtk.NewLabel("Cert local")) getCertFilename = func() string { return localCert } } else if os.Getenv("REMOTON_CERT_FILE") != "" { controlBox.Add(gtk.NewLabel("Cert enviroment")) getCertFilename = func() string { return os.Getenv("REMOTON_CERT_FILE") } } else { btnCert := gtk.NewFileChooserButton("Cert", gtk.FILE_CHOOSER_ACTION_OPEN) getCertFilename = btnCert.GetFilename controlBox.Add(btnCert) } btnSrv := gtk.NewButtonWithLabel("Start") clremoton.VNC.OnConnection(func(addr net.Addr) { statusbar.Push(contextID, "Someone connected") log.Println("New connection from:" + addr.String()) }) btnSrv.Clicked(func() { if *insecure { clremoton.SetInsecure() } else { certPool, err := common.GetRootCAFromFile(getCertFilename()) if err != nil { dialogError(window, err) return } clremoton.SetCertPool(certPool) } if !clremoton.Started() { log.Println("starting remoton") machinePassword = uuid.New()[:4] err := clremoton.Start(serverEntry.GetText(), authServerEntry.GetText(), machinePassword) if err != nil { dialogError(btnSrv.GetTopLevelAsWindow(), err) statusbar.Push(contextID, "Failed") } else { btnSrv.SetLabel("Stop") machineIDEntry.SetText(clremoton.MachineID()) machineAuthEntry.SetText(machinePassword) statusbar.Push(contextID, "Connected") } } else { clremoton.Stop() btnSrv.SetLabel("Start") machineIDEntry.SetText("") machineAuthEntry.SetText("") statusbar.Push(contextID, "Stopped") } }) controlBox.Add(btnSrv) //--- // CHAT //--- frameChat := gtk.NewFrame("Chat") chatBox := gtk.NewVBox(false, 1) frameChat.Add(chatBox) swinChat := gtk.NewScrolledWindow(nil, nil) chatHistory := gtk.NewTextView() clremoton.Chat.OnRecv(func(msg string) { chatHistoryRecv(chatHistory, msg) }) swinChat.Add(chatHistory) chatEntry := gtk.NewEntry() chatEntry.Connect("key-press-event", func(ctx *glib.CallbackContext) { arg := ctx.Args(0) event := *(**gdk.EventKey)(unsafe.Pointer(&arg)) if event.Keyval == gdk.KEY_Return { msgToSend := chatEntry.GetText() clremoton.Chat.Send(msgToSend) chatHistorySend(chatHistory, msgToSend) chatEntry.SetText("") } }) chatBox.Add(chatEntry) chatBox.Add(swinChat) hpaned.Pack1(frameControl, false, false) hpaned.Pack2(frameChat, false, true) appLayout.Add(statusbar) window.Add(appLayout) window.ShowAll() gtk.Main() }
func runGUI() { window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetTitle(getApplicationTitle()) window.Connect("destroy", gtk.MainQuit) keyboardEventsChan := make(chan *keyhandler.KeyPressEvent) window.Connect("key-press-event", func(ctx *glib.CallbackContext) { arg := ctx.Args(0) kev := *(**gdk.EventKey)(unsafe.Pointer(&arg)) kpe := keyhandler.KeyPressEvent{int(kev.Keyval), 0} if (gdk.ModifierType(kev.State) & gdk.CONTROL_MASK) != 0 { kpe.Modifier = gdk.CONTROL_MASK } keyboardEventsChan <- &kpe }) // motionEvent := make(chan interface{}) // window.Connect("motion-notify-event", func(ctx *glib.CallbackContext) { // arg := ctx.Args(0) // motionEvent <- *(**gdk.EventMotion)(unsafe.Pointer(&arg)) // }) // go events.MotionHandler(motionEvent) buttonEventChan := make(chan interface{}) window.Connect("button-press-event", func(ctx *glib.CallbackContext) { arg := ctx.Args(0) buttonEventChan <- *(**gdk.EventButton)(unsafe.Pointer(&arg)) }) go events.ButtonHandler(buttonEventChan) setupProxy() vbox := gtk.NewVBox(false, 1) notebook := gtk.NewNotebook() tab := ui.NewBrowser(homePage) page := gtk.NewFrame("") notebook.AppendPage(page, gtk.NewLabel("Home")) page.Add(tab.VBox) vbox.PackStart(notebook, true, true, 0) statusbar := gtk.NewStatusbar() contextID := statusbar.GetContextId("actarus") statusbar.Push(contextID, "Welcome to Actarus.") vbox.PackStart(statusbar, false, false, 0) replEntry := gtk.NewEntry() replEntry.Hide() vbox.PackEnd(replEntry, false, false, 0) window.Add(vbox) window.SetSizeRequest(defaultWinWidth, defaultWinHeight) window.ShowAll() replEntry.GrabFocus() replEntry.SetVisible(false) // Handlers go events.KeyboardHandler( keyboardEventsChan, window, replEntry, tab.URLEntry, notebook) gtk.Main() }
//InitializeGUI es la funcion que inicializa y ejecuta todo el entorno gráfico de la aplicacion func (p *Gui) InitializeGUI(errorstr string, file *os.File) { gtk.Init(nil) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetPosition(gtk.WIN_POS_CENTER) window.Maximize() window.SetTitle("Go-SIC ASM/SIM!") window.SetIconName("gtk-dialog-info") window.Connect("destroy", func(ctx *glib.CallbackContext) { fmt.Println("got destroy!", ctx.Data().(string)) gtk.MainQuit() }, "foo") //-------------------------------------------------------- // GTK statusbar //-------------------------------------------------------- statusbar := gtk.NewStatusbar() context_id := statusbar.GetContextId("hola") //-------------------------------------------------------- // GtkVBox //-------------------------------------------------------- vbox := gtk.NewVBox(false, 1) //-------------------------------------------------------- // GtkMenuBar //-------------------------------------------------------- menubar := gtk.NewMenuBar() vbox.PackStart(menubar, false, false, 0) //-------------------------------------------------------- // GtkVPaned //-------------------------------------------------------- vpaned := gtk.NewVPaned() vbox.Add(vpaned) //-------------------------------------------------------- // GtkFrame //-------------------------------------------------------- frame1 := gtk.NewFrame("Código Fuente/Archivo intermedio/TABSIM") framebox1 := gtk.NewVBox(false, 1) frame1.Add(framebox1) frame1.SetSizeRequest(300, 300) frame2 := gtk.NewFrame("Debug/Código Objeto") framebox2 := gtk.NewVBox(false, 1) frame2.Add(framebox2) vpaned.Pack1(frame1, false, false) vpaned.Pack2(frame2, false, false) //-------------------------------------------------------- // GtkHBox //-------------------------------------------------------- ventanasPrincipales := gtk.NewHBox(false, 1) //---------------------------------------------- label := gtk.NewLabel("Ensamblador SIC SIC/XE") label.ModifyFontEasy("DejaVu Serif 15") framebox1.PackStart(label, false, true, 0) //-------------------------------------------------------- // GtkTextView //-------------------------------------------------------- swin := gtk.NewScrolledWindow(nil, nil) swin.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) swin.SetShadowType(gtk.SHADOW_IN) textview := gtk.NewTextView() textview.ModifyFontEasy("Sans 10") var start, end gtk.TextIter buffer := textview.GetBuffer() buffer.GetStartIter(&start) swin.Add(textview) ventanasPrincipales.Add(swin) //framebox1.Add(swin) //-------------------------------------------------------- // GtkTextView //-------------------------------------------------------- swin4 := gtk.NewScrolledWindow(nil, nil) swin4.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) swin4.SetShadowType(gtk.SHADOW_IN) textview4 := gtk.NewTextView() textview4.ModifyFontEasy("Sans 10") var start4, end4 gtk.TextIter buffer4 := textview4.GetBuffer() buffer4.GetStartIter(&start4) swin4.Add(textview4) ventanasPrincipales.Add(swin4) //framebox1.Add(swin) //-------------------------------------------------------- // GtkTextView //-------------------------------------------------------- swin5 := gtk.NewScrolledWindow(nil, nil) swin5.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) swin5.SetShadowType(gtk.SHADOW_IN) textview5 := gtk.NewTextView() textview5.ModifyFontEasy("Sans 10") var start5, end5 gtk.TextIter buffer5 := textview5.GetBuffer() buffer5.GetStartIter(&start5) swin5.Add(textview5) ventanasPrincipales.Add(swin5) framebox1.PackStart(ventanasPrincipales, true, true, 1) //framebox1.Add(swin) //-------------------------------------------------------- // GtkHBox //-------------------------------------------------------- ventanas := gtk.NewHBox(false, 1) //-------------------------------------------------------- // GtkTextView //-------------------------------------------------------- swin2 := gtk.NewScrolledWindow(nil, nil) swin2.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) swin2.SetShadowType(gtk.SHADOW_IN) textview2 := gtk.NewTextView() textview2.SetEditable(false) var start2, end2 gtk.TextIter buffer2 := textview2.GetBuffer() buffer2.GetStartIter(&start2) swin2.Add(textview2) //framebox2.Add(swin2) ventanas.Add(swin2) //-------------------------------------------------------- // GtkTextView //-------------------------------------------------------- swin3 := gtk.NewScrolledWindow(nil, nil) swin3.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) swin3.SetShadowType(gtk.SHADOW_IN) textview3 := gtk.NewTextView() textview3.SetEditable(false) var start3, end3 gtk.TextIter buffer3 := textview3.GetBuffer() buffer3.GetStartIter(&start3) swin3.Add(textview3) //framebox2.Add(swin2) ventanas.Add(swin3) framebox2.PackStart(ventanas, true, true, 1) //-------------------------------------------------------- // GtkEntry //-------------------------------------------------------- entry := gtk.NewEntry() entry.SetText("Para comenzar, favor de escoger un archivo del directorio....") //entry.SetSensitive(false) entry.SetEditable(false) framebox2.Add(entry) //-------------------------------------------------------- // GtkHBox //-------------------------------------------------------- buttons := gtk.NewHBox(false, 1) //-------------------------------------------------------- // GtkButton //**OPEN FILE****// //-------------------------------------------------------- button := gtk.NewButtonWithLabel("Elegir archivo...") var filename string var isXE bool button.Clicked(func() { fmt.Println("button clicked:", button.GetLabel()) messagedialog := gtk.NewMessageDialog( button.GetTopLevelAsWindow(), gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "Escoja un archivo .*s o *.x de su directorio") messagedialog.Response(func() { fmt.Println("Dialog OK!") //-------------------------------------------------------- // GtkFileChooserDialog //-------------------------------------------------------- filechooserdialog := gtk.NewFileChooserDialog( "Choose File...", button.GetTopLevelAsWindow(), gtk.FILE_CHOOSER_ACTION_OPEN, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) filter := gtk.NewFileFilter() filter.AddPattern("*.s") filter.AddPattern("*.x") filechooserdialog.AddFilter(filter) filechooserdialog.Response(func() { /*aqui va el dialogo */ filename = filechooserdialog.GetFilename() var extension = filepath.Ext(filename) if extension == ".x" { isXE = true } else { isXE = false } fmt.Println(filechooserdialog.GetFilename()) statusbar.Push(context_id, filename) dat, err := ioutil.ReadFile(filechooserdialog.GetFilename()) if err == nil { buffer.GetStartIter(&start) buffer.GetEndIter(&end) buffer.Delete(&start, &end) buffer.Insert(&start, string(dat)) entry.SetText("Ahora haz click en el boton '¡Analizar!'") //fmt.Print(string(dat)) } filechooserdialog.Destroy() }) filechooserdialog.Run() messagedialog.Destroy() }) messagedialog.Run() }) buttons.Add(button) //-------------------------------------------------------- // GtkButton //-------------------------------------------------------- button2 := gtk.NewButtonWithLabel("Ensamblar!") button2.Clicked(func() { fmt.Println("button clicked:", button2.GetLabel()) messagedialog2 := gtk.NewMessageDialog( button.GetTopLevelAsWindow(), gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "Analisis lexico y sintactico presiona OK para continuar...") messagedialog2.Response(func() { fmt.Println(filename) statusbar.Push(context_id, filename) file, err := os.Open(filename) if err != nil { log.Fatalf("Error al cargar el archivo: %s", err.Error()) } else { //********************************************************* util.GetTabSim().Allocate() if isXE == false { fmt.Println("IS SIC") errorstr = parser.New().Parse(file, true, false) file, err = os.Open(filename) util.GetAssembler().CreateOpCodeTable() errorstr = parser.New().Parse(file, false, false) file.Close() //util.GetAssembler().PrintCode() util.GetAssembler().FormatCodeToHEX() buffer2.GetStartIter(&start2) buffer2.GetEndIter(&end2) buffer2.Delete(&start2, &end2) if len(errorstr) > 0 { buffer2.Insert(&start2, string(errorstr+util.GetTabSim().Errores)) strArray := strings.Split(filename, ".s") f, err := os.OpenFile(strArray[0]+".ts", os.O_WRONLY|os.O_CREATE, 0600) if err != nil { panic(err) } defer f.Close() if _, err = f.WriteString(errorstr); err != nil { panic(err) } } else { buffer2.Insert(&start2, "Correcto!"+util.GetTabSim().Errores) } ///******************************************************* ///******************************************************* tabsimlines := util.GetTabSim().ReturnTable() buffer5.GetStartIter(&start5) buffer5.GetEndIter(&end5) buffer5.Delete(&start5, &end5) if len(tabsimlines) > 0 { buffer5.Insert(&start5, string(tabsimlines)) } ///******************************************************* ///******************************************************* util.GetTabSim().DecToHex() objectCode := util.GetAssembler().ObjCode() var obj string for i := 0; i < len(objectCode); i++ { if len(objectCode[i]) > 10 { obj += objectCode[i] } if i == len(objectCode)-1 { obj += objectCode[i] } } buffer3.GetStartIter(&start3) buffer3.GetEndIter(&end3) buffer3.Delete(&start3, &end3) if len(obj) > 0 { buffer3.Insert(&start3, string(obj)) } f2 := newFile(strings.Split(filename, ".s")[0], ".os") if _, err = f2.WriteString(obj); err != nil { panic(err) } ///******************************************************* ///******************************************************* var todostr string lines, err := readLines(filename) if err == nil { addrsstr := util.GetTabSim().GetProgPcStr() //fmt.Println(addrsstr) for i := 0; i < len(lines); i++ { if addrsstr[i+1] == "" { addrsstr[i+1] = addrsstr[i] todostr += addrsstr[i] + "\t" + lines[i] + "\n" } else { todostr += addrsstr[i] + "\t" + lines[i] + "\t" + util.GetTabSim().Progobjstr[i] + "\n" } } //util.GetTabSim().PrintProgpc() //fmt.Print(todostr) addrsstr = nil } buffer4.GetStartIter(&start4) buffer4.GetEndIter(&end4) buffer4.Delete(&start4, &end4) if len(obj) > 0 { buffer4.Insert(&start4, string(todostr)) } } else { fmt.Println("IS SIC XE") errorstr = parser.New().Parse(file, true, true) file, err = os.Open(filename) util.GetAssembler().CreateOpCodeTable() parser.New().Parse(file, false, true) file.Close() //util.GetAssembler().PrintCode() //util.GetAssembler().FormatCodeToHEX() buffer2.GetStartIter(&start2) buffer2.GetEndIter(&end2) buffer2.Delete(&start2, &end2) if len(errorstr) > 0 { buffer2.Insert(&start2, string(errorstr+util.GetTabSim().Errores)) strArray := strings.Split(filename, ".x") f, err := os.OpenFile(strArray[0]+".tx", os.O_WRONLY|os.O_CREATE, 0600) if err != nil { panic(err) } defer f.Close() if _, err = f.WriteString(errorstr); err != nil { panic(err) } } else { buffer2.Insert(&start2, "Correcto!"+util.GetTabSim().Errores) } ///******************************************************* ///******************************************************* tabsimlines := util.GetTabSim().ReturnTable() buffer5.GetStartIter(&start5) buffer5.GetEndIter(&end5) buffer5.Delete(&start5, &end5) if len(tabsimlines) > 0 { buffer5.Insert(&start5, string(tabsimlines)) } ///******************************************************* ///******************************************************* objectCode := util.GetAssembler().ObjCodeXE() util.GetTabSim().PcToHex() var obj string for i := 0; i < len(objectCode); i++ { if len(objectCode[i]) > 10 { obj += objectCode[i] } if i == len(objectCode)-1 { obj += objectCode[i] } } buffer3.GetStartIter(&start3) buffer3.GetEndIter(&end3) buffer3.Delete(&start3, &end3) if len(obj) > 0 { buffer3.Insert(&start3, string(obj)) } f2 := newFile(strings.Split(filename, ".x")[0], ".ox") if _, err = f2.WriteString(obj); err != nil { panic(err) } ///******************************************************* ///******************************************************* var todostr string lines, err := readLines(filename) if err == nil { addrsstr := util.GetTabSim().GetProgPcStr() //fmt.Println(addrsstr) for i := 0; i < len(lines); i++ { if addrsstr[i+1] == "" { addrsstr[i+1] = addrsstr[i] todostr += addrsstr[i] + "\t" + lines[i] + "\tError" + "\n" } else { todostr += addrsstr[i] + "\t" + lines[i] + "\t \t" if i != 0 && i < len(lines)-1 { todostr += util.GetAssembler().Hexcode[i-1] + "\n" } else { todostr += "\n" } } } //util.GetTabSim().PrintProgpc() //fmt.Print(todostr) addrsstr = nil } buffer4.GetStartIter(&start4) buffer4.GetEndIter(&end4) buffer4.Delete(&start4, &end4) if len(obj) > 0 { buffer4.Insert(&start4, string(todostr)) } } } entry.SetText("En la ventana debug se encuentran los errores lexicos y sintacticos del programa") fmt.Println("Dialog OK!") messagedialog2.Destroy() }) messagedialog2.Run() }) buttons.Add(button2) framebox2.PackStart(buttons, false, false, 0) ///////////////////////////////////////////// button3 := gtk.NewButtonWithLabel("Cargador...") button3.Clicked(func() { strArray2 := strings.Split(filename, ".s") f2, err := os.OpenFile(strArray2[0]+".o", os.O_WRONLY|os.O_CREATE, 0600) var obj string objectCode := util.GetAssembler().ObjCode() for i := 0; i < len(objectCode); i++ { if len(objectCode[i]) > 10 { obj += objectCode[i] } if i == len(objectCode)-1 { obj += objectCode[i] } } if _, err = f2.WriteString(obj); err != nil { panic(err) } //nombre := strings.Split(strArray2[0], "work") cmd := exec.Command("script.sh", strArray2[0]+".o") err = cmd.Start() if err != nil { log.Fatal(err) } log.Printf("Waiting for command to finish...") //err = cmd.Wait() log.Printf("Command finished with error: %v", err) }) buttons.Add(button3) //////////////////////////// buttons = gtk.NewHBox(false, 1) //-------------------------------------------------------- // GtkMenuItem ///***********SAVE FILE*****************/// //-------------------------------------------------------- cascademenu := gtk.NewMenuItemWithMnemonic("_File") menubar.Append(cascademenu) submenu := gtk.NewMenu() cascademenu.SetSubmenu(submenu) var menuitem2 *gtk.MenuItem menuitem2 = gtk.NewMenuItemWithMnemonic("G_uardar") menuitem2.Connect("activate", func() { strArray := strings.Split(filename, ".s") if len(strArray) <= 1 { strArray = strings.Split(filename, ".x") } if len(strArray) > 1 && len(filename) > 0 { statusbar.Push(context_id, filename) var s string buffer.GetStartIter(&start) buffer.GetEndIter(&end) s = buffer.GetText(&start, &end, true) fmt.Println(filename) err := ioutil.WriteFile(filename, []byte(s), 0644) if err != nil { panic(err) } } else { filechooserdialog := gtk.NewFileChooserDialog( "Choose File...", button.GetTopLevelAsWindow(), gtk.FILE_CHOOSER_ACTION_SAVE, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) filter := gtk.NewFileFilter() ///***ALLOWS SIC AND SIC-XE EXTENSION***/// filter.AddPattern("*.s") filter.AddPattern("*.x") filechooserdialog.AddFilter(filter) filechooserdialog.Response(func() { /*aqui va el dialogo */ statusbar.Push(context_id, filename) filename = filechooserdialog.GetFilename() if len(filename) > 0 { fmt.Println(filechooserdialog.GetFilename()) var s string buffer.GetStartIter(&start) buffer.GetEndIter(&end) s = buffer.GetText(&start, &end, true) err := ioutil.WriteFile(filename, []byte(s), 0644) if err != nil { panic(err) } entry.SetText("Haz click en el boton analizar") } filechooserdialog.Destroy() }) filechooserdialog.Run() } }) submenu.Append(menuitem2) var menuitem *gtk.MenuItem menuitem = gtk.NewMenuItemWithMnemonic("S_alir") menuitem.Connect("activate", func() { gtk.MainQuit() }) submenu.Append(menuitem) cascademenu = gtk.NewMenuItemWithMnemonic("_View") menubar.Append(cascademenu) submenu = gtk.NewMenu() cascademenu.SetSubmenu(submenu) checkmenuitem := gtk.NewCheckMenuItemWithMnemonic("_Disable") checkmenuitem.Connect("activate", func() { textview.SetSensitive(!checkmenuitem.GetActive()) textview2.SetSensitive(!checkmenuitem.GetActive()) }) submenu.Append(checkmenuitem) cascademenu = gtk.NewMenuItemWithMnemonic("_Help") menubar.Append(cascademenu) submenu = gtk.NewMenu() cascademenu.SetSubmenu(submenu) menuitem = gtk.NewMenuItemWithMnemonic("_About") menuitem.Connect("activate", func() { dialog := gtk.NewAboutDialog() dialog.SetName("Go-SIC sim!") dialog.SetProgramName("Go-SIC sim") dialog.SetLicense("The library is available under the same terms and conditions as the Go, the BSD style license, and the LGPL (Lesser GNU Public License). The idea is that if you can use Go (and Gtk) in a project, you should also be able to use go-gtk.") dialog.SetWrapLicense(true) dialog.Run() dialog.Destroy() }) submenu.Append(menuitem) //-------------------------------------------------------- // GtkStatusbar //-------------------------------------------------------- statusbar.Push(context_id, "No hay archivo seleccionado") framebox2.PackStart(statusbar, false, false, 0) //-------------------------------------------------------- // Event //-------------------------------------------------------- window.Add(vbox) window.SetSizeRequest(600, 600) window.ShowAll() gtk.Main() }