func main() { thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://localhost:8089", }) thrustWindow.Show() thrustWindow.Maximize() thrustWindow.Focus() // Lets do a window timeout go func() { <-time.After(time.Second * 5) thrustWindow.Close() thrust.Exit() }() // In lieu of something like an http server, we need to lock this thread // in order to keep it open, and keep the process running. // Dont worry we use runtime.Gosched :) thrust.LockThread() }
func main() { /* use basic setup */ thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() /* Start of Basic Session Tutorial area */ // arguments (incognito, useDisk) mysession := thrust.NewSession(false, false, "./cache") //mysession.SetInvokable(*session.NewDummySession()) /* Modified basic_window, where we provide, a session argument to NewWindow. */ thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://breach.cc/", Session: mysession, }) thrustWindow.Show() thrustWindow.Maximize() thrustWindow.Focus() // BLOCKING - Dont run before youve excuted all commands you want first. thrust.LockThread() }
func main() { http.HandleFunc("/", handler) thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://localhost:8080/", }) thrustWindow.Show() thrustWindow.Maximize() thrustWindow.Focus() thrustWindow.OpenDevtools() _, err := thrustWindow.HandleRemote(func(er commands.EventResult, this *window.Window) { fmt.Println("RemoteMessage Recieved:", er.Message.Payload) // Keep in mind once we have the message, lets say its json of some new type we made, // We can unmarshal it to that type. // Same goes for the other way around. this.SendRemoteMessage("boop") }) if err != nil { fmt.Println(err) thrust.Exit() } // See, we dont use thrust.LockThread() because we now have something holding the process open http.ListenAndServe(":8080", nil) }
func main() { thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://breach.cc/", HasFrame: true, }) thrustWindow.Show() thrustWindow.Focus() thrustWindow.HandleEvent("closed", func(cr commands.EventResult) { fmt.Println("Close Event Occured") }) // Lets do a window timeout go func() { <-time.After(time.Second * 5) thrustWindow.Close() thrust.Exit() }() // In lieu of something like an http server, we need to lock this thread // in order to keep it open, and keep the process running. // Dont worry we use runtime.Gosched :) thrust.LockThread() }
func main() { thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://breach.cc/", }) thrustWindow.Show() thrustWindow.Maximize() thrustWindow.Focus() // make our top menus //applicationMenu, is essentially the menu bar applicationMenu := thrust.NewMenu() //applicationMenuRoot is the first menu, on darwin this is always named the name of your application. applicationMenuRoot := thrust.NewMenu() //File menu is our second menu fileMenu := thrust.NewMenu() // Lets build our root menu. // the first argument to AddItem is a CommandID // A CommandID is used by Thrust Core to communicate back results and events. applicationMenuRoot.AddItem(1, "About") applicationMenuRoot.RegisterEventHandlerByCommandID(1, func(reply commands.CommandResponse, item *menu.MenuItem) { fmt.Println("About Handled") }) // Now for the File menu fileMenu.AddItem(2, "Open") fileMenu.RegisterEventHandlerByCommandID(2, func(reply commands.CommandResponse, item *menu.MenuItem) { fmt.Println("Open Handled") }) fileMenu.AddItem(3, "Edit") fileMenu.AddSeparator() fileMenu.AddItem(4, "Close") fileMenu.RegisterEventHandlerByCommandID(4, func(reply commands.CommandResponse, item *menu.MenuItem) { fmt.Println("Close Event Handled") thrust.Exit() }) // Now we just need to plumb our menus together any way we want. applicationMenu.AddSubmenu(5, "Application", applicationMenuRoot) applicationMenu.AddSubmenu(6, "File", fileMenu) // Remember how in basic_browser, Window automatically self registered with the dispatcher. // unfortunately we have no such luck here. // I suppose this method could be added as an effect of SetApplicationMenu, but the effects of that need to be // Ironed out. // However, as least we only need to register the top level menu for events, all sub menus will delegate for the top menu. // Now we set it as our application Menu applicationMenu.SetApplicationMenu() // BLOCKING - Dont run before youve excuted all commands you want first. thrust.LockThread() }
func main() { http.HandleFunc("/", handler) thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() mysession := thrust.NewSession(false, false, "cache") thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://localhost:8080/", Session: mysession, }) thrustWindow.Show() thrustWindow.Maximize() thrustWindow.Focus() // See, we dont use thrust.LockThread() because we now have something holding the process open http.ListenAndServe(":8080", nil) }
func main() { thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://breach.cc/", }) thrustWindow.Show() thrustWindow.Maximize() thrustWindow.Focus() thrustWindow.OpenDevtools() // Lets do a window timeout go func() { <-time.After(time.Second * 10) thrustWindow.CloseDevtools() }() // BLOCKING - Dont run before youve excuted all commands you want first thrust.LockThread() }
func main() { thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://breach.cc/", }) thrustWindow.Show() thrustWindow.Maximize() thrustWindow.Focus() thrustWindow2 := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://google.com/", }) thrustWindow2.Show() thrustWindow2.Focus() // BLOCKING - Dont run before youve excuted all commands you want first. thrust.LockThread() }
func main() { /* use basic setup */ thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() /* Start of Advanced Session Tutorial. We are going to set the Override value to true as ooposed to the false used in basic_session. This will cause ThrustCore to try to invoke methods from us. Look down below func main to find our session class. */ mysession := thrust.NewSession(false, true, "session_cache") mysession.SetInvokable(NewSimpleSession()) /* Modified basic_window, where we provide, a session argument to NewWindow. */ thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://breach.cc/", Session: mysession, }) thrustWindow.Show() thrustWindow.Maximize() thrustWindow.Focus() // In lieu of something like an http server, we need to lock this thread // in order to keep it open, and keep the process running. // Dont worry we use runtime.Gosched :) thrust.LockThread() }
/* This tutorial teaches how to handle global events. You can even use this to track menu/window/session etc. events, if you store your bindings somewhere and track the ids. Check package thrust for the acceptable handler definitions. */ func main() { thrust.InitLogger() // Set any Custom Provisioners before Start thrust.SetProvisioner(tutorial.NewTutorialProvisioner()) // thrust.Start() must always come before any bindings are created. thrust.Start() thrustWindow := thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://rbc.ru/", }) thrustWindow.Show() thrustWindow.Close() thrustWindow = thrust.NewWindow(thrust.WindowOptions{ RootUrl: "http://google.com/", }) thrustWindow.Show() /* Here we use an EventResult Callback, it provides us a little less data than a ComandResponse cb however, its good for if we know we dont need to worry about targetids. Like understanding which window was focuses, just that there is a window, that was focused. */ onfocus, err := thrust.NewEventHandler("focus", func(er commands.EventResult) { fmt.Println("Focus Event Occured") }) fmt.Println(onfocus) if err != nil { fmt.Println(err) connection.CleanExit() } /* Note blur does not seem to be triggered by unfocus only by actually clicking the window, and then clicking somewhere else. */ onblur, err := thrust.NewEventHandler("blur", func(er commands.EventResult) { fmt.Println("Blur Event Occured") }) fmt.Println(onblur) if err != nil { fmt.Println(err) connection.CleanExit() } onclose, err := thrust.NewEventHandler("close", func(er commands.EventResult) { fmt.Println("close++++++++++") }) fmt.Println(onclose) /* Here we use a CommandResponse callback just because we can, it provides us more data than the EventResult callback */ /*onclose, err := thrust.NewEventHandler("closed", func(cr commands.EventResult) { fmt.Println("Close Event Occured") })*/ //fmt.Println(onclose) if err != nil { fmt.Println(err) connection.CleanExit() } /* Lets say we just want to log all events */ onanything, err := thrust.NewEventHandler("*", func(cr commands.CommandResponse) { cr_marshaled, err := json.Marshal(cr) if err != nil { fmt.Println(err) } else { fmt.Println(fmt.Sprintf("======Event(%s %s) - Signaled by Command (%s)", cr.TargetID, cr.Type, cr_marshaled)) } }) fmt.Println(onanything) if err != nil { fmt.Println(err) connection.CleanExit() } /*time.AfterFunc(time.Second, func() { thrustWindow.Focus() }) time.AfterFunc(time.Second*10, func() { thrustWindow.UnFocus() }) /*time.AfterFunc(time.Second*3, func() { thrustWindow.Close() })*/ // Lets do a window timeout /*go func() { <-time.After(time.Second * 5) connection.CleanExit() }()*/ // BLOCKING - Dont run before youve excuted all commands you want first thrust.LockThread() }