// tb draws a block of text
func tb(w, h int) {
para := []string{
"For lo,",
"the winter is past,",
"the rain is over and gone",
"the flowers appear on the earth;",
"the time for the singing of birds is come,",
"and the voice of the turtle is heard in our land",
}
tmargin := openvg.VGfloat(w) * 0.50
lmargin := openvg.VGfloat(w) * 0.10
top := openvg.VGfloat(h) * .9
mid := openvg.VGfloat(h) * .6
bot := openvg.VGfloat(h) * .3
fontsize := 24
leading := openvg.VGfloat(40.0)
lfontsize := fontsize * 2
midb := ((leading * 2) + (leading / 2)) - openvg.VGfloat(lfontsize/2)
openvg.Start(w, h)
openvg.FillRGB(49, 79, 79, 1)
textlines(tmargin, top, para, "serif", fontsize, leading)
textlines(tmargin, mid, para, "sans", fontsize, leading)
textlines(tmargin, bot, para, "mono", fontsize, leading)
openvg.Text(lmargin, top-midb, "Serif", "sans", lfontsize)
openvg.Text(lmargin, mid-midb, "Sans", "sans", lfontsize)
openvg.Text(lmargin, bot-midb, "Mono", "sans", lfontsize)
openvg.End()
}
// imgtest draws images at the corners and center
func imagetest(w, h int) {
openvg.Start(w, h)
imgw := 422
imgh := 238
fiw := openvg.VGfloat(imgw)
fih := openvg.VGfloat(imgh)
fw := openvg.VGfloat(w)
fh := openvg.VGfloat(h)
vgzero := openvg.VGfloat(0.0)
cx := (fw / 2) - (fiw / 2)
cy := (fh / 2) - (fih / 2)
ulx := vgzero
uly := fh - fih
urx := fw - fiw
ury := uly
llx := vgzero
lly := vgzero
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()
}
// rshapes draws shapes with random colors, openvg.Strokes, and sizes.
func rshapes(width, height, n int) {
var sx, sy, cx, cy, px, py, ex, ey, pox, poy openvg.VGfloat
np := 10
polyx := make([]openvg.VGfloat, np)
polyy := make([]openvg.VGfloat, np)
openvg.Start(width, height)
for i := 0; i < n; i++ {
openvg.FillRGB(randcolor(), randcolor(), randcolor(), openvg.VGfloat(rand.Float32()))
openvg.Ellipse(randf(width), randf(height), randf(200), randf(100))
openvg.Circle(randf(width), randf(height), randf(100))
openvg.Rect(randf(width), randf(height), randf(200), randf(100))
openvg.Arc(randf(width), randf(height), randf(200), randf(200), randf(360), randf(360))
sx = randf(width)
sy = randf(height)
openvg.StrokeRGB(randcolor(), randcolor(), randcolor(), 1)
openvg.StrokeWidth(randf(5))
openvg.Line(sx, sy, sx+randf(200), sy+randf(100))
openvg.StrokeWidth(0)
sx = randf(width)
sy = randf(height)
ex = sx + randf(200)
ey = sy
cx = sx + ((ex - sx) / 2.0)
cy = sy + randf(100)
openvg.Qbezier(sx, sy, cx, cy, ex, ey)
sx = randf(width)
sy = randf(height)
ex = sx + randf(200)
ey = sy
cx = sx + ((ex - sx) / 2.0)
cy = sy + randf(100)
px = cx
py = sy - randf(100)
openvg.Cbezier(sx, sy, cx, cy, px, py, ex, ey)
pox = randf(width)
poy = randf(height)
for j := 0; j < np; j++ {
polyx[j] = pox + randf(200)
polyy[j] = poy + randf(100)
}
openvg.Polygon(polyx, polyy) // , np)
pox = randf(width)
poy = randf(height)
for j := 0; j < np; j++ {
polyx[j] = pox + randf(200)
polyy[j] = poy + randf(100)
}
openvg.Polyline(polyx, polyy) // , np)
}
openvg.FillRGB(128, 0, 0, 1)
openvg.Text(20, 20, "OpenVG on the Raspberry Pi", "sans", 32)
openvg.End()
}
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()
}
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 = 0.5
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)
}
// loadimage loads all the images of the deck into a map for later display
func loadimage(d deck.Deck, m map[string]image.Image) {
firstrun++
w, h := d.Canvas.Width, d.Canvas.Height
cw := openvg.VGfloat(w)
ch := openvg.VGfloat(h)
msize := int(cw * .01)
mx := cw / 2
my := ch * 0.05
mbg := "white"
mfg := "black"
for ns, s := range d.Slide {
for ni, i := range s.Image {
if !modfile(i.Name, StartTime) {
continue
}
openvg.Start(w, h)
if i.Link != "" {
fmt.Fprintf(os.Stderr, "Found altimg %s\n", i.Link)
}
f, err := os.Open(i.Name)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
continue
}
img, _, err := image.Decode(f)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
continue
}
openvg.FillColor(mbg)
openvg.Rect(0, 0, cw, ch)
openvg.FillColor(mfg)
openvg.TextMid(mx, my, fmt.Sprintf("Loading image %s %d from slide %d", i.Name, ni, ns), "sans", msize)
bounds := img.Bounds()
iw := i.Width
ih := i.Height
if i.Scale > 0 {
iw = int(float64(iw) * (i.Scale / 100))
ih = int(float64(ih) * (i.Scale / 100))
}
// if the specified dimensions are native use those, otherwise resize
if iw == (bounds.Max.X-bounds.Min.X) && ih == (bounds.Max.Y-bounds.Min.Y) {
m[i.Name] = img
} else {
g := gift.New(gift.Resize(iw, ih, gift.BoxResampling))
resized := image.NewRGBA(g.Bounds(img.Bounds()))
g.Draw(resized, img)
m[i.Name] = resized
}
f.Close()
openvg.End()
}
}
}
// raspberry pi, scaled to the screen dimensions
func raspi(w, h int, s string) {
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)
openvg.FillRGB(128, 0, 0, 1)
openvg.TextMid(midx, midy-(rh/2)-openvg.VGfloat(fontsize*2), s, "sans", fontsize)
openvg.End()
}
//planets is an exploration of scale
func planets(width, height int, message string) {
w := openvg.VGfloat(width)
h := openvg.VGfloat(height)
y := h / 2
margin := openvg.VGfloat(100.0)
minsize := openvg.VGfloat(7.0)
labeloc := openvg.VGfloat(100.0)
bgcolor := "black"
labelcolor := "white"
maxsize := (h / 2) * 0.05
origin := sun.distance
mostDistant := neptune.distance
firstSize := mercury.radius
lastSize := neptune.radius
openvg.Start(width, height)
openvg.BackgroundColor(bgcolor)
for _, p := range solarSystem {
x := vmap(p.distance, origin, mostDistant, margin, w-margin)
r := vmap(p.radius, firstSize, lastSize, minsize, maxsize)
if p.name == "Sun" {
openvg.FillRGB(p.color.Red, p.color.Green, p.color.Blue, 1)
openvg.Circle(margin-(r/2), y, r)
} else {
light(x, y, r, p.color)
openvg.Circle(x, y, r)
if p.name == "Saturn" {
ringwidth := r * 2.35 // Saturn's rings are over 2x the planet radius
openvg.StrokeWidth(3)
openvg.StrokeRGB(p.color.Red, p.color.Green, p.color.Blue, 1)
openvg.Line((x - ringwidth/2), y, (x + ringwidth/2), y)
openvg.StrokeWidth(0)
}
}
if p.name == "Earth" && len(message) > 1 {
openvg.StrokeColor(labelcolor)
openvg.StrokeWidth(1)
openvg.Line(x, y+(r/2), x, y+labeloc)
openvg.StrokeWidth(0)
openvg.FillColor(labelcolor)
openvg.TextMid(x, y+labeloc+10, message, "sans", 12)
}
}
openvg.End()
}
func draw(w, h openvg.VGfloat) {
paintBG(w, h)
var p particle
var grav = openvg.VGfloat(gravity)
for i := 0; i < nparticles; i++ {
p = particles[i]
openvg.FillRGB(p.r, p.g, p.b, 1)
openvg.Circle(p.x, p.y, p.radius)
// Apply the velocity
p.x += p.vx
p.y += p.vy
p.vx *= 0.98
if p.vy > 0 {
p.vy *= 0.97
}
// Gravity
p.vy -= grav
// Stop p leaving the canvas
if p.x < -50 {
p.x = w + 50
}
if p.x > w+50 {
p.x = -50
}
// When particle reaches the bottom of screen reset velocity & start posn
if p.y < -50 {
p.x = 0
p.y = 0
p.vx = openvg.VGfloat(rand.Intn(maxrand)%30) + 30
p.vy = openvg.VGfloat(rand.Intn(maxrand)%20) + 40
if directionRTL {
p.vx *= -1
p.x = w
}
}
if p.y > h+50 {
p.y = -50
}
particles[i] = p
}
openvg.End()
}
func main() {
width, height := openvg.Init()
w := openvg.VGfloat(width)
h := openvg.VGfloat(height)
y := h / 2
var (
margin openvg.VGfloat = 100.0
minsize openvg.VGfloat = 7.0
labeloc openvg.VGfloat = 100.0
)
bgcolor := "black"
labelcolor := "white"
maxsize := (h / 2) * 0.05
origin := sun.distance
mostDistant := neptune.distance
firstSize := mercury.radius
lastSize := neptune.radius
openvg.Start(width, height)
openvg.BackgroundColor(bgcolor)
for _, p := range solarSystem {
x := vmap(p.distance, origin, mostDistant, margin, w-margin)
r := vmap(p.radius, firstSize, lastSize, minsize, maxsize)
if p.name == "Sun" {
openvg.FillRGB(p.color.Red, p.color.Green, p.color.Blue, 1)
openvg.Circle(margin-(r/2), y, r)
} else {
light(x, y, r, p.color)
openvg.Circle(x, y, r)
}
if p.name == "Earth" && len(os.Args) > 1 {
openvg.StrokeColor(labelcolor)
openvg.StrokeWidth(1)
openvg.Line(x, y+(r/2), x, y+labeloc)
openvg.StrokeWidth(0)
openvg.FillColor(labelcolor)
openvg.TextMid(x, y+labeloc+10, os.Args[1], "sans", 12)
}
}
openvg.End()
bufio.NewReader(os.Stdin).ReadByte()
openvg.Finish()
}
// showgrid xrays a slide
func showgrid(d deck.Deck, n int, p float64) {
w := openvg.VGfloat(d.Canvas.Width)
h := openvg.VGfloat(d.Canvas.Height)
percent := openvg.VGfloat(p)
fs := (w / 100) // labels are 1% of the width
xpct := (percent / 100.0) * w
ypct := (percent / 100.0) * h
openvg.StrokeColor("lightgray", 0.5)
openvg.StrokeWidth(3)
// horizontal gridlines
xl := percent
for x := xpct; x <= w; x += xpct {
openvg.Line(x, 0, x, h)
openvg.Text(x, percent, fmt.Sprintf("%.0f%%", xl), "sans", int(fs))
xl += percent
}
// vertical gridlines
yl := percent
for y := ypct; y <= h; y += ypct {
openvg.Line(0, y, w, y)
openvg.Text(percent, y, fmt.Sprintf("%.0f%%", yl), "sans", int(fs))
yl += percent
}
// show boundary and location of images
if n < 0 || n > len(d.Slide) {
return
}
for _, im := range d.Slide[n].Image {
x := pct(im.Xp, w)
y := pct(im.Yp, h)
iw := openvg.VGfloat(im.Width)
ih := openvg.VGfloat(im.Height)
if im.Scale > 0 {
iw *= openvg.VGfloat(im.Scale / 100)
ih *= openvg.VGfloat(im.Scale / 100)
}
openvg.FillRGB(127, 0, 0, 0.3)
openvg.Circle(x, y, fs)
openvg.FillRGB(255, 0, 0, 0.1)
openvg.Rect(x-iw/2, y-ih/2, iw, ih)
}
openvg.End()
}
func main() {
width, height := openvg.Init() // OpenGL, etc initialization
w2 := openvg.VGfloat(width / 2)
h2 := openvg.VGfloat(height / 2)
w := openvg.VGfloat(width)
openvg.Start(width, height) // Start the picture
openvg.BackgroundColor("black") // Black background
openvg.FillRGB(44, 100, 232, 1) // Big blue marble
openvg.Circle(w2, 0, w) // The "world"
openvg.FillColor("white") // White text
openvg.TextMid(w2, h2, "hello, world", "serif", width/10) // Greetings
openvg.End() // End the picture
bufio.NewReader(os.Stdin).ReadBytes('\n') // Pause until [RETURN]
openvg.Finish() // Graphics cleanup
}
func gradient(width, height int) {
w := openvg.VGfloat(width)
h := openvg.VGfloat(height)
stops := []openvg.Offcolor{
{0.0, openvg.RGB{255, 255, 255}, 1.0},
{0.5, openvg.RGB{128, 128, 128}, 1.0},
{1.0, openvg.RGB{0, 0, 0}, 1.0},
}
x1 := w / 8
x2 := (w * 3) / 8
y1 := h / 3
y2 := (h * 2) / 3
cx := (w * 3) / 4
cy := (h / 2)
r := (x2 - x1)
fx := cx + (r / 4)
fy := cy + (r / 4)
openvg.Start(width, height)
openvg.BackgroundRGB(128, 128, 128, 1)
openvg.FillLinearGradient(x1, y1, x2, y2, stops)
openvg.Rect(x1, y1, x2-x1, y2-y1)
openvg.FillRadialGradient(cx, cy, fx, fy, r, stops)
openvg.Circle(cx, cy, r)
openvg.FillRGB(0, 0, 0, 0.3)
openvg.Circle(x1, y1, 10)
openvg.Circle(x2, y2, 10)
openvg.Circle(cx, cy, 10)
openvg.Circle(cx+r/2, cy, 10)
openvg.Circle(fx, fy, 10)
openvg.FillColor("black")
SansTypeface := "sans"
openvg.TextMid(x1, y1-20, "(x1, y1)", SansTypeface, 18)
openvg.TextMid(x2, y2+10, "(x2, y2)", SansTypeface, 18)
openvg.TextMid(cx, cy, "(cx, cy)", SansTypeface, 18)
openvg.TextMid(fx, fy, "(fx, fy)", SansTypeface, 18)
openvg.TextEnd(cx+(r/2)+20, cy, "r", SansTypeface, 18)
openvg.TextMid(x1+((x2-x1)/2), h/6, "Linear Gradient", SansTypeface, 36)
openvg.TextMid(cx, h/6, "Radial Gradient", SansTypeface, 36)
openvg.End()
}
// textplay exercises text functions
func textplay(w, h int) {
forlo := `For lo, the winter is past, the rain is over and gone. The flowers appear on the earth, the time for the singing of birds is come, and the voice of the turtle is heard in our land.`
// forsince := `For since by man came death, by man came also the resurrection of the dead, for as in Adam all die, even so in Christ shall all be made alive.`
openvg.Start(w, h)
var (
tw openvg.VGfloat = 300
begin openvg.VGfloat = 50
xincr openvg.VGfloat = 400
offset openvg.VGfloat = 100
)
for x, y := begin, openvg.VGfloat(h)-offset; x < openvg.VGfloat(w/2); x += xincr {
textwrap(x, y, tw, forlo, "sans", 12, 24, 0.25, "black")
textwrap(x, y-400, tw, forlo, "sans", 12, 24, 0.5, "black")
tw -= offset
}
openvg.End()
}
func main() {
var loop = flag.Bool("loop", false, "Loop the show")
var resize = flag.Bool("resize", false, `Resize image to fit the screen.`)
var bgcolor = flag.String("bg", "black", `Background color (named color or rgb(r,g,b)).`)
var delay = flag.Duration("delay", 2*time.Second, "Delay between pictures")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s [ flags ] images...\n", os.Args[0])
flag.PrintDefaults()
os.Exit(1)
}
flag.Parse()
w, h := openvg.Init()
images := []image.Image{}
imgcount := 0
for _, imgfile := range flag.Args() {
fmt.Fprintf(os.Stderr, "loading %q ", imgfile)
img, err := getimage(imgfile, w, h, *resize)
if err != nil {
fmt.Fprintln(os.Stderr, err)
continue
}
images = append(images, img)
imgcount++
fmt.Fprintln(os.Stderr, "ok")
}
for {
for _, img := range images {
ib := img.Bounds()
imw, imh := ib.Max.X-ib.Min.X, ib.Max.Y-ib.Min.Y
openvg.Start(w, h)
openvg.BackgroundColor(*bgcolor)
x, y := openvg.VGfloat(w)/2-openvg.VGfloat(imw)/2, openvg.VGfloat(h)/2-openvg.VGfloat(imh)/2
openvg.Img(x, y, img)
openvg.End()
time.Sleep(*delay)
}
if !*loop {
break
}
}
}
// testpattern shows a test pattern
func testpattern(w, h int, s string) {
var midx, midy1, midy2, midy3 openvg.VGfloat
fontsize := 256
h2 := openvg.VGfloat(h / 2)
by := openvg.VGfloat(h - 100)
bx := openvg.VGfloat(w - 100)
tw1 := &FW{"mono", 0, fontsize}
tw2 := &FW{"sans", 0, fontsize}
tw3 := &FW{"serif", 0, fontsize}
openvg.Start(w, h)
// colored squares in the corners
openvg.FillRGB(255, 0, 0, 1)
openvg.Rect(0, 0, 100, 100)
openvg.FillRGB(0, 255, 0, 1)
openvg.Rect(0, by, 100, 100)
openvg.FillRGB(0, 0, 255, 1)
openvg.Rect(bx, 0, 100, 100)
openvg.FillRGB(128, 128, 128, 1)
openvg.Rect(bx, by, 100, 100)
// for each font, (Sans, Serif, Mono), adjust the string to the w
tw1.fitwidth(w, 20, s)
tw2.fitwidth(w, 20, s)
tw3.fitwidth(w, 20, s)
midx = openvg.VGfloat(w / 2)
// Adjust the baselines to be medial
midy1 = h2 + 20 + openvg.VGfloat((tw1.fontsize)/2)
midy2 = h2 - openvg.VGfloat((tw2.fontsize)/2)
midy3 = h2 - 20 - openvg.VGfloat(tw2.fontsize) - openvg.VGfloat((tw3.fontsize)/2)
openvg.FillRGB(128, 128, 128, 1)
openvg.TextMid(midx, midy1, s, tw1.font, tw1.fontsize)
openvg.FillRGB(128, 0, 0, 1)
openvg.TextMid(midx, midy2, s, tw2.font, tw2.fontsize)
openvg.FillRGB(0, 0, 128, 1)
openvg.TextMid(midx, midy3, s, tw3.font, tw3.fontsize)
openvg.End()
}
// main plots data from specified files or standard input in a
// grid where plotc specifies the number of columns.
func main() {
w, h := openvg.Init()
i := 1
filenames := flag.Args()
for i <= 1000 {
openvg.Start(w, h)
openvg.FillColor("white")
openvg.Rect(0, 0, gwidth, gheight)
if len(filenames) == 0 {
doplot(beginx, beginy, "")
} else {
plotgrid(beginx, beginy, filenames)
}
openvg.End()
i = i + 1
}
bufio.NewReader(os.Stdin).ReadByte()
openvg.Finish()
}
// rotext draws text, rotated around the center of the screen, progressively faded
func rotext(w, h, n int, s string) {
fade := (100.0 / openvg.VGfloat(n)) / 100.0
deg := 360.0 / openvg.VGfloat(n)
x := openvg.VGfloat(w) / 2.0
y := openvg.VGfloat(h) / 2.0
alpha := openvg.VGfloat(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()
}
func imagetable(w, h int) {
imgw, imgh := 422, 238
itable := []it{
{"desert0.jpg", imgw, imgh},
{"desert1.jpg", imgw, imgh},
{"desert2.jpg", imgw, imgh},
{"desert3.jpg", imgw, imgh},
{"desert4.jpg", imgw, imgh},
{"desert5.jpg", imgw, imgh},
{"desert6.jpg", imgw, imgh},
{"desert7.jpg", imgw, imgh},
//{"http://farm4.static.flickr.com/3546/3338566612_9c56bfb53e_m.jpg", 240, 164},
//{"http://farm4.static.flickr.com/3642/3337734413_e36baba755_m.jpg", 240, 164},
}
offset := openvg.VGfloat(50)
left := offset
bot := openvg.VGfloat(h-imgh) - offset
gutter := offset
x := left
y := bot
openvg.Start(w, h)
openvg.BackgroundColor("black")
for _, iname := range itable {
openvg.Image(x, y, iname.width, iname.height, iname.name)
openvg.FillRGB(255, 255, 255, 0.3)
openvg.Rect(x, y, openvg.VGfloat(imgw), 32)
openvg.FillRGB(0, 0, 0, 1)
openvg.TextMid(x+openvg.VGfloat(imgw/2), y+10, iname.name, "sans", 16)
x += openvg.VGfloat(iname.width) + gutter
if x > openvg.VGfloat(w) {
x = left
y -= openvg.VGfloat(iname.height) + gutter
}
}
y = openvg.VGfloat(h) * 0.1
openvg.FillRGB(128, 128, 128, 1)
openvg.TextMid(openvg.VGfloat(w/2), 100, "Joshua Tree National Park", "sans", 48)
openvg.End()
}
// advert is an ad for the package
func advert(w, h int) {
y := openvg.VGfloat(h) / 4
fontsize := (w * 4) / 100
f3 := fontsize / 3
s := "github.com/ajstarks/openvg"
a := "*****@*****.**"
imw := 110
imh := 110
rw := openvg.VGfloat(w / 4)
rh := (rw * 2) / 3
midx := openvg.VGfloat(w / 2)
openvg.Start(w, h)
makepi(midx-openvg.VGfloat(rw/2), openvg.VGfloat(h/2), rw, rh)
openvg.FillRGB(128, 0, 0, 1)
openvg.TextMid(midx, y-openvg.VGfloat(fontsize/4), s, "sans", fontsize)
y -= 100
openvg.FillRGB(128, 128, 128, 1)
openvg.TextMid(midx, y, a, "sans", f3)
openvg.Image(openvg.VGfloat(w/2)-openvg.VGfloat(imw/2), 20, imw, imh, "starx.jpg")
openvg.End()
}
// fontrange shows a range of fonts
func fontrange(w, h int) {
var x, lx, length openvg.VGfloat
y := openvg.VGfloat(h) / 2.0
w2 := openvg.VGfloat(w) / 2.0
spacing := openvg.VGfloat(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 += openvg.VGfloat(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 += openvg.VGfloat(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() {
width, height := openvg.Init() // OpenGL, etc initialization
w2 := openvg.VGfloat(width / 2)
h2 := openvg.VGfloat(height / 2)
w := openvg.VGfloat(width)
stops := []openvg.Offcolor{
{0.0, openvg.RGB{44, 100, 232}, 1.0}, // blue-ish
{0.5, openvg.RGB{22, 50, 151}, 1.0}, // darker blue
{1.0, openvg.RGB{88, 200, 255}, 1.0}, // lighter blue
}
openvg.Start(width, height) // Start the picture
openvg.BackgroundColor("black") // Black background
openvg.FillRadialGradient(w2, 0, w2, w2, w*.5, stops) // Big blue marble
openvg.Circle(w2, 0, w) // The "world"
openvg.FillColor("white") // White text
openvg.TextMid(w2, h2, "hello, world", "serif", width/10) // Greetings
//openvg.SaveEnd("hvg.raw") // End the picture
openvg.End()
bufio.NewReader(os.Stdin).ReadBytes('\n') // Pause until [RETURN]
openvg.Finish() // Graphics cleanup
}
func main() {
var nr = flag.Int("n", 500, "number of objects")
var message = flag.String("m", "Go/OpenVG", "message")
var bgcolor = flag.String("bg", "white", "background color")
var fgcolor = flag.String("fg", "maroon", "text color")
flag.Parse()
rseed()
width, height := openvg.Init()
fw := openvg.VGfloat(width)
fh := openvg.VGfloat(height)
openvg.Start(width, height)
openvg.BackgroundColor(*bgcolor)
for i := 0; i < *nr; i++ {
red := uint8(rand.Intn(255))
green := uint8(rand.Intn(255))
blue := uint8(rand.Intn(255))
alpha := randf()
x := randf() * fw
y := randf() * fh
radius := randf() * fw / 10
openvg.FillRGB(red, green, blue, alpha)
openvg.Circle(x, y, radius)
}
openvg.FillColor(*fgcolor)
openvg.TextMid(fw/2, fh/2, *message, "sans", width/25)
openvg.End()
bufio.NewReader(os.Stdin).ReadBytes('\n')
openvg.Finish()
}
// WaitEnd paused for user input, then terminates
func WaitEnd() {
openvg.End()
bufio.NewReader(os.Stdin).ReadBytes('\n')
openvg.Finish()
}
func main() {
flag.StringVar(&mincolor, "mincolor", "maroon", "minute color")
flag.StringVar(&facecolor, "facecolor", "white", "face color")
flag.StringVar(&hrcolor, "hourcolor", "gray", "hour color")
flag.StringVar(&secolor, "secolor", "maroon", "second color")
flag.StringVar(&digitcolor, "digitcolor", "black", "digit color")
flag.StringVar(&dotcolor, "dotcolor", "silver", "dotcolor")
flag.StringVar(&framecolor, "framecolor", "gray", "frame color")
flag.StringVar(¢ercolor, "centercolor", "black", "center color")
flag.StringVar(&handstyle, "handstyle", "combo", "handstyle (combo, arrow, or round)")
flag.BoolVar(&showdigits, "showdigits", true, "show digits")
flag.BoolVar(&showdots, "showdots", true, "show dots")
flag.BoolVar(&secline, "secline", false, "show second hand")
flag.Parse()
width, height := openvg.Init()
cx := openvg.VGfloat(width / 2)
cy := openvg.VGfloat(height / 2)
facesize := openvg.VGfloat(cy * 0.5)
textsize := facesize / 10.0
framesize := facesize * 2.5
hourstroke := textsize
minstroke := hourstroke * .6
// set up the ticker and signal handler
ticker := time.NewTicker(1 * time.Second)
sigint := make(chan os.Signal, 1)
signal.Notify(sigint, os.Interrupt)
// main loop: for each second, draw the clock components
openvg.Start(width, height)
for {
select {
case <-ticker.C:
// get the current time
hr, min, sec := time.Now().Clock()
// compute element coordinates
hx, hy, mx, my, sx, sy := timecoord(cx, cy, facesize, hr, min, sec)
// frame and clock face
frame(cx, cy, framesize, facesize, textsize, framecolor, facecolor)
face(cx, cy, facesize, int(textsize*1.5))
// hour and minute hands
switch handstyle {
case "round", "r":
roundhand(cx, cy, mx, my, minstroke, mincolor)
roundhand(cx, cy, hx, hy, hourstroke, hrcolor)
case "arrow", "a":
arrowhand(cx, cy, mx, my, facesize*0.9, minangles[min], 0, mincolor)
arrowhand(cx, cy, hx, hy, facesize*0.6, hourangles[hr%12], min, hrcolor)
case "combo", "c":
combohand(cx, cy, mx, my, facesize*0.9, minstroke/2, minangles[min], 0, mincolor)
combohand(cx, cy, hx, hy, facesize*0.6, minstroke/2, hourangles[hr%12], min, hrcolor)
default:
combohand(cx, cy, mx, my, facesize*0.9, minstroke/2, minangles[min], 0, mincolor)
combohand(cx, cy, hx, hy, facesize*0.6, minstroke/2, hourangles[hr%12], min, hrcolor)
}
// second indicator
secondhand(cx, cy, sx, sy, textsize)
// center dot
centerdot(cx, cy, textsize)
// make the picture
openvg.End()
case <-sigint:
openvg.Finish()
return
}
}
}
func main() {
var (
filename = flag.String("f", "svgcolors.txt", "input file")
fontname = flag.String("font", "sans", "fontname")
neg = flag.Bool("neg", false, "negative")
showrgb = flag.Bool("rgb", false, "show RGB")
showcode = flag.Bool("showcode", true, "show colors and codes")
circsw = flag.Bool("circle", true, "circle swatch")
outline = flag.Bool("outline", false, "outline swatch")
fontsize = flag.Int("fs", 12, "fontsize")
rowsize = flag.Int("r", 32, "rowsize")
colw = flag.Float64("c", 340, "column size")
swatch = flag.Float64("s", 16, "swatch size")
gutter = flag.Float64("g", 12, "gutter")
err error
tcolor, line string
)
flag.Parse()
f, oerr := os.Open(*filename)
if oerr != nil {
fmt.Fprintf(os.Stderr, "%v\n", oerr)
return
}
width, height := openvg.Init()
openvg.Start(width, height)
fw := openvg.VGfloat(width)
fh := openvg.VGfloat(height)
if *neg {
openvg.FillColor("black")
openvg.Rect(0, 0, fw, fh)
tcolor = "white"
} else {
openvg.FillColor("white")
openvg.Rect(0, 0, fw, fh)
tcolor = "black"
}
top := fh - 32.0
left := openvg.VGfloat(32.0)
cw := openvg.VGfloat(*colw)
sw := openvg.VGfloat(*swatch)
g := openvg.VGfloat(*gutter)
in := bufio.NewReader(f)
for x, y, nr := left, top, 0; err == nil; nr++ {
line, err = in.ReadString('\n')
fields := strings.Split(strings.TrimSpace(line), "\t")
if nr%*rowsize == 0 && nr > 0 {
x += cw
y = top
}
if len(fields) == 3 {
var red, green, blue uint8
fmt.Sscanf(fields[2], "%d,%d,%d", &red, &green, &blue)
openvg.FillRGB(red, green, blue, 1)
if *outline {
openvg.StrokeColor("black")
openvg.StrokeWidth(1)
}
if *circsw {
openvg.Circle(x+sw/2, y+sw/2, sw)
} else {
openvg.Rect(x, y, sw, sw)
}
openvg.StrokeWidth(0)
openvg.FillColor(tcolor)
openvg.Text(x+sw+openvg.VGfloat(*fontsize/2), y, fields[0], *fontname, *fontsize)
var label string
if *showcode {
if *showrgb {
label = fields[1]
} else {
label = fields[2]
}
openvg.FillColor("gray")
openvg.TextEnd(x+cw-(sw+g), y, label, *fontname, *fontsize)
}
}
y -= (sw + g)
}
openvg.End()
bufio.NewReader(os.Stdin).ReadBytes('\n')
openvg.Finish()
}
func main() {
var sreenHeight, cx, cy, cw, ch int
message := "Hej Sandra tack forden mysiga kramen ..... <3 <3 Puss puss"
w, h := openvg.Init()
sreenHeight = h
var speed openvg.VGfloat = 4.0
var x openvg.VGfloat = 0
//midy = (h / 2)
fontsize := w / 50
cx = 0
ch = fontsize * 2
cw = w
//cy = midy - (ch / 2)
cy = h - 80
var jsonData SLData
var lastmill = makeTimestamp()
response, err := http.Get("http://localhost:8000")
if err == nil {
defer response.Body.Close()
contents, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Printf("Error reading http data, %s", err)
} else {
fmt.Printf("Got: %s\n", string(contents))
if err := json.Unmarshal(contents, &jsonData); err != nil {
panic(err)
}
fmt.Println(jsonData)
}
}
openvg.Start(w, h)
openvg.End()
go PlayVideo(w, h)
for {
openvg.Start(w, h)
//fmt.Println("W,H",w,h)
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 {
var mill = makeTimestamp()
var delta = (mill - lastmill) / 5
//fmt.Println("delta ", delta)
//speed
x = openvg.VGfloat(delta)
imgw, imgh := 0, 0
openvg.Background(0, 0, 0)
//SLHeight = 60
var imgPosY = openvg.VGfloat(sreenHeight - 120)
openvg.Image(8, imgPosY, imgw, imgh, "DA4FID.png")
var TAB1 = openvg.VGfloat(4 * w / 20)
//var TAB2 = openvg.VGfloat(8*w/20)
rx1, rw1, rh1 := openvg.VGfloat(cx), openvg.VGfloat(cw), openvg.VGfloat(ch)
ty := 0
rix := 0
// - (120 + int(rh1))
ty = sreenHeight - 140
var trainIx = 0
for ty = ty - 20; ty > 0 && trainIx < len(jsonData.ResponseData.Trains); ty -= ch {
tempy := openvg.VGfloat(ty)
//ry := openvg.VGfloat(ty)
if rix%2 == 0 {
openvg.FillRGB(255, 255, 255, .2)
//openvg.Rect(rx1, tempy, rw1, rh1)
tempy = tempy + 6.0
} else {
openvg.FillRGB(255, 255, 255, .4)
openvg.Rect(rx1, tempy, rw1/3, rh1)
tempy = tempy + 6.0
}
openvg.FillRGB(255, 255, 255, 1)
//openvg.Text(rx1, tempy, jsonData.ResponseData.Trains[trainIx].LineNumber , "sans", fontsize)
//drawTypeOfTransport(rx1+55,tempy+4,rw1,ch-20,jsonData.ResponseData.Trains[trainIx].TransportMode)
openvg.Text(rx1, tempy, jsonData.ResponseData.Trains[trainIx].DisplayTime, "sans", fontsize)
var dest = jsonData.ResponseData.Trains[trainIx].Destination
dest = replaceAO(dest)
openvg.Text(rx1+TAB1, tempy, dest, "sans", fontsize)
//openvg.Translate(x, ry+openvg.VGfloat(fontsize/2))
//openvg.Background(255,255,0)
trainIx = trainIx + 1
rix = rix + 1
}
imgw = 20
imgh = 20
//openvg.Image(8, 100 , imgw, imgh, "no_smoking.png")
// openvg.Start(w, h)
//openvg.Background(255, 255, 255)
openvg.FillRGB(100, 0, 0, 1)
openvg.Rect(rx, ry, rw, rh)
//openvg.ClipRect(cx, cy, cw, ch)
//openvg.Translate(x, ry+openvg.VGfloat(fontsize/2))
openvg.FillRGB(255, 255, 255, 1)
var pxp openvg.VGfloat = openvg.VGfloat(w) - openvg.VGfloat(x)
var pyp openvg.VGfloat = openvg.VGfloat(h) - openvg.VGfloat(58)
openvg.Text(pxp, pyp, message, "sans", fontsize)
//openvg.ClipEnd()
openvg.End()
}
//openvg.SaveEnd("dump.raw")
//time.Sleep(60*time.Second);
}
bufio.NewReader(os.Stdin).ReadBytes('\n')
bufio.NewReader(os.Stdin).ReadBytes('\n')
openvg.Finish()
os.Exit(0)
}
func main() {
var sreenHeight, cx, cy, cw, ch, midy int
message := "Scrolling texts could be useful if the information does not fit on screen"
w, h := openvg.Init()
sreenHeight = h
var speed openvg.VGfloat = 0.5
var x openvg.VGfloat = 0
midy = (h / 2)
fontsize := w / 50
cx = 0
ch = fontsize * 2
cw = w
cy = midy - (ch / 2)
var jsonData SLData
for {
response, err := http.Get("http://localhost:8000")
if err == nil {
defer response.Body.Close()
contents, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Printf("Error reading http data, %s", err)
} else {
fmt.Printf("Got: %s\n", string(contents))
if err := json.Unmarshal(contents, &jsonData); err != nil {
panic(err)
}
fmt.Println(jsonData)
}
}
openvg.Start(w, h)
imgw, imgh := 0, 0
openvg.Background(255, 255, 255)
//SLHeight = 60
var imgPosY = openvg.VGfloat(sreenHeight - 70)
openvg.Image(4, imgPosY, imgw, imgh, "SL.jpg")
var TAB1 = openvg.VGfloat(4 * w / 20)
var TAB2 = openvg.VGfloat(8 * w / 20)
rx1, rw1, rh1 := openvg.VGfloat(cx), openvg.VGfloat(cw), openvg.VGfloat(ch)
ty := 0
rix := 0
// Buses
for ty = sreenHeight - (80 + int(rh1)); ty > 0 && rix < len(jsonData.ResponseData.Buses); ty -= ch {
tempy := openvg.VGfloat(ty)
//ry := openvg.VGfloat(ty)
if rix%2 == 0 {
openvg.FillRGB(0, 0, 0, .2)
//openvg.Rect(rx1, tempy, rw1, rh1)
openvg.FillRGB(0, 0, 0, 1)
tempy = tempy + 6.0
} else {
openvg.FillRGB(0, 0, 0, .4)
openvg.Rect(rx1, tempy, rw1, rh1)
tempy = tempy + 6.0
openvg.FillRGB(0, 0, 0, 1)
}
openvg.Text(rx1, tempy, jsonData.ResponseData.Buses[rix].LineNumber, "sans", fontsize)
drawTypeOfTransport(rx1+60, tempy+2, rw1, ch-20, jsonData.ResponseData.Buses[rix].TransportMode)
openvg.Text(rx1+100, tempy, jsonData.ResponseData.Buses[rix].StopPointDesignation, "sans", fontsize)
openvg.Text(rx1+TAB1, tempy, jsonData.ResponseData.Buses[rix].DisplayTime, "sans", fontsize)
var dest = jsonData.ResponseData.Buses[rix].Destination
dest = replaceAO(dest)
openvg.Text(rx1+TAB2, tempy, dest, "sans", fontsize)
//openvg.Translate(x, ry+openvg.VGfloat(fontsize/2))
//openvg.Background(255,255,0)
rix = rix + 1
}
var trainIx = 0
for ty = ty - 20; ty > 0 && trainIx < len(jsonData.ResponseData.Trains); ty -= ch {
tempy := openvg.VGfloat(ty)
//ry := openvg.VGfloat(ty)
if rix%2 == 0 {
openvg.FillRGB(0, 0, 0, .2)
//openvg.Rect(rx1, tempy, rw1, rh1)
openvg.FillRGB(0, 0, 0, 1)
tempy = tempy + 6.0
} else {
openvg.FillRGB(0, 0, 0, .4)
openvg.Rect(rx1, tempy, rw1, rh1)
tempy = tempy + 6.0
openvg.FillRGB(0, 0, 0, 1)
}
openvg.Text(rx1, tempy, jsonData.ResponseData.Trains[trainIx].LineNumber, "sans", fontsize)
drawTypeOfTransport(rx1+55, tempy+4, rw1, ch-20, jsonData.ResponseData.Trains[trainIx].TransportMode)
openvg.Text(rx1+TAB1, tempy, jsonData.ResponseData.Trains[trainIx].DisplayTime, "sans", fontsize)
var dest = jsonData.ResponseData.Trains[trainIx].Destination
dest = replaceAO(dest)
openvg.Text(rx1+TAB2, tempy, dest, "sans", fontsize)
//openvg.Translate(x, ry+openvg.VGfloat(fontsize/2))
//openvg.Background(255,255,0)
trainIx = trainIx + 1
rix = rix + 1
}
//openvg.End()
openvg.SaveEnd("dump.raw")
time.Sleep(60 * time.Second)
}
bufio.NewReader(os.Stdin).ReadBytes('\n')
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 main() {
var cy, ch, midy int
var message []string
message = []string{" Black", "cats", "skitter", "and", "ghouls", "patter", "Happy", "Halloween"}
w, h := openvg.Init()
//var speed openvg.VGfloat = 0.5
var x openvg.VGfloat = 0
var vw, vh openvg.VGfloat
var midxx openvg.VGfloat = openvg.VGfloat(w / 2)
midy = (h / 2)
fontsize := w / 8
//cx = 0
ch = fontsize * 2
//cw = w
cy = midy - (ch / 2)
var redness uint8
var index int
//rx , rw, rh := openvg.VGfloat(cx) , openvg.VGfloat(cw), openvg.VGfloat(ch)
ry := openvg.VGfloat(cy)
// scroll the text, only in the clipping rectangle
index = 0
for {
for redness = 255; redness > 16; redness -= 2 {
ch = fontsize * 2
//cw = w
cy = midy - (ch / 2)
openvg.Start(w, h)
openvg.Background(redness, 0, 0)
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)
var fsiz int
fsiz = int(255 - redness)
openvg.TextMid(midxx, 0, message[index], "shf", fsiz)
openvg.ClipEnd()
openvg.End()
}
index = (index + 1) % 8
if index == 0 {
vw = openvg.VGfloat(w) - 200
vh = openvg.VGfloat(h) - 200
openvg.Video(100.0, 100.0, vw, vh, "test.h264")
}
if index == 0 {
var test, oix int
var xpos [40]float32
var ypos [40]float32
var rotate [40]float32
var spdx [40]float32
var spdy [40]float32
// Init positions
for test = 0; test < 40; test++ {
var rot = rand.Float32()
var rax = rand.Float32()
rax = float32(w) * rax
var ray = rand.Float32()
ray = float32(h) * ray
spdx[test] = float32(test) * rand.Float32()
spdy[test] = float32(test) * rand.Float32()
ypos[test] = ray
xpos[test] = rax
rot = 0
rotate[test] = rot
}
// Move around
for oix = 0; oix < 100; oix++ {
openvg.Start(w, h)
openvg.Background(0, 0, 0)
openvg.FillColor("red")
for test = 0; test < 40; test++ {
var rot = rand.Float32()
var rax = rand.Float32()*float32(4.0) - float32(2.0)
var ray = float32(4.0)*rand.Float32() - float32(2.0)
spdy[test] += ray
spdx[test] += rax
xpos[test] = xpos[test] + spdx[test]
ypos[test] = ypos[test] + spdy[test]
rotate[test] = rotate[test] + float32(rot*4-2)
openvg.Rotate(openvg.VGfloat(rotate[test]))
openvg.Translate(openvg.VGfloat(xpos[test]), openvg.VGfloat(ypos[test]))
openvg.TextMid(0, 0, "Happy Halloween", "shf", 30)
openvg.Translate(-openvg.VGfloat(xpos[test]), -openvg.VGfloat(ypos[test]))
openvg.Rotate(-openvg.VGfloat(rotate[test]))
}
openvg.End()
}
}
}
bufio.NewReader(os.Stdin).ReadBytes('\n')
openvg.Finish()
os.Exit(0)
}
func main() {
var resize = flag.Bool("resize", false, "Resize image to fit the screen.")
var bgcolor = flag.String("bg", "black", "Background color (named color or rgb(r,g,b)).")
var fgcolor = flag.String("fg", "white", "text color (named color or rgb(r,g,b)).")
var title = flag.String("t", "", "text annotation")
var fontsize = flag.Float64("fp", 2.0, "fontsize %")
var px = flag.Float64("px", 50, "x position %")
var py = flag.Float64("py", 50, "y position %")
var texty = flag.Float64("ty", 0, "text y %")
var exit_code int
defer func() {
os.Exit(exit_code)
}()
flag.Usage = func() {
fmt.Fprintf(os.Stderr, `usage: %s [ flags ] 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()
exit_code = 1
return
}
flag.Parse()
if flag.NArg() != 1 {
fmt.Fprintf(os.Stderr, "Exactly one image-path argument must be specified.\n")
flag.Usage()
exit_code = 2
return
}
openvg.SaveTerm()
w, h := openvg.Init()
openvg.RawTerm()
defer openvg.Finish()
defer openvg.RestoreTerm()
img, err := getimage(flag.Args()[0], w, h, *resize)
if err != nil {
exit_code = 3
return
}
ib := img.Bounds()
imw, imh := ib.Max.X-ib.Min.X, ib.Max.Y-ib.Min.Y
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.BackgroundColor(*bgcolor)
var x, y openvg.VGfloat
if *px < 0 || *px > 100 {
x = openvg.VGfloat(w)/2 - openvg.VGfloat(imw)/2
} else {
x = openvg.VGfloat(w)*openvg.VGfloat(*px/100) - openvg.VGfloat(imw)/2
}
if *py < 0 || *py > 100 {
y = openvg.VGfloat(h)/2 - openvg.VGfloat(imh)/2
} else {
y = openvg.VGfloat(h)*openvg.VGfloat(*py/100) - openvg.VGfloat(imh)/2
}
openvg.Img(x, y, img)
if len(*title) > 0 {
var typ openvg.VGfloat
fs := openvg.VGfloat(*fontsize/100.0) * openvg.VGfloat(w)
if *texty == 0 {
typ = y - fs*1.5
} else {
typ = openvg.VGfloat(h) * openvg.VGfloat(*texty/100)
}
openvg.FillColor(*fgcolor)
openvg.TextMid(x+openvg.VGfloat(imw)/2, typ, *title, "sans", int(fs))
}
openvg.End()
_ = <-sig_chan
}