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()
}
