func main() {
flag.Usage = usage
flag.Parse()
switch {
default:
fmt.Println("Using all Go packages in GOPATH.")
goPackages = &exp14.GoPackages{SkipGoroot: true} // All Go packages in GOPATH (not including GOROOT).
updater = repo.GopathUpdater{GoPackages: goPackages}
case *stdinFlag:
fmt.Println("Reading the list of newline separated Go packages from stdin.")
goPackages = &exp14.GoPackagesFromReader{Reader: os.Stdin}
updater = repo.GopathUpdater{GoPackages: goPackages}
case *godepsFlag != "":
fmt.Println("Reading the list of Go packages from Godeps.json file:", *godepsFlag)
goPackages = newGoPackagesFromGodeps(*godepsFlag)
updater = nil
case *govendorFlag != "":
fmt.Println("Reading the list of Go packages from vendor.json file:", *govendorFlag)
goPackages = newGoPackagesFromGovendor(*govendorFlag)
updater = nil
}
err := loadTemplates()
if err != nil {
log.Fatalln("loadTemplates:", err)
}
http.HandleFunc("/index.html", mainHandler)
http.Handle("/favicon.ico", http.NotFoundHandler())
http.Handle("/assets/", gzip_file_server.New(assets))
http.Handle("/opened", websocket.Handler(openedHandler)) // Exit server when client tab is closed.
if updater != nil {
http.HandleFunc("/-/update", updateHandler)
go updateWorker()
}
// Start listening first.
listener, err := net.Listen("tcp", *httpFlag)
if err != nil {
log.Fatalf("failed to listen on %q: %v\n", *httpFlag, err)
}
switch production {
case true:
// Open a browser tab and navigate to the main page.
go u4.Open("http://" + *httpFlag + "/index.html")
case false:
updater = repo.MockUpdater{}
}
fmt.Println("Go Package Store server is running at http://" + *httpFlag + "/index.html.")
err = http.Serve(listener, nil)
if err != nil {
log.Fatalln(err)
}
}
func instantShareHandler() {
fmt.Println("request URL")
resp, err := httpClient.Get(*hostFlag + "/api/getfilename?ext=" + clipboard.extension)
if err != nil {
trayhost.Notification{Title: "Upload Failed", Body: err.Error()}.Display()
log.Println(err)
return
}
defer resp.Body.Close()
filename, err := ioutil.ReadAll(resp.Body)
if err != nil {
trayhost.Notification{Title: "Upload Failed", Body: err.Error()}.Display()
log.Println(err)
return
}
fmt.Println("display/put URL in clipboard")
url := *hostFlag + "/" + string(filename)
trayhost.SetClipboardText(url)
trayhost.Notification{
Title: "Success",
Body: url,
Image: notificationThumbnail,
Timeout: 3 * time.Second,
Handler: func() {
// On click, open the displayed URL.
u4.Open(url)
},
}.Display()
fmt.Println("upload image in background of size", len(clipboard.bytes))
go func(b []byte) {
req, err := http.NewRequest("PUT", url, bytes.NewReader(b))
if err != nil {
log.Println(err)
return
}
req.Header.Set("Content-Type", "application/octet-stream")
resp, err := http.DefaultClient.Do(req)
if err != nil {
log.Println(err)
return
}
_ = resp.Body.Close()
fmt.Println("done")
}(clipboard.bytes)
}
func Test(t *testing.T) {
http.Handle("/script.go.js", gopherjs_http.StaticGoFiles("./frontend.go"))
{
defaultValue := false
queryParameter := "some-optional-thing"
http.HandleFunc("/index.html", func(w http.ResponseWriter, req *http.Request) {
query := req.URL.Query()
checkboxHtml := checkbox.New(defaultValue, query, queryParameter)
io.WriteString(w, `<html><head><script type="text/javascript" src="/script.go.js"></script></head><body>`+string(checkboxHtml)+"</body></html>")
})
}
ts := httptest.NewServer(nil)
defer ts.Close()
u4.Open(ts.URL + "/index.html")
select {}
}
func Test(t *testing.T) {
http.Handle("/script.go.js", gopherjs_http.StaticGoFiles("./frontend.go"))
{
options := []string{"option one", "option two (default)", "option three", "option four", "option five"}
defaultOption := "option two (default)"
queryParameter := "parameter"
http.HandleFunc("/index.html", func(w http.ResponseWriter, req *http.Request) {
query := req.URL.Query()
selectMenuHtml := select_menu.New(options, defaultOption, query, queryParameter)
io.WriteString(w, `<html><head><script type="text/javascript" src="/script.go.js"></script></head><body>`+string(selectMenuHtml)+"</body></html>")
})
}
ts := httptest.NewServer(nil)
defer ts.Close()
u4.Open(ts.URL + "/index.html")
select {}
}
func main() {
flag.Parse()
runtime.LockOSThread()
menuItems := []trayhost.MenuItem{
trayhost.MenuItem{
Title: "Instant Share",
Enabled: instantShareEnabled,
Handler: instantShareHandler,
},
trayhost.SeparatorMenuItem(),
trayhost.MenuItem{
Title: "Quit",
Handler: trayhost.Exit,
},
}
if *debugFlag {
menuItems = append(menuItems,
trayhost.SeparatorMenuItem(),
trayhost.MenuItem{
Title: "Debug: Get Clipboard Content",
Handler: func() {
cc, err := trayhost.GetClipboardContent()
fmt.Printf("GetClipboardContent() error: %v\n", err)
fmt.Printf("Text: %q\n", cc.Text)
fmt.Printf("Image: %v len(%v)\n", cc.Image.Kind, len(cc.Image.Bytes))
fmt.Printf("Files: len(%v) %v\n", len(cc.Files), cc.Files)
},
},
trayhost.MenuItem{
Title: "Debug: Set Clipboard Text",
Handler: func() {
trayhost.SetClipboardText("http://www.example.com/image.png")
},
},
trayhost.MenuItem{
Title: "Debug: Notification",
Handler: func() {
handler := func() {
u4.Open("http://www.example.com/image.png")
}
notification := trayhost.Notification{Title: "Success", Body: "http://www.example.com/image.png", Timeout: 3 * time.Second, Handler: handler}
//trayhost.Notification{Title: "Upload Failed", Body: "error description goes here"}.Display()
if cc, err := trayhost.GetClipboardContent(); err == nil && cc.Image.Kind != "" {
notification.Image = cc.Image
}
notification.Display()
},
},
)
}
// TODO: Create a real icon and bake it into the binary.
// TODO: Optionally, if non-Retina pixel perfection is required, generate or load 1x image and supply that as a second representation.
iconData, err := ioutil.ReadFile("./[email protected]")
if err != nil {
panic(err)
}
fmt.Println("Starting.")
trayhost.Initialize("Instant Share", iconData, menuItems)
trayhost.EnterLoop()
fmt.Println("Exiting.")
}