func accountWindow() {
// window settings
window_account := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window_account.SetPosition(gtk.WIN_POS_CENTER)
window_account.SetTitle("Add Account")
// main container
container_main := gtk.NewVBox(false, 10)
container_user := gtk.NewHBox(false, 0)
container_pass := gtk.NewHBox(false, 0)
container_buttons := gtk.NewHBox(false, 5)
container_main.SetBorderWidth(10)
// username
user_label := gtk.NewLabel("Username")
user_entry := gtk.NewEntry()
// password
pass_label := gtk.NewLabel("Password")
pass_entry := gtk.NewEntry()
pass_entry.SetVisibility(false)
// login and cancel buttons
button_login := gtk.NewButtonWithLabel("Add")
button_cancel := gtk.NewButtonWithLabel("Cancel")
// login
button_login.Clicked(func() {
username := user_entry.GetText()
password := pass_entry.GetText()
profile, err := CreateProfile(username, password)
if err == nil && profile != nil {
println("[*] Login successful")
window_account.Destroy()
}
})
// cancel
button_cancel.Clicked(func() {
window_account.Destroy()
})
// add elements to containers
container_buttons.Add(button_login)
container_buttons.Add(button_cancel)
container_user.PackStart(user_label, false, false, 20)
container_user.PackEnd(user_entry, true, true, 1)
container_pass.PackStart(pass_label, false, false, 20)
container_pass.PackEnd(pass_entry, true, true, 1)
container_main.PackStart(container_user, false, false, 1)
container_main.PackStart(container_pass, false, false, 1)
container_main.PackStart(container_buttons, false, false, 1)
window_account.Add(container_main)
window_account.SetSizeRequest(350, 150)
window_account.SetResizable(false)
window_account.ShowAll()
}
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 main() {
gtk.Init(nil)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle("Clock")
vbox := gtk.NewVBox(false, 1)
label := gtk.NewLabel("")
vbox.Add(label)
window.Add(vbox)
window.SetDefaultSize(300, 20)
window.ShowAll()
timer, _ := uv.TimerInit(nil)
timer.Start(func(h *uv.Handle, status int) {
label.SetLabel(fmt.Sprintf("%v", time.Now()))
}, 1000, 1000)
idle, _ := uv.IdleInit(nil)
idle.Start(func(h *uv.Handle, status int) {
gtk.MainIterationDo(false)
})
window.Connect("destroy", func() {
timer.Close(nil)
idle.Close(nil)
})
uv.DefaultLoop().Run()
}
// 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()
}
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
}
// Init acts as a constructor for the Status window struct
func (v *Status) Init(client, user string, minutes int) {
// Initialize variables
v.client = client
v.user = user
v.minutes = minutes
v.warned = false
v.window = gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
// Inital Window configuration
v.window.SetKeepAbove(true)
v.window.SetTitle(client)
v.window.SetTypeHint(gdk.WINDOW_TYPE_HINT_MENU)
v.window.SetSizeRequest(200, 180)
v.window.SetResizable(false)
// Build GUI
userLabel := gtk.NewLabel(user)
v.timeLabel = gtk.NewLabel("")
v.timeLabel.SetMarkup("<span size='xx-large'>" + strconv.Itoa(v.minutes) + " min igjen</span>")
button := gtk.NewButtonWithLabel("Logg ut")
vbox := gtk.NewVBox(false, 20)
vbox.SetBorderWidth(5)
vbox.Add(userLabel)
vbox.Add(v.timeLabel)
vbox.Add(button)
v.window.Add(vbox)
// Connect GUI event signals to function callbacks
v.window.Connect("delete-event", func() bool {
// Don't allow user to quit by closing the window
return true
})
button.Connect("clicked", func() {
gtk.MainQuit()
})
return
}
func main() {
gtk.Init(&os.Args)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle("GTK DrawingArea")
window.Connect("destroy", gtk.MainQuit)
vbox := gtk.NewVBox(true, 0)
vbox.SetBorderWidth(5)
targets := []gtk.TargetEntry{
{"text/uri-list", 0, 0},
{"STRING", 0, 1},
{"text/plain", 0, 2},
}
dest := gtk.NewLabel("drop me file")
dest.DragDestSet(
gtk.DEST_DEFAULT_MOTION|
gtk.DEST_DEFAULT_HIGHLIGHT|
gtk.DEST_DEFAULT_DROP,
targets,
gdk.ACTION_COPY)
dest.DragDestAddUriTargets()
dest.Connect("drag-data-received", func(ctx *glib.CallbackContext) {
sdata := gtk.SelectionDataFromNative(unsafe.Pointer(ctx.Args(3)))
if sdata != nil {
a := (*[2000]uint8)(sdata.GetData())
files := strings.Split(string(a[0:sdata.GetLength()-1]), "\n")
for i := range files {
filename, _, _ := glib.FilenameFromUri(files[i])
files[i] = filename
}
dialog := gtk.NewMessageDialog(
window,
gtk.DIALOG_MODAL,
gtk.MESSAGE_INFO,
gtk.BUTTONS_OK,
strings.Join(files, "\n"))
dialog.SetTitle("D&D")
dialog.Response(func() {
dialog.Destroy()
})
dialog.Run()
}
})
vbox.Add(dest)
window.Add(vbox)
window.SetSizeRequest(300, 100)
window.ShowAll()
gtk.Main()
}
func main() {
runtime.GOMAXPROCS(10)
glib.ThreadInit(nil)
gdk.ThreadsInit()
gdk.ThreadsEnter()
gtk.Init(nil)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.Connect("destroy", gtk.MainQuit)
vbox := gtk.NewVBox(false, 1)
label1 := gtk.NewLabel("")
vbox.Add(label1)
label2 := gtk.NewLabel("")
vbox.Add(label2)
window.Add(vbox)
window.SetSizeRequest(100, 100)
window.ShowAll()
time.Sleep(1000 * 1000 * 100)
go (func() {
for i := 0; i < 300000; i++ {
gdk.ThreadsEnter()
label1.SetLabel(strconv.Itoa(i))
gdk.ThreadsLeave()
}
gtk.MainQuit()
})()
go (func() {
for i := 300000; i >= 0; i-- {
gdk.ThreadsEnter()
label2.SetLabel(strconv.Itoa(i))
gdk.ThreadsLeave()
}
gtk.MainQuit()
})()
gtk.Main()
}
func (g *GUI) mkSidebar() *gtk.ScrolledWindow {
sbVBox := gtk.NewVBox(false, 0)
sbVBox.PackStart(labelCustomFont("Tools", "Sans Bold 14"), false, false, 3)
g.showbiomes = gtk.NewCheckButtonWithLabel("Show Biomes")
g.showbiomes.SetActive(true)
g.showbiomes.Connect("toggled", g.showbiomesToggled)
sbVBox.PackStart(g.showbiomes, false, false, 3)
g.fixSnowIce = gtk.NewCheckButtonWithLabel("Fix Snow/Ice")
g.fixSnowIce.SetTooltipText("Add Snow/Ice for Taiga/Ice Plains. Remove Snow/Ice for other biomes.")
g.fixSnowIce.Connect("toggled", g.fixSnowIceToggled)
sbVBox.PackStart(g.fixSnowIce, false, false, 3)
fill := gtk.NewRadioButtonWithLabel(nil, "Fill")
fill.SetActive(true)
fill.Connect("toggled", g.mkUpdateToolFx(fill, NewFillTool()))
draw := gtk.NewRadioButtonWithLabel(fill.GetGroup(), "Draw")
drawRadius := gtk.NewSpinButtonWithRange(1, 20, 1)
drawHBox := gtk.NewHBox(false, 0)
drawHBox.PackStart(draw, true, true, 0)
drawHBox.PackStart(gtk.NewLabel("Radius:"), false, false, 3)
drawHBox.PackEnd(drawRadius, false, false, 3)
draw.Connect("toggled", g.mkUpdateToolFx(draw, NewDrawTool(func() int { return drawRadius.GetValueAsInt() })))
sbVBox.PackStart(fill, false, false, 3)
sbVBox.PackStart(drawHBox, false, false, 3)
sbVBox.PackStart(gtk.NewHSeparator(), false, false, 3)
bioHeaderHBox := gtk.NewHBox(false, 0)
bioHeaderHBox.PackStart(labelCustomFont("Biomes", "Sans Bold 14"), true, false, 0)
editBiomesBtn := gtk.NewButton()
editBiomesBtn.Add(gtk.NewImageFromStock(gtk.STOCK_EDIT, gtk.ICON_SIZE_SMALL_TOOLBAR))
editBiomesBtn.Connect("clicked", g.biomeEditor)
editBiomesBtn.SetTooltipText("Configure Biomes")
bioHeaderHBox.PackStart(editBiomesBtn, false, false, 0)
sbVBox.PackStart(bioHeaderHBox, false, false, 3)
g.bioVBoxWrap = gtk.NewVBox(false, 0)
g.bioVBox = gtk.NewVBox(false, 0)
g.bioVBoxWrap.PackStart(g.bioVBox, false, false, 0)
sbVBox.PackStart(g.bioVBoxWrap, false, false, 3)
g.updateBiomeInfo()
scrolled := gtk.NewScrolledWindow(nil, nil)
scrolled.SetPolicy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrolled.AddWithViewPort(sbVBox)
return scrolled
}
func main() {
gtk.Init(&os.Args)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle("Alignment")
window.Connect("destroy", gtk.MainQuit)
notebook := gtk.NewNotebook()
window.Add(notebook)
align := gtk.NewAlignment(0.5, 0.5, 0.5, 0.5)
notebook.AppendPage(align, gtk.NewLabel("Alignment"))
button := gtk.NewButtonWithLabel("Hello World!")
align.Add(button)
fixed := gtk.NewFixed()
notebook.AppendPage(fixed, gtk.NewLabel("Fixed"))
button2 := gtk.NewButtonWithLabel("Pulse")
fixed.Put(button2, 30, 30)
progress := gtk.NewProgressBar()
fixed.Put(progress, 30, 70)
button.Connect("clicked", func() {
progress.SetFraction(0.1 + 0.9*progress.GetFraction()) //easter egg
})
button2.Connect("clicked", func() {
progress.Pulse()
})
window.ShowAll()
window.SetSizeRequest(200, 200)
gtk.Main()
}
func main() {
gtk.Init(&os.Args)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetSizeRequest(150, 50)
window.SetPosition(gtk.WIN_POS_CENTER)
window.Connect("destroy", func(ctx *glib.CallbackContext) {
gtk.MainQuit()
}, nil)
label := gtk.NewLabel("hello world")
window.Add(label)
window.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(&os.Args)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle("We love Expander")
window.Connect("destroy", gtk.MainQuit)
vbox := gtk.NewVBox(true, 0)
vbox.SetBorderWidth(5)
expander := gtk.NewExpander("dan the ...")
expander.Add(gtk.NewLabel("404 contents not found"))
vbox.PackStart(expander, false, false, 0)
window.Add(vbox)
window.ShowAll()
gtk.Main()
}
// 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 main() {
gtk.Init(&os.Args)
dialog := gtk.NewDialog()
dialog.SetTitle("number input")
vbox := dialog.GetVBox()
label := gtk.NewLabel("Numnber:")
vbox.Add(label)
input := gtk.NewEntry()
input.SetEditable(true)
vbox.Add(input)
input.Connect("insert-text", func(ctx *glib.CallbackContext) {
a := (*[2000]uint8)(unsafe.Pointer(ctx.Args(0)))
p := (*int)(unsafe.Pointer(ctx.Args(2)))
i := 0
for a[i] != 0 {
i++
}
s := string(a[0:i])
if s == "." {
if *p == 0 {
input.StopEmission("insert-text")
}
} else {
_, err := strconv.ParseFloat(s, 64)
if err != nil {
input.StopEmission("insert-text")
}
}
})
button := gtk.NewButtonWithLabel("OK")
button.Connect("clicked", func() {
println(input.GetText())
gtk.MainQuit()
})
vbox.Add(button)
dialog.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()
}
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()
}
func guiMain(confglobal string, conflocal string) {
var CallID string
ch := make(chan string, 100)
Config := ReadConfig(confglobal)
Configlocal := ReadConfiglocal(conflocal)
owner := Configlocal.Main.Owner
//prepare config for XSI
var xsiConfig xsi.ConfigT
xsiConfig.Main.User = Configlocal.Main.Owner
xsiConfig.Main.Password = Configlocal.Main.Password
xsiConfig.Main.Host = Config.Main.Host
xsiConfig.Main.HTTPHost = Config.Main.HTTPHost
xsiConfig.Main.HTTPPort = Config.Main.HTTPPort
def := xsi.MakeDef(xsiConfig)
//start main client
go clientMain(ch, Config)
//prepare config for OCI
var ociConfig ocip.ConfigT
ociConfig.Main.User = Configlocal.Main.Owner
ociConfig.Main.Password = Configlocal.Main.Password
ociConfig.Main.Host = Config.Main.Host
ociConfig.Main.OCIPPort = Config.Main.OCIPPort
//set unavailable at start app
ocip.OCIPsend(ociConfig, "UserCallCenterModifyRequest19", ConcatStr("", "userId=", owner), "agentACDState=Unavailable")
//prepare timer
timer := time.NewTimer(time.Second)
timer.Stop()
//init gthreads
glib.ThreadInit(nil)
gdk.ThreadsInit()
gdk.ThreadsEnter()
gtk.Init(nil)
//names
names := make(map[string]string)
for iter, target := range Config.Main.TargetID {
names[target] = Config.Main.Name[iter]
}
//icons to pixbuf map
pix := make(map[string]*gdkpixbuf.Pixbuf)
im_call := gtk.NewImageFromFile("ico/Call-Ringing-48.ico")
pix["call"] = im_call.GetPixbuf()
im_blank := gtk.NewImageFromFile("ico/Empty-48.ico")
pix["blank"] = im_blank.GetPixbuf()
im_green := gtk.NewImageFromFile("ico/Green-ball-48.ico")
pix["green"] = im_green.GetPixbuf()
im_grey := gtk.NewImageFromFile("ico/Grey-ball-48.ico")
pix["grey"] = im_grey.GetPixbuf()
im_yellow := gtk.NewImageFromFile("ico/Yellow-ball-48.ico")
pix["yellow"] = im_yellow.GetPixbuf()
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle("Call Center")
window.SetIcon(pix["call"])
window.SetPosition(gtk.WIN_POS_CENTER)
window.SetSizeRequest(350, 500)
window.SetDecorated(false)
window.SetResizable(true)
window.Connect("destroy", gtk.MainQuit)
swin := gtk.NewScrolledWindow(nil, nil)
swin.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
swin.SetShadowType(gtk.SHADOW_IN)
//owner
owner1 := gtk.NewLabel(names[owner])
owner2 := gtk.NewLabel("")
owner3 := gtk.NewImage()
//qstatus
qlabel1 := gtk.NewLabel("В очереди:")
qlabel2 := gtk.NewLabel("")
//buttons
b_av := gtk.NewButtonWithLabel("Доступен")
b_av.SetCanFocus(false)
b_av.Connect("clicked", func() {
ocip.OCIPsend(ociConfig, "UserCallCenterModifyRequest19", ConcatStr("", "userId=", owner), "agentACDState=Available")
})
b_un := gtk.NewButtonWithLabel("Недоступен")
b_un.SetCanFocus(false)
b_un.Connect("clicked", func() {
ocip.OCIPsend(ociConfig, "UserCallCenterModifyRequest19", ConcatStr("", "userId=", owner), "agentACDState=Unavailable")
})
b_wr := gtk.NewButtonWithLabel("Дообработка")
b_wr.SetCanFocus(false)
b_wr.Connect("clicked", func() {
ocip.OCIPsend(ociConfig, "UserCallCenterModifyRequest19", ConcatStr("", "userId=", owner), "agentACDState=Wrap-Up")
})
//main table
table := gtk.NewTable(3, 3, false)
table.Attach(owner1, 0, 1, 0, 1, gtk.FILL, gtk.FILL, 1, 1)
table.Attach(owner3, 1, 2, 0, 1, gtk.FILL, gtk.FILL, 1, 1)
table.Attach(owner2, 2, 3, 0, 1, gtk.FILL, gtk.FILL, 1, 1)
table.Attach(b_av, 0, 1, 1, 2, gtk.FILL, gtk.FILL, 1, 1)
table.Attach(b_un, 1, 2, 1, 2, gtk.FILL, gtk.FILL, 1, 1)
table.Attach(b_wr, 2, 3, 1, 2, gtk.FILL, gtk.FILL, 1, 1)
table.Attach(qlabel1, 0, 1, 2, 3, gtk.FILL, gtk.FILL, 1, 1)
table.Attach(qlabel2, 1, 2, 2, 3, gtk.FILL, gtk.FILL, 1, 1)
//menu buttons
btnclose := gtk.NewToolButtonFromStock(gtk.STOCK_STOP)
btnclose.SetCanFocus(false)
btnclose.OnClicked(gtk.MainQuit)
btnhide := gtk.NewToolButtonFromStock(gtk.STOCK_REMOVE)
btnhide.SetCanFocus(false)
btnhide.OnClicked(window.Iconify)
//move window
var p2, p1 point
var gdkwin *gdk.Window
p1.x = -1
p2.y = -1
var x int = 0
var y int = 0
var diffx int = 0
var diffy int = 0
px := &x
py := &y
movearea := gtk.NewDrawingArea()
movearea.Connect("motion-notify-event", func(ctx *glib.CallbackContext) {
if gdkwin == nil {
gdkwin = movearea.GetWindow()
}
arg := ctx.Args(0)
mev := *(**gdk.EventMotion)(unsafe.Pointer(&arg))
var mt gdk.ModifierType
if mev.IsHint != 0 {
gdkwin.GetPointer(&p2.x, &p2.y, &mt)
}
if (gdk.EventMask(mt) & gdk.BUTTON_PRESS_MASK) != 0 {
if p1.x != -1 && p1.y != -1 {
window.GetPosition(px, py)
diffx = p2.x - p1.x
diffy = p2.y - p1.y
window.Move(x+diffx, y+diffy)
}
p1.x = p2.x - diffx
p1.y = p2.y - diffy
} else {
p1.x = -1
p2.y = -1
}
})
movearea.SetEvents(int(gdk.POINTER_MOTION_MASK | gdk.POINTER_MOTION_HINT_MASK | gdk.BUTTON_PRESS_MASK))
//resize window
var p2r, p1r point
var gdkwinr *gdk.Window
p1r.x = -1
p2r.y = -1
var xr int = 0
var yr int = 0
var diffxr int = 0
var diffyr int = 0
pxr := &xr
pyr := &yr
resizearea := gtk.NewDrawingArea()
resizearea.SetSizeRequest(10, 10)
resizearea.Connect("motion-notify-event", func(ctx *glib.CallbackContext) {
if gdkwinr == nil {
gdkwinr = resizearea.GetWindow()
}
argr := ctx.Args(0)
mevr := *(**gdk.EventMotion)(unsafe.Pointer(&argr))
var mtr gdk.ModifierType
if mevr.IsHint != 0 {
gdkwinr.GetPointer(&p2r.x, &p2r.y, &mtr)
}
if (gdk.EventMask(mtr) & gdk.BUTTON_PRESS_MASK) != 0 {
if p1r.x != -1 && p1r.y != -1 {
diffxr = p2r.x - p1r.x
diffyr = p2r.y - p1r.y
window.GetSize(pxr, pyr)
window.Resize(xr+diffxr, yr+diffyr)
}
}
p1r = p2r
})
resizearea.SetEvents(int(gdk.POINTER_MOTION_MASK | gdk.POINTER_MOTION_HINT_MASK | gdk.BUTTON_PRESS_MASK))
//menu
menutable := gtk.NewTable(1, 8, true)
menutable.Attach(movearea, 0, 6, 0, 1, gtk.FILL, gtk.FILL, 0, 0)
menutable.Attach(btnhide, 6, 7, 0, 1, gtk.EXPAND, gtk.EXPAND, 0, 0)
menutable.Attach(btnclose, 7, 8, 0, 1, gtk.EXPAND, gtk.EXPAND, 0, 0)
//agents
dlabel1 := make(map[string]*gtk.Label)
dlabel2 := make(map[string]*gtk.Image)
dlabel3 := make(map[string]*gtk.Image)
b_tr := make(map[string]*gtk.Button)
var count uint = 0
for _, target := range Config.Main.TargetID {
if target != owner {
count = count + 1
dlabel1[target] = gtk.NewLabel(names[target])
dlabel2[target] = gtk.NewImage()
dlabel3[target] = gtk.NewImage()
tmp := gtk.NewButtonWithLabel("Перевод")
tmp.SetCanFocus(false)
tmptarget := target
tmp.Connect("clicked", func() {
xsi.XSITransfer(xsiConfig, def, owner, CallID, tmptarget)
})
b_tr[target] = tmp
}
}
table_ag := gtk.NewTable(4, count+1, false)
var place uint = 0
for _, target := range Config.Main.TargetID {
if target != owner {
place = place + 1
table_ag.Attach(dlabel1[target], 0, 1, place, place+1, gtk.FILL, gtk.FILL, 1, 1)
table_ag.Attach(dlabel3[target], 2, 3, place, place+1, gtk.FILL, gtk.FILL, 1, 1)
table_ag.Attach(dlabel2[target], 1, 2, place, place+1, gtk.FILL, gtk.FILL, 1, 1)
table_ag.Attach(b_tr[target], 3, 4, place, place+1, gtk.FILL, gtk.FILL, 1, 1)
}
}
//calls
table_cl := gtk.NewTable(2, 15, false)
dlabel4 := make(map[uint]*gtk.Label)
dlabel5 := make(map[uint]*gtk.Label)
var i uint
for i = 0; i < 15; i++ {
dlabel4[i] = gtk.NewLabel("")
table_cl.Attach(dlabel4[i], 0, 1, i, i+1, gtk.FILL, gtk.FILL, 1, 1)
dlabel5[i] = gtk.NewLabel("")
table_cl.Attach(dlabel5[i], 1, 2, i, i+1, gtk.FILL, gtk.FILL, 1, 1)
}
//tabs
notebook := gtk.NewNotebook()
notebook.AppendPage(table_ag, gtk.NewLabel("Агенты"))
notebook.AppendPage(table_cl, gtk.NewLabel("Звонки"))
//add all to window
vbox := gtk.NewVBox(false, 1)
vbox.Add(menutable)
vbox.Add(table)
vbox.Add(notebook)
vbox.Add(resizearea)
swin.AddWithViewPort(vbox)
window.Add(swin)
window.ShowAll()
//main func for update
go func() {
for {
select {
case data := <-ch:
cinfo := strings.Split(strings.Trim(data, "\n"), ";")
//owner
if cinfo[0] == owner && cinfo[1] == "state" {
if cinfo[4] != "" {
CallID = cinfo[5]
gdk.ThreadsEnter()
owner2.SetLabel(strings.Trim(cinfo[4], "tel:"))
gdk.ThreadsLeave()
} else {
CallID = ""
gdk.ThreadsEnter()
owner2.SetLabel("")
gdk.ThreadsLeave()
}
if cinfo[3] == "Available" {
gdk.ThreadsEnter()
owner3.SetFromPixbuf(pix["green"])
gdk.ThreadsLeave()
} else if cinfo[3] == "Wrap-Up" {
gdk.ThreadsEnter()
owner3.SetFromPixbuf(pix["yellow"])
gdk.ThreadsLeave()
timer.Reset(time.Second * Config.Main.Wraptime)
} else {
gdk.ThreadsEnter()
owner3.SetFromPixbuf(pix["grey"])
gdk.ThreadsLeave()
}
}
//CC q
if cinfo[0] == Config.Main.CCID && cinfo[1] == "state" {
if cinfo[6] != "" {
gdk.ThreadsEnter()
qlabel2.SetLabel(cinfo[6])
gdk.ThreadsLeave()
}
}
//CC calls
if cinfo[0] == Config.Main.CCID && cinfo[1] == "calls" {
if cinfo[3] != "" {
var i, j uint
j = 2
for i = 0; i < 15; i++ {
if cinfo[j] != "" {
date, _ := strconv.Atoi(cinfo[j])
date = date / 1000
j++
Addr := strings.Trim(cinfo[j], "tel:")
j++
Time := time.Unix(int64(date), 0)
gdk.ThreadsEnter()
tmp4 := dlabel4[i]
tmp4.SetLabel(Time.Format(time.Stamp))
tmp5 := dlabel5[i]
tmp5.SetLabel(Addr)
dlabel4[i] = tmp4
dlabel5[i] = tmp5
gdk.ThreadsLeave()
}
}
}
}
//Targets
if cinfo[0] != owner && cinfo[0] != Config.Main.CCID && cinfo[1] == "state" {
if cinfo[2] == "On-Hook" {
gdk.ThreadsEnter()
tmp := dlabel3[cinfo[0]]
tmp.SetFromPixbuf(pix["blank"])
dlabel3[cinfo[0]] = tmp
gdk.ThreadsLeave()
}
if cinfo[2] == "Off-Hook" {
gdk.ThreadsEnter()
tmp := dlabel3[cinfo[0]]
tmp.SetFromPixbuf(pix["call"])
dlabel3[cinfo[0]] = tmp
gdk.ThreadsLeave()
}
if cinfo[3] == "Available" {
gdk.ThreadsEnter()
tmp := dlabel2[cinfo[0]]
tmp.SetFromPixbuf(pix["green"])
dlabel2[cinfo[0]] = tmp
gdk.ThreadsLeave()
} else if cinfo[3] == "Wrap-Up" {
gdk.ThreadsEnter()
tmp := dlabel2[cinfo[0]]
tmp.SetFromPixbuf(pix["yellow"])
dlabel2[cinfo[0]] = tmp
gdk.ThreadsLeave()
} else {
gdk.ThreadsEnter()
tmp := dlabel2[cinfo[0]]
tmp.SetFromPixbuf(pix["grey"])
dlabel2[cinfo[0]] = tmp
gdk.ThreadsLeave()
}
}
//timer for wrap-up
case <-timer.C:
ocip.OCIPsend(ociConfig, "UserCallCenterModifyRequest19", ConcatStr("", "userId=", owner), "agentACDState=Available")
}
}
}()
gtk.Main()
}
func mainWindow() {
gtk.Init(&os.Args)
// window settings
window_main := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window_main.SetPosition(gtk.WIN_POS_CENTER)
window_main.SetTitle("Social Gopher")
window_main.Connect("destroy", func() {
println("[!] Quit application")
gtk.MainQuit()
})
// images
image_profile := loadImageAsset("profile")
image_stream := loadImageAsset("stream")
image_mentions := loadImageAsset("mentions")
image_interactions := loadImageAsset("interactions")
image_stars := loadImageAsset("stars")
image_messages := loadImageAsset("messages")
image_settings := loadImageAsset("settings")
// containers
container_main := gtk.NewHBox(false, 1)
container_left := gtk.NewVBox(false, 1)
container_right := gtk.NewVBox(false, 5)
container_compose := gtk.NewHBox(false, 5)
container_profile := gtk.NewHBox(false, 5)
container_profile.Add(image_profile)
container_left.SetBorderWidth(5)
container_right.SetBorderWidth(5)
// toolbar
button_stream := gtk.NewToolButton(image_stream, "My Stream")
button_mentions := gtk.NewToolButton(image_mentions, "Mentions")
button_interactions := gtk.NewToolButton(image_interactions, "Interactions")
button_stars := gtk.NewToolButton(image_stars, "Stars")
button_messages := gtk.NewToolButton(image_messages, "Messages")
button_settings := gtk.NewToolButton(image_settings, "Settings")
button_separator := gtk.NewSeparatorToolItem()
toolbar := gtk.NewToolbar()
toolbar.SetOrientation(gtk.ORIENTATION_VERTICAL)
toolbar.Insert(button_stream, -1)
toolbar.Insert(button_mentions, -1)
toolbar.Insert(button_interactions, -1)
toolbar.Insert(button_stars, -1)
toolbar.Insert(button_messages, -1)
toolbar.Insert(button_separator, -1)
toolbar.Insert(button_settings, -1)
// stream list
list_swin := gtk.NewScrolledWindow(nil, nil)
list_swin.SetPolicy(-1, 1)
list_swin.SetShadowType(2)
list_textView := gtk.NewTextView()
list_textView.SetEditable(false)
list_textView.SetCursorVisible(false)
list_textView.SetWrapMode(2)
list_swin.Add(list_textView)
list_buffer := list_textView.GetBuffer()
// compose message
compose := gtk.NewTextView()
compose.SetEditable(true)
compose.SetWrapMode(2)
compose_swin := gtk.NewScrolledWindow(nil, nil)
compose_swin.SetPolicy(1, 1)
compose_swin.SetShadowType(1)
compose_swin.Add(compose)
compose_counter := gtk.NewLabel("256")
compose_buffer := compose.GetBuffer()
compose_buffer.Connect("changed", func() {
chars_left := 256 - compose_buffer.GetCharCount()
compose_counter.SetText(strconv.Itoa(chars_left))
})
// post button and counter
button_post := gtk.NewButtonWithLabel("Post")
container_post := gtk.NewVBox(false, 1)
container_post.Add(compose_counter)
container_post.Add(button_post)
// button functions
button_stream.OnClicked(func() {
list_buffer.SetText("My Stream")
})
button_mentions.OnClicked(func() {
list_buffer.SetText("Mentions")
})
button_interactions.OnClicked(func() {
list_buffer.SetText("Interactions")
})
button_stars.OnClicked(func() {
list_buffer.SetText("Stars")
})
button_messages.OnClicked(func() {
list_buffer.SetText("Messages")
})
button_settings.OnClicked(func() {
accountWindow()
})
button_post.Clicked(func() {
compose_buffer.SetText("")
})
// add elements to containers
container_left.PackStart(container_profile, false, true, 1)
container_left.PackEnd(toolbar, true, true, 1)
container_right.PackStart(list_swin, true, true, 1)
container_right.PackEnd(container_compose, false, false, 1)
container_compose.PackStart(compose_swin, true, true, 1)
container_compose.PackEnd(container_post, false, true, 1)
container_main.PackStart(container_left, false, true, 1)
container_main.PackEnd(container_right, true, true, 1)
window_main.Add(container_main)
window_main.SetSizeRequest(500, 600)
window_main.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 labelCustomFont(text, font string) *gtk.Label {
label := gtk.NewLabel(text)
label.ModifyFontEasy(font)
return label
}
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() {
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() {
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() {
var autoupdating bool = false
var autoticker *time.Ticker
var entries [][]*gtk.Entry = make([][]*gtk.Entry, entitylimit)
for i := 0; i < entitylimit; i++ {
entries[i] = make([]*gtk.Entry, entityfields)
}
var entities []*physics.Entity = initentities(entries)
// Initialize gtk
gtk.Init(nil)
// WINDOW
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetPosition(gtk.WIN_POS_CENTER)
window.SetTitle("Gravity Visualization")
// Connect top window closing to gtk main loop closing
window.Connect("destroy", func(ctx *glib.CallbackContext) {
gtk.MainQuit()
})
// TOP VERTICAL BOX
topvbox := gtk.NewVBox(false, 1)
// NOTEBOOK FOR TABS
notebook := gtk.NewNotebook()
// DRAWING AREA VERTICAL BOX
davbox := gtk.NewVBox(false, 1)
// DRAWING AREA
drawingarea = gtk.NewDrawingArea()
drawingarea.SetSizeRequest(width, height)
drawingarea.ModifyBG(gtk.STATE_NORMAL, gdk.NewColor("white"))
drawingarea.Connect("expose_event", func() {
drawentities(entities)
})
davbox.PackStart(drawingarea, true, true, 0)
// TICK SPEED SLIDER
ticksliderhbox := gtk.NewHBox(false, 1)
ticksliderlabel := gtk.NewLabel("Time between ticks (ms)")
ticksliderhbox.Add(ticksliderlabel)
tickslider := gtk.NewHScaleWithRange(1, 1000, 100)
// Default value of 10 ms
tickslider.SetValue(10)
ticksliderhbox.Add(tickslider)
davbox.Add(ticksliderhbox)
// BUTTONS
buttons := gtk.NewHBox(false, 1)
// RESET MENU ITEM
resetbutton := gtk.NewButtonWithLabel("Reset")
resetbutton.Clicked(func() {
entities = initentities(entries)
drawingarea.QueueDraw()
})
buttons.Add(resetbutton)
// TICK MENU ITEM
tickbutton := gtk.NewButtonWithLabel("Tick")
tickbutton.Clicked(func() {
updateentities(entities)
})
buttons.Add(tickbutton)
// AUTOUPDATE MENU ITEM
autotickbutton := gtk.NewToggleButtonWithLabel("AutoUpdate")
autotickbutton.Clicked(func() {
// Stop the previous ticker if it exists
if autoticker != nil {
autoticker.Stop()
}
if autoupdating {
// Toggle autoupdating state
autoupdating = false
} else {
// Start the ticker
autoticker = time.NewTicker(time.Duration(tickslider.GetValue()) * time.Millisecond)
// Spawn a goroutine that will run update entities every tick
go func() {
for _ = range autoticker.C {
updateentities(entities)
}
}()
// Toggle autoupdating state
autoupdating = true
}
})
buttons.Add(autotickbutton)
davbox.Add(buttons)
notebook.AppendPage(davbox, gtk.NewLabel("Simulation"))
// INITIALIZE PANEL
entitiesvbox := gtk.NewVBox(false, 1)
// INITIALIZE LABELS FOR TABLE
titles := gtk.NewHBox(false, 1)
titles.Add(gtk.NewLabel("Mass"))
titles.Add(gtk.NewLabel("X-Pos"))
titles.Add(gtk.NewLabel("Y-Pos"))
titles.Add(gtk.NewLabel("X-Vel"))
titles.Add(gtk.NewLabel("Y-Vel"))
titles.Add(gtk.NewLabel("X-Acc"))
titles.Add(gtk.NewLabel("Y-Acc"))
entitiesvbox.Add(titles)
// INITIALIZE ENTRIES IN ROWS FOR TABLE
for row := 0; row < entitylimit; row++ {
rowbox := gtk.NewHBox(false, 1)
for col := 0; col < entityfields; col++ {
textfield := gtk.NewEntry()
// Hold reference to text field in entries 2d array
entries[row][col] = textfield
rowbox.Add(textfield)
}
entitiesvbox.Add(rowbox)
}
// CLEAR ENTITIES BUTTON
clearentitiesbutton := gtk.NewButtonWithLabel("Clear Entries")
clearentitiesbutton.Clicked(func() {
for row := 0; row < entitylimit; row++ {
for col := 0; col < entityfields; col++ {
entries[row][col].SetText("")
}
}
})
entitiesvbox.Add(clearentitiesbutton)
// Limit the size of the entitiesvbox and add to notebook
entitiesvbox.SetSizeRequest(width, height)
notebook.AppendPage(entitiesvbox, gtk.NewLabel("Entities"))
// FINISH PACKING COMPONENTS
topvbox.PackStart(notebook, false, false, 0)
// FINISH PACKING WINDOW
window.Add(topvbox)
// Show the GUI
window.ShowAll()
// Grab the drawable and initialize graphics context now that they are initialized
drawable = drawingarea.GetWindow().GetDrawable()
blackgc = gdk.NewGC(drawable)
redgc = gdk.NewGC(drawable)
redgc.SetRgbFgColor(gdk.NewColorRGB(255, 0, 0))
bluegc = gdk.NewGC(drawable)
bluegc.SetRgbFgColor(gdk.NewColorRGB(0, 0, 255))
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() {
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() {
gtk.Init(nil)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle("test002 - clicker game stuff thingy")
window.Connect("destroy", gtk.MainQuit)
window.SetSizeRequest(800, 600)
layout := gtk.NewLayout(nil, nil)
layout.ModifyBG(gtk.STATE_NORMAL, gdk.NewColorRGB(200, 200, 200))
menubar := createMenu()
spielstand := spielstand{money: 10, spielfeld: [5][5]*haus{}, amountUpgrades: 0}
label := gtk.NewLabel("")
labelUpdate(label, &spielstand)
for i := 0; i < len(spielstand.spielfeld); i++ {
for j := 0; j < len(spielstand.spielfeld[0]); j++ {
spielHaus := haus{state: -1}
spielstand.spielfeld[i][j] = &spielHaus
bild := gtk.NewImage()
if i == 2 && j == 3 {
spielHaus.state = 0
}
setImage(bild, spielHaus.state)
// lambda für die weiterschaltung
// Erhöhe den state nur wenn es kein upgrade gibt oder wenn wenn wir genug geld haben.
// Und nur bei letzterem kaufe das upgrade.
weiter := func(ctx *glib.CallbackContext) {
if spielHaus.state == -1 && spielstand.amountUpgrades != 0 && spielstand.money >= spielstand.amountUpgrades*10 {
spielHaus.state = 0
setImage(bild, 0)
spielstand.money -= spielstand.amountUpgrades * 10
} else {
if spielHaus.state < 6*5 && spielHaus.state != -1 {
if (spielHaus.state+1)%5 != 0 {
spielHaus.state += 1
} else {
if spielstand.money > 9 {
spielHaus.state += 1
setImage(bild, spielHaus.state/5)
spielstand.money -= 10
spielstand.amountUpgrades++
}
}
}
}
labelUpdate(label, &spielstand)
}
// Ein bild kann ohne weiteres keine events, daher braucht man eine
// EventBox drum rum um events zu haben
eventBox := gtk.NewEventBox()
eventBox.Add(bild)
// das event kann nicht direkt auf das image gesetzt werden, deswegen
// diese event box dafür.
eventBox.Connect("button-press-event", weiter)
eventBox.SetEvents(int(gdk.BUTTON_PRESS_MASK))
layout.Put(eventBox, 100+i*100, 100+j*100)
}
}
// start update routine
go update(&spielstand, label)
layout.Put(label, 300, 70)
layout.Put(menubar, 0, 0)
window.Add(layout)
window.ShowAll()
gtk.Main()
}
func main() {
b, err := ioutil.ReadFile("settings.json")
if err != nil {
fmt.Println(`"settings.json" not found: `, err)
return
}
var config map[string]string
err = json.Unmarshal(b, &config)
if err != nil {
fmt.Println(`can't read "settings.json": `, err)
return
}
client := &oauth.Client{Credentials: oauth.Credentials{config["ClientToken"], config["ClientSecret"]}}
cred := &oauth.Credentials{config["AccessToken"], config["AccessSecret"]}
runtime.LockOSThread()
gtk.Init(&os.Args)
window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
window.SetTitle("Twitter!")
window.Connect("destroy", gtk.MainQuit)
vbox := gtk.NewVBox(false, 1)
scrolledwin := gtk.NewScrolledWindow(nil, nil)
textview := gtk.NewTextView()
textview.SetEditable(false)
textview.SetCursorVisible(false)
scrolledwin.Add(textview)
vbox.Add(scrolledwin)
buffer := textview.GetBuffer()
tag := buffer.CreateTag("blue", map[string]string{"foreground": "#0000FF", "weight": "700"})
hbox := gtk.NewHBox(false, 1)
vbox.PackEnd(hbox, false, true, 5)
label := gtk.NewLabel("Tweet")
hbox.PackStart(label, false, false, 5)
text := gtk.NewEntry()
hbox.PackEnd(text, true, true, 5)
text.Connect("activate", func() {
t := text.GetText()
text.SetText("")
post(client, cred, t)
})
window.Add(vbox)
window.SetSizeRequest(800, 500)
window.ShowAll()
var mutex sync.Mutex
go func() {
show(client, cred, func(t *tweet) {
mutex.Lock()
display(t, buffer, tag)
mutex.Unlock()
})
stream(client, cred, func(t *tweet) {
mutex.Lock()
display(t, buffer, tag)
var start, end gtk.TextIter
buffer.GetIterAtLine(&start, buffer.GetLineCount()-2)
buffer.GetEndIter(&end)
buffer.Delete(&start, &end)
mutex.Unlock()
})
}()
for alive {
mutex.Lock()
alive = gtk.MainIterationDo(false)
mutex.Unlock()
}
}