func (ed *BiomeInfoEditor) save() {
dlg := gtk.NewFileChooserDialog("Save", nil, gtk.FILE_CHOOSER_ACTION_SAVE, "OK", gtk.RESPONSE_OK, "Cancel", gtk.RESPONSE_CANCEL)
defer dlg.Destroy()
askFilename:
if dlg.Run() == gtk.RESPONSE_OK {
path := dlg.GetFilename()
if _, err := os.Stat(path); err == nil {
qdlg := gtk.NewMessageDialog(nil, gtk.DIALOG_MODAL, gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, "File %s already exists. Overwrite?", path)
resp := qdlg.Run()
qdlg.Destroy()
if resp != gtk.RESPONSE_YES {
goto askFilename
}
}
f, err := os.Create(path)
if err != nil {
errdlg("Could not save biome infos %s:\n%s", path, err.Error())
goto askFilename
}
defer f.Close()
if err := WriteBiomeInfos(ed.biolist.Biomes(), f); err != nil {
errdlg("Could not save biome infos %s:\n%s", path, err.Error())
goto askFilename
}
}
}
func file_chooser_dialog(t int) (bool, string) {
var action gtk.FileChooserAction
var ok_stock string
if OPEN_DIALOG == t {
action = gtk.FILE_CHOOSER_ACTION_OPEN
ok_stock = gtk.STOCK_OPEN
} else if SAVE_DIALOG == t {
action = gtk.FILE_CHOOSER_ACTION_SAVE
ok_stock = gtk.STOCK_SAVE
} else if OPEN_DIR_DIALOG == t {
action = gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER
ok_stock = gtk.STOCK_OPEN
}
dialog := gtk.NewFileChooserDialog("", source_view.GetTopLevelAsWindow(),
action,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
ok_stock, gtk.RESPONSE_ACCEPT)
dialog.SetCurrentFolder(prev_dir)
res := dialog.Run()
dialog_folder := dialog.GetCurrentFolder()
dialog_file := dialog.GetFilename()
dialog.Destroy()
if gtk.RESPONSE_ACCEPT == res {
prev_dir = dialog_folder
return true, dialog_file
}
return false, ""
}
func (g *GUI) openWorldDlg() {
dlg := gtk.NewFileChooserDialog("Open World (level.dat)", g.window, gtk.FILE_CHOOSER_ACTION_OPEN, "Open", gtk.RESPONSE_OK, "Cancel", gtk.RESPONSE_CANCEL)
filter := gtk.NewFileFilter()
filter.AddPattern("level.dat")
filter.SetName("level.dat")
dlg.AddFilter(filter)
if dlg.Run() == gtk.RESPONSE_OK {
g.openWorld(dlg.GetFilename())
}
dlg.Destroy()
}
func openFileDialog(callback func(filename string)) {
filechooserdialog := gtk.NewFileChooserDialog(
"Choose File",
nil,
gtk.FILE_CHOOSER_ACTION_OPEN,
gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT)
filter := gtk.NewFileFilter()
filter.AddPattern("*.wav")
filter.AddPattern("*.mp3")
filechooserdialog.AddFilter(filter)
filechooserdialog.Response(func() {
callback(filechooserdialog.GetFilename())
filechooserdialog.Destroy()
})
filechooserdialog.Show()
}
func chooseFile(title string, action gtk.FileChooserAction, b *FileBuilder) (string, error) {
dlg := gtk.NewFileChooserDialog(firstOf(b.Dlg.Title, title), nil, action, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
for _, filt := range b.Filters {
filter := gtk.NewFileFilter()
filter.SetName(filt.Desc)
for _, ext := range filt.Extensions {
filter.AddPattern("*." + ext)
}
dlg.AddFilter(filter)
}
if b.StartDir != "" {
dlg.SetCurrentFolder(b.StartDir)
}
r := dlg.Run()
defer closeDialog(&dlg.Dialog)
if r == gtk.RESPONSE_ACCEPT {
return dlg.GetFilename(), nil
}
return "", Cancelled
}
func (ed *BiomeInfoEditor) load() {
dlg := gtk.NewFileChooserDialog("Load", nil, gtk.FILE_CHOOSER_ACTION_OPEN, "OK", gtk.RESPONSE_OK, "Cancel", gtk.RESPONSE_CANCEL)
defer dlg.Destroy()
askFilename:
if dlg.Run() == gtk.RESPONSE_OK {
path := dlg.GetFilename()
f, err := os.Open(path)
if err != nil {
errdlg("Could not load biome infos %s:\n%s", path, err.Error())
goto askFilename
}
defer f.Close()
infos, err := ReadBiomeInfos(f)
if err != nil {
errdlg("Could not load biome infos %s:\n%s", path, err.Error())
goto askFilename
}
ed.biolist.SetBiomes(infos)
}
}
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() {
if len(os.Args) < 2 {
filename = ""
} else {
filename = os.Args[1]
}
gtk.Init(nil)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle(filename)
window.Connect("destroy", gtk.MainQuit)
vbox := gtk.NewVBox(false, 1)
menubar := gtk.NewMenuBar()
vbox.PackStart(menubar, false, false, 0)
webview = webkit.NewWebView()
vbox.Add(webview)
filemenu := gtk.NewMenuItemWithMnemonic("_File")
menubar.Append(filemenu)
submenu := gtk.NewMenu()
filemenu.SetSubmenu(submenu)
menu_open := gtk.NewMenuItemWithMnemonic("_Open")
menu_open.Connect("activate", func() {
filechooserdialog := gtk.NewFileChooserDialog(
"Choose file",
window,
gtk.FILE_CHOOSER_ACTION_OPEN,
gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT)
filter := gtk.NewFileFilter()
filter.AddPattern("*.md")
filter.AddPattern("*.markdown")
filter.SetName("Markdown files")
filechooserdialog.AddFilter(filter)
filechooserdialog.Response(func() {
filename = (filechooserdialog.GetFilename())
filechooserdialog.Destroy()
})
filechooserdialog.Run()
reload()
})
submenu.Append(menu_open)
menu_reload = gtk.NewMenuItemWithMnemonic("_Reload")
menu_reload.Connect("activate", func() {
reload()
})
submenu.Append(menu_reload)
menu_exit = gtk.NewMenuItemWithMnemonic("E_xit")
menu_exit.Connect("activate", func() {
gtk.MainQuit()
})
submenu.Append(menu_exit)
viewmenu := gtk.NewMenuItemWithMnemonic("_View")
menubar.Append(viewmenu)
viewsubmenu := gtk.NewMenu()
viewmenu.SetSubmenu(viewsubmenu)
menu_dark := gtk.NewCheckMenuItemWithMnemonic("D_ark Theme")
menu_dark.Connect("activate", func() {
if menu_dark.GetActive() {
dark_theme = true
} else {
dark_theme = false
}
reload()
})
viewsubmenu.Append(menu_dark)
window.Add(vbox)
window.SetSizeRequest(480, 600)
bytesSlice := bytesFromXpmData(xpm_data)
icon_file := "/tmp/hackdown-icon.xpm"
ioutil.WriteFile(icon_file, bytesSlice, os.ModePerm)
window.SetIconFromFile(icon_file)
window.ShowAll()
webview.LoadString(getContent(), "text/html", "utf-8", ".")
gtk.Main()
}
func main() {
runtime.LockOSThread()
gtk.Init(&os.Args)
gdk.ThreadsInit()
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle("DMS GUI")
window.Connect("destroy", gtk.MainQuit)
vbox := gtk.NewVBox(false, 0)
window.Add(vbox)
hbox := gtk.NewHBox(false, 0)
vbox.PackStart(hbox, false, true, 0)
hbox.PackStart(gtk.NewLabel("Shared directory: "), false, true, 0)
dialog := gtk.NewFileChooserDialog(
"Select directory to share", window, gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)
button := gtk.NewFileChooserButtonWithDialog(dialog)
hbox.Add(button)
logView := gtk.NewTextView()
logView.SetEditable(false)
logView.ModifyFontEasy("monospace")
logView.SetWrapMode(gtk.WRAP_WORD_CHAR)
logViewScroller := gtk.NewScrolledWindow(nil, nil)
logViewScroller.Add(logView)
logViewScroller.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
vbox.PackEnd(logViewScroller, true, true, 0)
getPath := func() string {
return button.GetFilename()
}
window.ShowAll()
if dialog.Run() != gtk.RESPONSE_ACCEPT {
return
}
go func() {
dmsServer := dms.Server{
RootObjectPath: getPath(),
}
if err := dmsServer.Serve(); err != nil {
log.Fatalln(err)
}
defer dmsServer.Close()
runtime.LockOSThread()
gdk.ThreadsEnter()
button.Connect("selection-changed", func() {
dmsServer.RootObjectPath = getPath()
})
gdk.ThreadsLeave()
runtime.UnlockOSThread()
dmsServer.Serve()
}()
gtk.Main()
runtime.UnlockOSThread()
}
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()
}
//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()
}
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()
}