func TestWebView_LoadHTML(t *testing.T) {
webView := NewWebView()
defer webView.Destroy()
loadOk := false
webView.Connect("load-failed", func() {
t.Errorf("load failed")
})
webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) {
switch loadEvent {
case LoadFinished:
loadOk = true
gtk.MainQuit()
}
})
glib.IdleAdd(func() bool {
webView.LoadHTML("<p>hello</p>", "")
return false
})
gtk.Main()
if !loadOk {
t.Error("!loadOk")
}
}
func TestWebView_URI(t *testing.T) {
setup()
defer teardown()
mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {})
wantURI := server.URL + "/"
var gotURI string
webView.Connect("notify::uri", func() {
glib.IdleAdd(func() bool {
gotURI = webView.URI()
if gotURI != "" {
gtk.MainQuit()
}
return false
})
})
glib.IdleAdd(func() bool {
webView.LoadURI(server.URL)
return false
})
gtk.Main()
if wantURI != gotURI {
t.Errorf("want URI %q, got %q", wantURI, gotURI)
}
}
func main() {
gtk.Init(nil)
initIcons()
win := setupWindow("Go Example Testreport")
var iter1, iter2 *gtk.TreeIter
treeView, treeStore := setupTreeView()
win.Add(treeView)
// Add some rows to the tree store
iter1 = addRow(treeStore, imageOK, "Testsuite 1")
iter2 = addSubRow(treeStore, iter1, imageOK, "test1-1")
iter2 = addSubRow(treeStore, iter1, imageOK, "test1-2")
addSubRow(treeStore, iter2, imageOK, "test1-2-1")
addSubRow(treeStore, iter2, imageOK, "test1-2-2")
addSubRow(treeStore, iter2, imageOK, "test1-2-3")
iter2 = addSubRow(treeStore, iter1, imageOK, "test1-3")
iter1 = addRow(treeStore, imageFAIL, "Testsuite 2")
iter2 = addSubRow(treeStore, iter1, imageOK, "test2-1")
iter2 = addSubRow(treeStore, iter1, imageOK, "test2-2")
iter2 = addSubRow(treeStore, iter1, imageFAIL, "test2-3")
addSubRow(treeStore, iter2, imageOK, "test2-3-1")
addSubRow(treeStore, iter2, imageFAIL, "test2-3-2")
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
window := ui.NewMainWindow()
window.Window.ShowAll()
gtk.Main()
}
func TestWebView_RunJavaScript(t *testing.T) {
webView := NewWebView()
defer webView.Destroy()
wantResultString := "abc"
webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) {
switch loadEvent {
case LoadFinished:
webView.RunJavaScript(`document.getElementById("foo").innerHTML`, func(result *gojs.Value, err error) {
if err != nil {
t.Errorf("RunJavaScript error: %s", err)
}
resultString := webView.JavaScriptGlobalContext().ToStringOrDie(result)
if wantResultString != resultString {
t.Errorf("want result string %q, got %q", wantResultString, resultString)
}
gtk.MainQuit()
})
}
})
glib.IdleAdd(func() bool {
webView.LoadHTML(`<p id=foo>abc</p>`, "")
return false
})
gtk.Main()
}
func TestWebView_GetSnapshot(t *testing.T) {
webView := NewWebView()
defer webView.Destroy()
webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) {
switch loadEvent {
case LoadFinished:
webView.GetSnapshot(func(img *image.RGBA, err error) {
if err != nil {
t.Errorf("GetSnapshot error: %q", err)
}
if img.Pix == nil {
t.Error("!img.Pix")
}
if img.Stride == 0 || img.Rect.Max.X == 0 || img.Rect.Max.Y == 0 {
t.Error("!img.Stride or !img.Rect.Max.X or !img.Rect.Max.Y")
}
gtk.MainQuit()
})
}
})
glib.IdleAdd(func() bool {
webView.LoadHTML(`<p id=foo>abc</p>`, "")
return false
})
gtk.Main()
}
func Example() {
gtk.Init(nil)
go func() {
runtime.LockOSThread()
gtk.Main()
}()
ctx := webloop.New()
view := ctx.NewView()
defer view.Close()
view.Open("http://google.com")
err := view.Wait()
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to load URL: %s", err)
os.Exit(1)
}
res, err := view.EvaluateJavaScript("document.title")
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to run JavaScript: %s", err)
os.Exit(1)
}
fmt.Printf("JavaScript returned: %q\n", res)
// output:
// JavaScript returned: "Google"
}
func TestWebView_LoadURI_load_failed(t *testing.T) {
webView := NewWebView()
defer webView.Destroy()
loadFailed := false
loadFinished := false
webView.Connect("load-failed", func() {
loadFailed = true
})
webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) {
switch loadEvent {
case LoadFinished:
loadFinished = true
gtk.MainQuit()
}
})
glib.IdleAdd(func() bool {
// Load a bad URL to trigger load failure.
webView.LoadURI("http://127.0.0.1:99999")
return false
})
gtk.Main()
if !loadFailed {
t.Error("!loadFailed")
}
if !loadFinished {
t.Error("!loadFinished")
}
}
func init() {
gtk.Init(nil)
go func() {
runtime.LockOSThread()
gtk.Main()
}()
}
func main() {
// Initialize GTK without parsing any command line arguments.
gtk.Init(nil)
// Create a new toplevel window, set its title, and connect it to the
// "destroy" signal to exit the GTK main loop when it is destroyed.
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if err != nil {
log.Fatal("Unable to create window:", err)
}
win.SetTitle("Simple Example")
win.Connect("destroy", func() {
gtk.MainQuit()
})
// Create a new label widget to show in the window.
list, err := gtk.ListBoxNew()
if err != nil {
log.Fatal("Unable to create label:", err)
}
gtkList = list
// Add the label to the window.
win.Add(gtkList)
// Set the default window size.
win.SetDefaultSize(640/2, 1136/2)
// Recursively show all widgets contained in this window.
win.ShowAll()
// Begin executing the GTK main loop. This blocks until
// gtk.MainQuit() is run.
go getEntries()
gtk.Main()
}
func TestWebView_Title(t *testing.T) {
webView := NewWebView()
defer webView.Destroy()
wantTitle := "foo"
var gotTitle string
webView.Connect("notify::title", func() {
glib.IdleAdd(func() bool {
gotTitle = webView.Title()
if gotTitle != "" {
gtk.MainQuit()
}
return false
})
})
glib.IdleAdd(func() bool {
webView.LoadHTML("<html><head><title>"+wantTitle+"</title></head><body></body></html>", "")
return false
})
gtk.Main()
if wantTitle != gotTitle {
t.Errorf("want title %q, got %q", wantTitle, gotTitle)
}
}
func TestWebView_RunJavaScript_exception(t *testing.T) {
webView := NewWebView()
defer webView.Destroy()
wantErr := errors.New("An exception was raised in JavaScript")
webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) {
switch loadEvent {
case LoadFinished:
webView.RunJavaScript(`throw new Error("foo")`, func(result *gojs.Value, err error) {
if result != nil {
ctx := webView.JavaScriptGlobalContext()
t.Errorf("want result == nil, got %q", ctx.ToStringOrDie(result))
}
if !reflect.DeepEqual(wantErr, err) {
t.Errorf("want error %q, got %q", wantErr, err)
}
gtk.MainQuit()
})
}
})
glib.IdleAdd(func() bool {
webView.LoadHTML(`<p></p>`, "")
return false
})
gtk.Main()
}
func main() {
gtk.Init(nil)
go func() {
appdbus.StandAlone(TVPlay.NewApplet)
gtk.MainQuit()
}()
gtk.Main()
}
// StartGTK ensures that the GTK+ main loop has started. If it has already been
// started by StartGTK, it will not start it again. If another goroutine is
// already running the GTK+ main loop, StartGTK's behavior is undefined.
func (h *StaticRenderer) StartGTK() {
startGTKOnce.Do(func() {
gtk.Init(nil)
go func() {
runtime.LockOSThread()
gtk.Main()
}()
})
}
func (u *gtkUI) Loop() {
go u.loadConfig(*config.ConfigFile)
go u.watchCommands()
go u.observeAccountEvents()
doInUIThread(u.mainWindow)
gtk.Main()
}
// InitGtk provides GTK start and stop callbacks.
//
func InitGtk() (onstart, onstop func()) {
gtkStart := func() {
GRRTHREADS()
// runtime.LockOSThread()
gtk.Init(nil)
gtk.Main()
}
return gtkStart, gtk.MainQuit
}
/*At this moment Visionect specific*/
func TestTimeoutAdd(t *testing.T) {
runtime.LockOSThread()
glib.TimeoutAdd(2500, func(s string) bool {
t.Log(s)
gtk.MainQuit()
return false
}, "TimeoutAdd executed")
gtk.Main()
}
func main() {
gtk.Init(nil)
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
panicIfNotNil(err)
win.Connect("destroy", func() {
gtk.MainQuit()
})
win.SetDefaultSize(1280, 720)
win.SetTitle("mauIRC Desktop")
// Create a new grid widget to arrange child widgets
grid, err := gtk.GridNew()
panicIfNotNil(err)
grid.SetOrientation(gtk.ORIENTATION_VERTICAL)
loginLabel, err := gtk.LabelNew("Log in to mauIRC")
panicIfNotNil(err)
email, err := gtk.EntryNew()
panicIfNotNil(err)
password, err := gtk.EntryNew()
panicIfNotNil(err)
password.SetVisibility(false)
btn, err := gtk.ButtonNewWithLabel("Log in")
panicIfNotNil(err)
grid.Attach(loginLabel, 0, 2, 1, 1)
grid.Attach(email, 0, 3, 1, 1)
grid.Attach(password, 0, 4, 1, 1)
grid.Attach(btn, 0, 5, 1, 1)
//grid.Attach(nb, 1, 1, 1, 2)
//nb.SetHExpand(true)
//nb.SetVExpand(true)
/*nbChild, err := gtk.LabelNew("Notebook content")
if err != nil {
log.Fatal("Unable to create button:", err)
}
nbTab, err := gtk.LabelNew("Tab label")
if err != nil {
log.Fatal("Unable to create label:", err)
}
nb.AppendPage(nbChild, nbTab)*/
win.Add(grid)
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if err != nil {
log.Fatal("Unable to create window:", err)
}
win.Connect("destroy", func() {
gtk.MainQuit()
})
win.Add(windowWidget())
// Native GTK is not thread safe, and thus, gotk3's GTK bindings may not
// be used from other goroutines. Instead, glib.IdleAdd() must be used
// to add a function to run in the GTK main loop when it is in an idle
// state.
//
// Two examples of using glib.IdleAdd() are shown below. The first runs
// a user created function, LabelSetTextIdle, and passes it two
// arguments for a label and the text to set it with. The second calls
// (*gtk.Label).SetText directly, passing in only the text as an
// argument.
//
// If the function passed to glib.IdleAdd() returns one argument, and
// that argument is a bool, this return value will be used in the same
// manner as a native g_idle_add() call. If this return value is false,
// the function will be removed from executing in the GTK main loop's
// idle state. If the return value is true, the function will continue
// to execute when the GTK main loop is in this state.
go func() {
for {
time.Sleep(time.Second)
s := fmt.Sprintf("Set a label %d time(s)!", nSets)
_, err := glib.IdleAdd(LabelSetTextIdle, topLabel, s)
if err != nil {
log.Fatal("IdleAdd() failed:", err)
}
nSets++
s = fmt.Sprintf("Set a label %d time(s)!", nSets)
_, err = glib.IdleAdd(bottomLabel.SetText, s)
if err != nil {
log.Fatal("IdleAdd() failed:", err)
}
nSets++
}
}()
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
win := setup_window(winTitle)
box := newStackFull()
win.Add(box)
// Recursively show all widgets contained in this window.
win.ShowAll()
// Begin executing the GTK main loop. This blocks until
// gtk.MainQuit() is run.
gtk.Main()
}
func main() {
gtk.Init(nil)
win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if err != nil {
log.Fatal("Unable to create window:", err)
}
win.Connect("destroy", func() {
gtk.MainQuit()
})
win.Add(windowWidget())
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
win := setupWindow("Go Feature Timeline")
treeView, listStore := setupTreeView()
win.Add(treeView)
// Add some rows to the list store
addRow(listStore, "r57", "Gofix command added for rewriting code for new APIs")
addRow(listStore, "r60", "URL parsing moved to new \"url\" package")
addRow(listStore, "go1.0", "Rune type introduced as alias for int32")
addRow(listStore, "go1.1", "Race detector added to tools")
addRow(listStore, "go1.2", "Limit for number of threads added")
addRow(listStore, "go1.3", "Support for various BSD's, Plan 9 and Solaris")
win.ShowAll()
gtk.Main()
}
func Example() {
runtime.LockOSThread()
gtk.Init(nil)
webView := webkit2.NewWebView()
defer webView.Destroy()
webView.Connect("load-failed", func() {
fmt.Println("Load failed.")
})
webView.Connect("load-changed", func(_ *glib.Object, i int) {
loadEvent := webkit2.LoadEvent(i)
switch loadEvent {
case webkit2.LoadFinished:
fmt.Println("Load finished.")
fmt.Printf("Title: %q\n", webView.Title())
fmt.Printf("URI: %s\n", webView.URI())
webView.RunJavaScript("window.location.hostname", func(val *gojs.Value, err error) {
if err != nil {
fmt.Println("JavaScript error.")
} else {
fmt.Printf("Hostname (from JavaScript): %q\n", val)
}
gtk.MainQuit()
})
}
})
glib.IdleAdd(func() bool {
webView.LoadURI("https://www.google.com/")
return false
})
gtk.Main()
// output:
// Load finished.
// Title: "Google"
// URI: https://www.google.com/
// Hostname (from JavaScript): "www.google.com"
}
// TestConnectNotifySignal ensures that property notification signals (those
// whose name begins with "notify::") are queried by the name "notify" (with the
// "::" and the property name omitted). This is because the signal is "notify"
// and the characters after the "::" are not recognized by the signal system.
//
// See
// https://developer.gnome.org/gobject/stable/gobject-The-Base-Object-Type.html#GObject-notify
// for background, and
// https://developer.gnome.org/gobject/stable/gobject-Signals.html#g-signal-new
// for the specification of valid signal names.
func TestConnectNotifySignal(t *testing.T) {
runtime.LockOSThread()
// Create any GObject that has defined properties.
spacing := 0
box, _ := gtk.BoxNew(gtk.ORIENTATION_HORIZONTAL, spacing)
// Connect to a "notify::" signal to listen on property changes.
box.Connect("notify::spacing", func() {
gtk.MainQuit()
})
glib.IdleAdd(func(s string) bool {
t.Log(s)
spacing++
box.SetSpacing(spacing)
return true
}, "IdleAdd executed")
gtk.Main()
}
func main() {
gtk.Init(nil)
win := setupWindow()
box, _ := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 0)
win.Add(box)
tv := setupTextView(box)
props := []*BoolProperty{
&BoolProperty{"cursor visible", (*tv).GetCursorVisible, (*tv).SetCursorVisible},
&BoolProperty{"editable", (*tv).GetEditable, (*tv).SetEditable},
&BoolProperty{"overwrite", (*tv).GetOverwrite, (*tv).SetOverwrite},
&BoolProperty{"accepts tab", (*tv).GetAcceptsTab, (*tv).SetAcceptsTab},
}
setupPropertyCheckboxes(tv, box, props)
win.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
win, e := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
if e != nil {
println(e.Error())
return
}
path, isTest := vdata.TestPathDefault()
var saveCall func(cftype.Builder)
if isTest {
saveCall = cfprint.Updated
} else {
saveCall = func(build cftype.Builder) { cfprint.Default(build, true) }
}
source := vdata.New(log.NewLog(log.Logs), win, saveCall)
build := vdata.TestInit(source, path)
source.SetGrouper(build)
glib.IdleAdd(packWindow(win, source, build))
gtk.Main()
}
func main() {
gtk.Init(&os.Args)
// Declarations
Window, _ = gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
RootBox, _ = gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 6)
TreeView, _ = gtk.TreeViewNew()
Entry, _ = gtk.EntryNew()
ListStore, _ = gtk.ListStoreNew(glib.TYPE_STRING)
// Window properties
Window.SetTitle("Products written in Go")
Window.Connect("destroy", gtk.MainQuit)
// TreeView properties
{
renderer, _ := gtk.CellRendererTextNew()
column, _ := gtk.TreeViewColumnNewWithAttribute("Value", renderer, "text", 0)
TreeView.AppendColumn(column)
}
TreeView.SetModel(ListStore)
// TreeView selection properties
sel, _ := TreeView.GetSelection()
sel.SetMode(gtk.SELECTION_MULTIPLE)
sel.Connect("changed", SelectionChanged)
// Packing
RootBox.PackStart(TreeView, true, true, 0)
RootBox.PackStart(Entry, false, false, 0)
Window.Add(RootBox)
// Populating list
// TODO: Add more values to the list
AppendMultipleToList("Go", "Docker", "CockroachDB")
Window.ShowAll()
gtk.Main()
}
func main() {
gtk.Init(nil)
// gui boilerplate
win, _ := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
da, _ := gtk.DrawingAreaNew()
win.Add(da)
win.SetTitle("Arrow keys")
win.Connect("destroy", gtk.MainQuit)
win.ShowAll()
// Data
unitSize := 20.0
x := 0.0
y := 0.0
keyMap := map[uint]func(){
KEY_LEFT: func() { x-- },
KEY_UP: func() { y-- },
KEY_RIGHT: func() { x++ },
KEY_DOWN: func() { y++ },
}
// Event handlers
da.Connect("draw", func(da *gtk.DrawingArea, cr *cairo.Context) {
cr.SetSourceRGB(0, 0, 0)
cr.Rectangle(x*unitSize, y*unitSize, unitSize, unitSize)
cr.Fill()
})
win.Connect("key-press-event", func(win *gtk.Window, ev *gdk.Event) {
keyEvent := &gdk.EventKey{ev}
if move, found := keyMap[keyEvent.KeyVal()]; found {
move()
win.QueueDraw()
}
})
gtk.Main()
}
func StartGUI(launcher launchers.Launcher, bootDescriptorPath string) (err error) {
log.Debug("Initializing GTK...")
gtkui.InitGTK()
log.Debug("GTK initialized")
guiOutcomeChannel := make(chan guiOutcomeStruct)
defer close(guiOutcomeChannel)
go backgroundOrchestrator(launcher, bootDescriptorPath, guiOutcomeChannel)
log.Debug("Starting GTK main loop...")
gtk.Main()
log.SetCallback(func(level logging.Level, message string) {})
log.Debug("GTK main loop terminated")
select {
case guiOutcome := <-guiOutcomeChannel:
log.Debug("Outcome retrieved from the GUI channel")
if guiOutcome.userInterface != nil && guiOutcome.userInterface.IsClosedByUser() {
return &engine.ExecutionCanceled{}
}
err = guiOutcome.err
if err != nil {
log.Warning("Err is: %v", err)
return err
}
log.Notice("OK")
return nil
default:
log.Debug("The user has manually closed the program")
return &engine.ExecutionCanceled{}
}
}
func TestWebView_LoadURI(t *testing.T) {
setup()
defer teardown()
responseOk := false
mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
w.Write([]byte("abc"))
responseOk = true
})
loadFinished := false
webView.Connect("load-failed", func() {
t.Errorf("load failed")
})
webView.Connect("load-changed", func(_ *glib.Object, loadEvent LoadEvent) {
switch loadEvent {
case LoadFinished:
loadFinished = true
gtk.MainQuit()
}
})
glib.IdleAdd(func() bool {
webView.LoadURI(server.URL)
return false
})
gtk.Main()
if !responseOk {
t.Error("!responseOk")
}
if !loadFinished {
t.Error("!loadFinished")
}
}