func main() { driver.Main(func(s screen.Screen) { w, err := s.NewWindow(nil) if err != nil { log.Fatal(err) } defer w.Release() winSize := image.Point{256, 256} b, err := s.NewBuffer(winSize) if err != nil { log.Fatal(err) } defer b.Release() drawGradient(b.RGBA()) t, err := s.NewTexture(winSize) if err != nil { log.Fatal(err) } defer t.Release() t.Upload(image.Point{}, b, b.Bounds(), w) var sz size.Event for e := range w.Events() { switch e := e.(type) { default: // TODO: be more interesting. fmt.Printf("got %#v\n", e) case key.Event: fmt.Printf("got %v\n", e) if e.Code == key.CodeEscape { return } case paint.Event: w.Fill(sz.Bounds(), blue0, draw.Src) w.Fill(sz.Bounds().Inset(10), blue1, draw.Src) w.Upload(image.Point{}, b, b.Bounds(), w) c := math.Cos(math.Pi / 6) s := math.Sin(math.Pi / 6) w.Draw(f64.Aff3{ +c, -s, 100, +s, +c, 200, }, t, t.Bounds(), screen.Over, nil) w.Publish() case screen.UploadedEvent: // No-op. case size.Event: sz = e case error: log.Print(e) } } }) }
func main() { flag.Parse() rand.Seed(int64(time.Now().Nanosecond())) board := NewBoard(9, *scale) driver.Main(func(s screen.Screen) { w, err := s.NewWindow(nil) if err != nil { log.Fatal(err) } defer w.Release() var b screen.Buffer defer func() { if b != nil { b.Release() } }() for { switch e := w.NextEvent().(type) { case lifecycle.Event: if e.To == lifecycle.StageDead { return } case key.Event: if e.Code == key.CodeEscape { return } case mouse.Event: if e.Direction == mouse.DirRelease && e.Button != 0 { board.click(b.RGBA(), int(e.X), int(e.Y), int(e.Button)) w.Send(paint.Event{}) } case paint.Event: w.Upload(image.Point{}, b, b.Bounds()) w.Publish() case size.Event: // TODO: Set board size. if b != nil { b.Release() } b, err = s.NewBuffer(e.Size()) if err != nil { log.Fatal(err) } render(b.RGBA(), board) case error: log.Print(e) } } }) }
func Main(f func(NewFunc)) { driver.Main(func(s screen.Screen) { ctxt := context{ screen: s, } f(ctxt.new) }) }
func main() { driver.Main(func(s screen.Screen) { w, err := s.NewWindow(nil) if err != nil { log.Fatal(err) } defer w.Release() winSize := image.Point{1000, 1000} b, err := s.NewBuffer(winSize) if err != nil { log.Fatal(err) } defer b.Release() drawGradient(b.RGBA()) t, err := s.NewTexture(winSize) if err != nil { log.Fatal(err) } defer t.Release() t.Upload(image.Point{}, b, b.Bounds()) var sz size.Event for e := range w.Events() { // This print message is to help programmers learn what events this // example program generates. A real program shouldn't print such // messages; they're not important to end users. format := "got %#v\n" if _, ok := e.(fmt.Stringer); ok { format = "got %v\n" } fmt.Printf(format, e) switch e := e.(type) { case lifecycle.Event: if e.To == lifecycle.StageDead { return } case key.Event: if e.Code == key.CodeEscape { return } case paint.Event: w.Fill(sz.Bounds(), blue0, draw.Src) w.Fill(sz.Bounds().Inset(10), blue1, draw.Src) w.Upload(image.Point{}, b, b.Bounds()) w.Publish() case size.Event: sz = e case error: log.Print(e) } } }) }
func main() { driver.Main(func(s screen.Screen) { w, err := s.NewWindow(nil) if err != nil { log.Fatal(err) } defer w.Release() winSize := image.Point{256, 256} b, err := s.NewBuffer(winSize) if err != nil { log.Fatal(err) } defer b.Release() drawGradient(b.RGBA()) t, err := s.NewTexture(winSize) if err != nil { log.Fatal(err) } defer t.Release() t.Upload(image.Point{}, b, b.Bounds(), w) var sz size.Event for e := range w.Events() { switch e := e.(type) { default: // TODO: be more interesting. fmt.Printf("got event %#v\n", e) case size.Event: sz = e case paint.Event: wBounds := image.Rectangle{Max: image.Point{sz.WidthPx, sz.HeightPx}} w.Fill(wBounds, color.RGBA{0x00, 0x00, 0x3f, 0xff}, draw.Src) w.Upload(image.Point{}, b, b.Bounds(), w) w.Draw(f64.Aff3{ 1, 0, 100, 0, 1, 200, }, t, t.Bounds(), screen.Over, nil) w.EndPaint(e) case screen.UploadedEvent: // No-op. case error: log.Print(e) } } }) }
func main() { driver.Main(func(s screen.Screen) { w, err := s.NewWindow(&screen.NewWindowOptions{ Width: 480, Height: 640, }) Panic(err) g := Game{} g.Init(s, w) publish := false for { switch e := w.NextEvent().(type) { case lifecycle.Event: if e.To == lifecycle.StageDead { g.Exit() return } case key.Event: fmt.Printf("key\n") g.Key(e) case mouse.Event: fmt.Printf("%f, %f\n", e.X, e.Y) case paint.Event: fmt.Printf("paint %t\n", e.External) publish = true case size.Event: fmt.Printf("resize %d, %d\n", e.WidthPx, e.HeightPx) g.Resize(e.WidthPx, e.HeightPx) } if publish { publish = false g.Draw() } } }) }
func Main(f func(driver.Display)) { shiny.Main(func(s screen.Screen) { Run(s, f) }) }
func main() { driver.Main(func(s screen.Screen) { w, err := s.NewWindow(nil) if err != nil { log.Fatal(err) } defer w.Release() var ( pool = &tilePool{ screen: s, drawRGBA: drawRGBA, m: map[image.Point]*tilePoolEntry{}, } dragging bool paintPending bool drag image.Point origin image.Point sz size.Event ) for e := range w.Events() { switch e := e.(type) { case key.Event: if e.Code == key.CodeEscape { return } case mouse.Event: p := image.Point{X: int(e.X), Y: int(e.Y)} if e.Button == mouse.ButtonLeft && e.Direction != mouse.DirNone { dragging = e.Direction == mouse.DirPress drag = p } if !dragging { break } origin = origin.Sub(p.Sub(drag)) drag = p if origin.X < 0 { origin.X = 0 } if origin.Y < 0 { origin.Y = 0 } if !paintPending { paintPending = true w.Send(paint.Event{}) } case paint.Event: generation++ var wg sync.WaitGroup for y := -(origin.Y & 0xff); y < sz.HeightPx; y += 256 { for x := -(origin.X & 0xff); x < sz.WidthPx; x += 256 { wg.Add(1) go drawTile(&wg, w, pool, origin, x, y) } } wg.Wait() w.Publish() paintPending = false pool.releaseUnused() case size.Event: sz = e case error: log.Print(e) } } }) }
func main() { log.SetFlags(0) log.SetPrefix("preview: ") flag.Usage = func() { log.Print("Usage: preview [options] file") flag.PrintDefaults() } flag.Parse() if flag.NArg() != 1 { flag.Usage() os.Exit(1) } if *prof != "" { log.Print("profile mode: will write out CPU profile after 5 seconds") f, err := os.Create(*prof) if err != nil { log.Fatal(err) } err = pprof.StartCPUProfile(f) if err != nil { log.Fatal(err) } go func() { time.Sleep(5 * time.Second) pprof.StopCPUProfile() log.Print("done writing CPU profile") }() } f, err := os.Open(flag.Arg(0)) if err != nil { log.Fatal(err) } log.Print("parsing STL...") t := time.Now() stl, err := slice.Parse(f) if err != nil { log.Fatal(err) } f.Close() log.Printf("parsing took %v", time.Now().Sub(t)) if err := sliceSTL(stl); err != nil { log.Fatal(err) } imgs, err := drawLayers(stl) if err != nil { log.Fatal(err) } r := imgs[0].Bounds() log.Print("Launching UI...") driver.Main(func(s screen.Screen) { w, err := s.NewWindow(&screen.NewWindowOptions{ Width: r.Dx(), Height: r.Dy(), }) if err != nil { log.Fatal(err) } defer w.Release() r := image.Rect(int(stl.Min.X), int(stl.Min.Y), int(stl.Max.X)+1, int(stl.Max.Y)+1) winSize := r.Size() var b screen.Buffer defer func() { if b != nil { b.Release() } }() var sz size.Event var lastClick mouse.Event var layer int redraw := func() { draw.Draw(b.RGBA(), b.RGBA().Bounds(), imgs[layer], imgs[layer].Bounds().Min, draw.Src) drawLayerNumber(b.RGBA(), layer) w.Send(paint.Event{}) } for e := range w.Events() { switch e := e.(type) { default: case mouse.Event: if e.Button == mouse.ButtonLeft { if e.Y > lastClick.Y && layer < len(imgs)-1 { layer++ redraw() } else if e.Y < lastClick.Y && layer > 0 { layer-- redraw() } lastClick = e } case key.Event: log.Printf("key: %v", e) if e.Code == key.CodeEscape { log.Print("quitting") return } case paint.Event: w.Upload(image.Point{}, b, b.Bounds(), w) w.Publish() case screen.UploadedEvent: // No-op. case size.Event: sz = e if b != nil { b.Release() } winSize = image.Point{sz.WidthPx, sz.HeightPx} b, err = s.NewBuffer(winSize) if err != nil { log.Fatal(err) } redraw() case error: log.Printf("error: %v", e) } } }) }
func main() { flag.Parse() rand.Seed(int64(time.Now().Nanosecond())) board := NewBoard(9, *scale) driver.Main(func(s screen.Screen) { w, err := s.NewWindow(nil) if err != nil { log.Fatal(err) } defer w.Release() var b screen.Buffer defer func() { if b != nil { b.Release() } }() for e := range w.Events() { switch e := e.(type) { case mouse.Event: if e.Direction == mouse.DirRelease && e.Button != 0 { board.click(b.RGBA(), int(e.X), int(e.Y), int(e.Button)) dirty = true } case key.Event: if e.Code == key.CodeEscape { return } case paint.Event: // TODO: we shouldn't rely on the library sending us a constant // stream of paint events. If we're dirty, we should just draw // on the window and then call w.Publish. // // TODO: This check should save CPU time but causes flicker on Darwin. //if dirty && !uploading { w.Upload(image.Point{}, b, b.Bounds(), w) // TODO: On Darwin always writes to 0,0, ignoring first arg. dirty = false uploading = true //} w.Publish() case screen.UploadedEvent: // No-op. uploading = false case size.Event: // TODO: Set board size. if b != nil { b.Release() } b, err = s.NewBuffer(e.Size()) if err != nil { log.Fatal(err) } render(b.RGBA(), board) case error: log.Print(e) } } }) }
func main() { // Run the CPU profile if we're instructed to. if len(flagProfile) > 0 { f, err := os.Create(flagProfile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } // Whoops! if flag.NArg() == 0 { fmt.Fprint(os.Stderr, "\n") log.Print("No images specified.\n\n") usage() } driver.Main(func(s screen.Screen) { // Decode all images (in parallel). names, imgs := decodeImages(findFiles(flag.Args())) // Die now if we don't have any images! if len(imgs) == 0 { log.Fatal("No images specified could be shown. Quitting...") } winSize := image.Point{flagWidth, flagHeight} // Auto-size the window if appropriate. if flagAutoResize { log.Printf(">>> img[%s]...\n", names[0]) b := imgs[0].Bounds() winSize = image.Point{b.Dx(), b.Dy()} } w, err := s.NewWindow(&screen.NewWindowOptions{ Width: winSize.X, Height: winSize.Y, }) if err != nil { log.Fatal(err) } defer w.Release() b, err := s.NewBuffer(winSize) if err != nil { log.Fatal(err) } defer b.Release() w.Fill(b.Bounds(), color.White, draw.Src) w.Publish() var sz size.Event var i int // index of image to display for { e := w.NextEvent() switch e := e.(type) { default: case mouse.Event: case key.Event: repaint := false switch e.Code { case key.CodeEscape, key.CodeQ: return case key.CodeRightArrow: if e.Direction == key.DirPress { if i == len(imgs)-1 { i = -1 } i++ repaint = true b.Release() b, err = s.NewBuffer(sz.Size()) if err != nil { log.Fatal(err) } } case key.CodeLeftArrow: if e.Direction == key.DirPress { if i == 0 { i = len(imgs) } i-- repaint = true b, err = s.NewBuffer(sz.Size()) if err != nil { log.Fatal(err) } } case key.CodeR: if e.Direction == key.DirPress { // resize to current image r := imgs[i].Bounds() sz.HeightPx = r.Dy() sz.WidthPx = r.Dx() repaint = true b, err = s.NewBuffer(sz.Size()) if err != nil { log.Fatal(err) } w.Publish() } } if repaint { w.Send(paint.Event{}) } case paint.Event: img := imgs[i] draw.Draw(b.RGBA(), b.Bounds(), img, image.Point{}, draw.Src) dp := vpCenter(img, sz.WidthPx, sz.HeightPx) zero := image.Point{} if dp != zero { w.Fill(sz.Bounds(), color.Black, draw.Src) } w.Upload(dp, b, b.Bounds()) case size.Event: sz = e case error: log.Print(e) } } }) }