func main() {
var color string
openvg.Start(width, height)
openvg.Background(200, 200, 200)
for i := 0; i < niter; i++ {
x := random(0, width)
y := random(height/3, (height*2)/3)
r := random(0, 10000)
switch {
case r >= 0 && r <= 2500:
color = "white"
case r > 2500 && r <= 5000:
color = "maroon"
case r > 5000 && r <= 7500:
color = "gray"
case r > 7500 && r <= 10000:
color = "black"
}
openvg.FillColor(color, openvg.VGfloat(opacity))
openvg.Circle(openvg.VGfloat(x), openvg.VGfloat(y), openvg.VGfloat(size))
}
openvg.End()
bufio.NewReader(os.Stdin).ReadByte()
openvg.Finish()
}
// imgtest draws images at the corners and center
func imagetest(w, h int) {
openvg.Start(w, h)
imgw := 422
imgh := 238
fiw := float64(imgw)
fih := float64(imgh)
fw := float64(w)
fh := float64(h)
cx := (fw / 2) - (fiw / 2)
cy := (fh / 2) - (fih / 2)
ulx := 0.0
uly := fh - fih
urx := fw - fiw
ury := uly
llx := 0.0
lly := 0.0
lrx := urx
lry := lly
openvg.Start(w, h)
openvg.Background(0, 0, 0)
openvg.Image(cx, cy, imgw, imgh, "desert1.jpg")
openvg.Image(ulx, uly, imgw, imgh, "desert2.jpg")
openvg.Image(urx, ury, imgw, imgh, "desert3.jpg")
openvg.Image(llx, lly, imgw, imgh, "desert4.jpg")
openvg.Image(lrx, lry, imgw, imgh, "desert5.jpg")
openvg.End()
}
func main() {
var cx, cy, cw, ch, midy int
message := "Now is the time for all good men to come to the aid of the party"
w, h := openvg.Init()
var speed openvg.VGfloat = 15.0
var x openvg.VGfloat = 0
midy = (h / 2)
fontsize := w / 50
cx = 0
ch = fontsize * 2
cw = w
cy = midy - (ch / 2)
rx, ry, rw, rh := openvg.VGfloat(cx), openvg.VGfloat(cy), openvg.VGfloat(cw), openvg.VGfloat(ch)
// scroll the text, only in the clipping rectangle
for x = 0; x < rw+speed; x += speed {
openvg.Start(w, h)
openvg.Background(255, 255, 255)
openvg.FillRGB(0, 0, 0, .2)
openvg.Rect(rx, ry, rw, rh)
openvg.ClipRect(cx, cy, cw, ch)
openvg.Translate(x, ry+openvg.VGfloat(fontsize/2))
openvg.FillRGB(0, 0, 0, 1)
openvg.Text(0, 0, message, "sans", fontsize)
openvg.ClipEnd()
openvg.End()
}
bufio.NewReader(os.Stdin).ReadBytes('\n')
openvg.Finish()
os.Exit(0)
}
func paintBG(w, h openvg.VGfloat) {
if !showTrails {
openvg.Background(0, 0, 0)
return
}
openvg.FillRGB(0, 0, 0, 0.3)
openvg.Rect(0, 0, w, h)
}
// raspberry pi, scaled to the screen dimensions
func raspi(w, h int, s string) {
midx := float64(w) / 2
midy := float64(h) / 2
rw := midx
rh := (rw * 2) / 3
fontsize := w / 25
openvg.Start(w, h)
openvg.Background(255, 255, 255)
makepi(midx-(rw/2), midy-(rh/2), rw, rh)
openvg.FillRGB(128, 0, 0, 1)
openvg.TextMid(midx, midy-(rh/2)-float64(fontsize*2), s, "sans", fontsize)
openvg.End()
}
// raspberry pi, scaled to the screen dimensions
func main() {
w, h := openvg.Init()
midx := openvg.VGfloat(w) / 2
midy := openvg.VGfloat(h) / 2
rw := midx
rh := (rw * 2) / 3
fontsize := w / 25
openvg.Start(w, h)
openvg.Background(255, 255, 255)
makepi(midx-(rw/2), midy-(rh/2), rw, rh)
makepi(200, 100, 75, 50)
openvg.FillRGB(128, 0, 0, 1)
openvg.TextMid(midx, midy-(rh/2)-openvg.VGfloat(fontsize*2), "The Raspberry Pi", "sans", fontsize)
WaitEnd()
}
// sunearth shows the relative sizes of the sun and the earth
func sunearth(w, h int) {
var sun, earth, x, y float64
openvg.Start(w, h)
openvg.Background(0, 0, 0)
openvg.FillRGB(255, 255, 255, 1)
for i := 0; i < w/4; i++ {
x = randf(w)
y = randf(h)
openvg.Circle(x, y, 2)
}
earth = float64(w) * 0.010
sun = earth * 109
openvg.FillRGB(0, 0, 255, 1)
openvg.Circle(float64(w/3), float64(h-(h/10)), earth)
openvg.FillRGB(255, 255, 224, 1)
openvg.Circle(float64(w), 0, sun)
openvg.End()
}
// rotext draws text, rotated around the center of the screen, progressively faded
func rotext(w, h, n int, s string) {
fade := (100.0 / float64(n)) / 100.0
deg := 360.0 / float64(n)
x := float64(w) / 2.0
y := float64(h) / 2.0
alpha := 1.0
size := w / 8
openvg.Start(w, h)
openvg.Background(0, 0, 0)
openvg.Translate(x, y)
for i := 0; i < n; i++ {
openvg.FillRGB(255, 255, 255, alpha)
openvg.Text(0, 0, s, "serif", size)
alpha -= fade // fade
size += n // enlarge
openvg.Rotate(deg)
}
openvg.End()
}
// fontrange shows a range of fonts
func fontrange(w, h int) {
var x, lx, length float64
y := float64(h) / 2.0
w2 := float64(w) / 2.0
spacing := 50.0
s2 := spacing / 2.0
sizes := []int{6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 21, 24, 36, 48, 60, 72, 96}
openvg.Start(w, h)
openvg.Background(255, 255, 255)
// compute the length so we can center
length = 0.0
for _, s := range sizes {
length += float64(s) + spacing
}
length -= spacing
lx = w2 - (length / 2) // center point
// for each size, display a character and label
x = lx
for _, s := range sizes {
openvg.FillRGB(128, 0, 0, 1)
openvg.TextMid(x, y, "a", "serif", s)
openvg.FillRGB(128, 128, 128, 1)
openvg.TextMid(x, y-spacing, fmt.Sprintf("%d", s), "sans", 16)
x += float64(s) + spacing
}
// draw a openvg.Line below the characters, a curve above
x -= spacing
openvg.StrokeRGB(150, 150, 150, 0.5)
openvg.StrokeWidth(2)
openvg.Line(lx, y-s2, x, y-s2)
openvg.FillRGB(255, 255, 255, 1)
openvg.Qbezier(lx, y+s2, x, y+s2, x, y+(spacing*3))
openvg.End()
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stdout,
`usage: %s [ opts ] image-path
Set specified image as an overlay screen via OpenVG lib.
Default is to put this image to the center.
`, os.Args[0])
flag.PrintDefaults()
}
var resize bool
var bg_color string
flag.BoolVar(&resize, "resize", false, `Resize image to fit the screen (using "convert" binary.`)
flag.StringVar(&bg_color, "bg-color", "",
`Background color to use with centered image, in RRGGBB (hex, e.g. "aabbcc") format.`)
flag.Parse()
if flag.NArg() != 1 {
log.Print("ERROR: Exactly one image-path argument must be specified.")
flag.Usage()
}
var r, g, b uint8
var err error
if len(bg_color) == 0 {
r, g, b = 0, 0, 0
} else if len(bg_color) == 6 {
n, err := strconv.ParseUint(bg_color[:2], 16, 8)
if err == nil {
r = uint8(n)
n, err = strconv.ParseUint(bg_color[2:4], 16, 8)
}
if err == nil {
g = uint8(n)
n, err = strconv.ParseUint(bg_color[4:6], 16, 8)
}
if err == nil {
b = uint8(n)
}
}
if err != nil {
log.Fatalf("ERROR: Failed to parse bg-color value (%v): %v", bg_color, err)
}
image_path := flag.Args()[0]
exit_code := 0
defer func() {
os.Exit(exit_code)
}()
openvg.SaveTerm()
w, h := openvg.Init()
openvg.RawTerm()
defer openvg.Finish()
defer openvg.RestoreTerm()
image_conf, err := get_image_conf(image_path)
if err == nil && resize && (image_conf.Width != w || image_conf.Height != h) {
image_path, err = resize_image(w, h, image_path)
}
if err != nil {
log.Printf("ERROR: Failed to process image (%v): %v", image_path, err)
exit_code = 1
} else {
sig_chan := make(chan os.Signal, 1)
signal.Notify(sig_chan, os.Interrupt, os.Kill,
syscall.SIGHUP, syscall.SIGTERM, syscall.SIGALRM)
openvg.Start(w, h)
openvg.Background(r, g, b)
if resize {
openvg.Image(0, 0, w, h, image_path)
} else {
x, y := openvg.VGfloat(w)/2-openvg.VGfloat(image_conf.Width)/2,
openvg.VGfloat(h)/2-openvg.VGfloat(image_conf.Height)/2
openvg.Image(x, y, image_conf.Width, image_conf.Height, image_path)
}
openvg.End()
_ = <-sig_chan
}
}
