// 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 := float64(w) * 0.50
lmargin := float64(w) * 0.10
top := float64(h) * .9
mid := float64(h) * .6
bot := float64(h) * .3
fontsize := 24
leading := 40.0
lfontsize := fontsize * 2
midb := ((leading * 2) + (leading / 2)) - float64(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()
}
// 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 float64
np := 10
polyx := make([]float64, np)
polyy := make([]float64, np)
openvg.Start(width, height)
for i := 0; i < n; i++ {
openvg.FillRGB(randcolor(), randcolor(), randcolor(), rand.Float64())
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 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 main() {
width, height := openvg.Init() // OpenGL, etc initialization
w := openvg.VGfloat(width)
h := openvg.VGfloat(height)
openvg.Start(width, height) // Start the picture
openvg.BackgroundColor("white") // Black background
openvg.FillColor("black")
var x, y, spacing openvg.VGfloat
x = w * 0.10
y = h * 0.90
fontsize := 24
spacing = openvg.VGfloat(fontsize) * 2
var data = []string{
"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
"\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f",
"\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f",
"\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f",
"\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f",
"\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f",
"\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f",
"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f",
"\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f",
"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf",
"\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf",
"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf",
"\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf",
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef",
"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
}
for i, s := range data {
openvg.Text(x-(spacing*2), y, fmt.Sprintf("%2x", i), "mono", fontsize)
openvg.Text(x, y, s, "mono", fontsize)
y -= spacing
}
openvg.End() // End the picture
bufio.NewReader(os.Stdin).ReadBytes('\n') // Pause until [RETURN]
openvg.Finish() // Graphics cleanup
}
// textwrap draws text at location, wrapping at the specified width
func textwrap(x, y, w float64, s string, font string, size int, leading, factor float64, color string) {
openvg.FillColor(color)
wordspacing := openvg.TextWidth("M", font, size)
words := strings.Split(s, " ")
xp := x
yp := y
edge := x + w
for i := 0; i < len(words); i++ {
tw := openvg.TextWidth(words[i], font, size)
openvg.Text(xp, yp, words[i], font, size)
xp += tw + (wordspacing * factor)
if xp > edge {
xp = x
yp -= leading
}
}
}
// 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()
}
// nytheadlines retrieves data from the New York Times API, decodes and displays it.
func (d *display) nytheadlines(section string, thumb bool) {
hdim := dimen{x: 0, y: 0, width: d.width, height: d.height / 2}
r, err := netread(fmt.Sprintf(NYTfmt, section, NYTAPIkey))
if err != nil {
fmt.Fprintf(os.Stderr, "headline read error: %v\n", err)
hdim.gerror(d.bgcolor, d.textcolor, "no headlines")
return
}
defer r.Close()
var data NYTHeadlines
err = json.NewDecoder(r).Decode(&data)
if err != nil {
fmt.Fprintf(os.Stderr, "decode: %v\n", err)
hdim.gerror(d.bgcolor, d.textcolor, "no headlines")
return
}
x := d.width * 0.10
y := d.height * 0.10
thumbsize := int(d.height * 0.05)
hdim.regionFill(d.bgcolor, d.textcolor)
headsize := d.width / 80
spacing := openvg.VGfloat(thumbsize)
for i := len(data.Results) - 1; i >= 0; i-- {
openvg.Text(x, y, fromHTML.Replace(data.Results[i].Title), "serif", int(headsize))
if len(data.Results[i].Thumbnail) > 0 {
img, imerr := netimage(data.Results[i].Thumbnail)
if imerr != nil {
continue
}
g := gift.New()
g.Add(gift.Resize(0, thumbsize, gift.LanczosResampling))
gift.Resize(thumbsize, thumbsize, gift.BoxResampling)
resized := image.NewRGBA(g.Bounds(img.Bounds()))
g.Draw(resized, img)
openvg.Img(x-100, y-(spacing*0.25), resized)
}
y = y + spacing
}
openvg.Image(d.width*0.05, 15, 30, 30, "poweredby_nytimes_30a.png")
openvg.End()
}
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()
}
// refcard shows a reference card of shapes
func refcard(width, height int) {
shapenames := []string{
"Circle",
"Ellipse",
"Rectangle",
"Rounded Rectangle",
"Line",
"Polyline",
"Polygon",
"Arc",
"Quadratic Bezier",
"Cubic Bezier",
"Image",
}
top := float64(height) * .95
sx := float64(width) * 0.10
sy := top
sw := float64(width) * .05
sh := float64(height) * .045
dotsize := 7.0
spacing := 2.0
fontsize := int(float64(height) * .033)
shapecolor := Color{202, 225, 255, 1.0}
openvg.Start(width, height)
openvg.FillRGB(128, 0, 0, 1)
openvg.TextEnd(float64(width-20), float64(height/2),
"OpenVG on the Raspberry Pi", "sans", fontsize+(fontsize/2))
openvg.FillRGB(0, 0, 0, 1)
for _, s := range shapenames {
openvg.Text(sx+sw+sw/2, sy, s, "sans", fontsize)
sy -= sh * spacing
}
sy = top
cx := sx + (sw / 2)
ex := sx + sw
openvg.FillRGB(shapecolor.red, shapecolor.green, shapecolor.blue, shapecolor.alpha)
openvg.Circle(cx, sy, sw)
coordpoint(cx, sy, dotsize, shapecolor)
sy -= sh * spacing
openvg.Ellipse(cx, sy, sw, sh)
coordpoint(cx, sy, dotsize, shapecolor)
sy -= sh * spacing
openvg.Rect(sx, sy, sw, sh)
coordpoint(sx, sy, dotsize, shapecolor)
sy -= sh * spacing
openvg.Roundrect(sx, sy, sw, sh, 20, 20)
coordpoint(sx, sy, dotsize, shapecolor)
sy -= sh * spacing
openvg.StrokeWidth(1)
openvg.StrokeRGB(204, 204, 204, 1)
openvg.Line(sx, sy, ex, sy)
coordpoint(sx, sy, dotsize, shapecolor)
coordpoint(ex, sy, dotsize, shapecolor)
sy -= sh
px := []float64{sx, sx + (sw / 4), sx + (sw / 2), sx + ((sw * 3) / 4), sx + sw}
py := []float64{sy, sy - sh, sy, sy - sh, sy}
openvg.Polyline(px, py) // , 5)
coordpoint(px[0], py[0], dotsize, shapecolor)
coordpoint(px[1], py[1], dotsize, shapecolor)
coordpoint(px[2], py[2], dotsize, shapecolor)
coordpoint(px[3], py[3], dotsize, shapecolor)
coordpoint(px[4], py[4], dotsize, shapecolor)
sy -= sh * spacing
py[0] = sy
py[1] = sy - sh
py[2] = sy - (sh / 2)
py[3] = py[1] - (sh / 4)
py[4] = sy
openvg.Polygon(px, py) // , 5)
sy -= (sh * spacing) + sh
openvg.Arc(sx+(sw/2), sy, sw, sh, 0, 180)
coordpoint(sx+(sw/2), sy, dotsize, shapecolor)
sy -= sh * spacing
var cy, ey float64
cy = sy + (sh / 2)
ey = sy
openvg.Qbezier(sx, sy, cx, cy, ex, ey)
coordpoint(sx, sy, dotsize, shapecolor)
coordpoint(cx, cy, dotsize, shapecolor)
coordpoint(ex, ey, dotsize, shapecolor)
sy -= sh * spacing
ey = sy
cy = sy + sh
openvg.Cbezier(sx, sy, cx, cy, cx, sy, ex, ey)
coordpoint(sx, sy, dotsize, shapecolor)
coordpoint(cx, cy, dotsize, shapecolor)
coordpoint(cx, sy, dotsize, shapecolor)
coordpoint(ex, ey, dotsize, shapecolor)
sy -= (sh * spacing * 1.5)
openvg.Image(sx, sy, 110, 110, "starx.jpg")
openvg.End()
}
// weather retrieves data from the forecast.io API, decodes and displays it.
func (d *display) weather(latlong string) {
wdim := dimen{x: 0, y: d.height / 2, width: d.width / 2, height: d.height / 2}
r, err := netread(fmt.Sprintf(weatherfmt, weatherAPIkey, latlong))
if err != nil {
fmt.Fprintf(os.Stderr, "Weather read error: %v\n", err)
wdim.gerror(d.bgcolor, d.textcolor, "no weather")
return
}
defer r.Close()
var data Forecast
err = json.NewDecoder(r).Decode(&data)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
wdim.gerror(d.bgcolor, d.textcolor, "no weather")
return
}
x := d.width * 0.05
y := d.height * 0.70
wsize := d.width / 20
spacing := wsize * 2.0
w1 := int(wsize)
w2 := w1 / 2
w3 := w1 / 4
c := data.Currently
temp := fmt.Sprintf("%0.f°", c.Temperature)
tw := openvg.TextWidth(temp, "sans", w1)
wdim.regionFill(d.bgcolor, d.textcolor)
openvg.Text(x, y, temp, "sans", w1)
if c.Temperature-c.FeelsLike > 1 {
openvg.Text(x, y-(spacing/3),
fmt.Sprintf("(feels like %0.f°)", c.FeelsLike), "sans", w3)
}
openvg.Text(x, y+spacing, c.Summary, "sans", w2)
if c.PrecipProb > 0 {
openvg.Text(x, y-(spacing*.6),
fmt.Sprintf("%0.f%% Chance of precipitation", c.PrecipProb*100), "sans", w3)
}
ic := dimen{
x: x + tw + d.width*0.01,
y: d.height * 0.67,
width: d.width / 10,
height: d.width / 10,
}
switch c.Icon {
case "clear-day":
ic.sun("orange")
case "clear-night":
ic.moon(d.bgcolor, d.textcolor)
case "rain":
ic.rain("skyblue")
case "snow":
ic.snow(d.textcolor)
case "wind":
ic.wind(d.bgcolor, d.textcolor)
case "fog":
ic.fog(d.textcolor)
case "cloudy":
ic.cloud(d.textcolor)
case "partly-cloudy-day":
ic.pcloud(d.textcolor)
case "partly-cloudy-night":
ic.npcloud("darkgray", d.textcolor)
}
openvg.End()
}
