// moon shows the icon for clear weather at night
func (d *dimen) moon(bg, fg string) {
x, y, w, h := d.x, d.y, d.width, d.height
cx := x + w/2
cy := y + h/2
w2 := w / 2
openvg.FillColor(fg)
openvg.Circle(cx, cy, w2)
openvg.FillColor(bg)
openvg.Circle(x+w*0.65, cy, w2)
}
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()
}
// drop shows the raindrop icon
func (d *dimen) drop(color string) {
x, y, w, h := d.x, d.y, d.width, d.height
openvg.FillColor(color)
openvg.Ellipse(x+(w/2), y+(h*0.40), w*0.52, h*0.65)
xp := []openvg.VGfloat{x + (w / 2), x + (w * 0.25), x + (w * 0.75)}
yp := []openvg.VGfloat{y + h, y + (h / 2), y + (h / 2)}
openvg.Polygon(xp, yp)
}
func roundhand(cx, cy, px, py, stroke openvg.VGfloat, color string) {
openvg.StrokeWidth(stroke)
openvg.StrokeColor(color)
openvg.Line(cx, cy, px, py)
openvg.StrokeWidth(0)
openvg.FillColor(color)
openvg.Ellipse(px, py, stroke, stroke)
}
// cloud shows the cloudy icon
func (d *dimen) cloud(color string) {
x, y, w, h := d.x, d.y, d.width, d.height
radius := d.width / 3
r2 := radius * 1.8
openvg.FillColor(color)
openvg.Circle(x+w*0.25, y+h*0.25, radius)
openvg.Circle(x+w*0.30, y+h*0.45, radius)
openvg.Circle(x+w*0.60, y+h*0.40, r2)
}
// wind shows the windy icon
func (d *dimen) wind(bg, color string) {
x, y, w, h := d.x, d.y, d.width, d.height
openvg.FillColor(bg, 0)
openvg.StrokeWidth(w / 25)
openvg.StrokeColor(color)
openvg.Qbezier(x+w*0.10, y+h*0.8, x+w*0.50, y+h*0.60, x+w*0.9, y+h*0.85)
openvg.Qbezier(x+w*0.10, y+h*0.5, x+w*0.55, y+h*0.30, x+w*0.9, y+h*0.55)
openvg.Qbezier(x+w*0.10, y+h*0.2, x+w*0.60, y+h*0.10, x+w*0.9, y+h*0.35)
openvg.StrokeWidth(0)
}
func secondhand(cx, cy, sx, sy, textsize openvg.VGfloat) {
openvg.FillColor(secolor, 0.4)
openvg.Ellipse(sx, sy, textsize, textsize)
if secline {
openvg.StrokeWidth(textsize / 6)
openvg.StrokeColor(secolor)
openvg.Line(cx, cy, sx, sy)
openvg.StrokeWidth(0)
}
}
func face(x, y, r openvg.VGfloat, ts int) {
var fx, fy, va openvg.VGfloat
va = openvg.VGfloat(ts) / 2.0
secsize := openvg.VGfloat(ts) / 3
radius := float64(r)
ir := radius * 1.2
// hour display
openvg.FillColor(digitcolor)
openvg.StrokeColor(digitcolor)
openvg.StrokeWidth(5)
for h := 12; h > 0; h-- {
t := hourangles[h%12] * deg2rad
fx = x + openvg.VGfloat(radius*math.Cos(t))
fy = y + openvg.VGfloat(radius*math.Sin(t))
ix := x + openvg.VGfloat(ir*math.Cos(t))
iy := y + openvg.VGfloat(ir*math.Sin(t))
if showdigits {
openvg.TextMid(fx, fy-va, hourdigits[h%12], "sans", ts)
} else {
openvg.Line(fx, fy, ix, iy)
}
}
// second display
openvg.FillColor(dotcolor)
openvg.StrokeColor(dotcolor)
openvg.StrokeWidth(2)
re := radius * edge
for a := 0.0; a < 360; a += 6.0 {
t := a * deg2rad
sx := x + openvg.VGfloat(re*math.Cos(t))
sy := y + openvg.VGfloat(re*math.Sin(t))
if showdots {
openvg.Ellipse(sx, sy, secsize, secsize)
} else {
ix := x + openvg.VGfloat(ir*math.Cos(t))
iy := y + openvg.VGfloat(ir*math.Sin(t))
openvg.Line(sx, sy, ix, iy)
}
}
openvg.StrokeWidth(0)
}
// countdown shows a countdown display to the top of minute
func (d *display) countdown() {
tick := time.NewTicker(1 * time.Second)
ty := d.height / 2
th := d.height / 20
size := d.width / 70
for delay := 60 - time.Now().Second(); delay > 0; delay-- {
select {
case <-tick.C:
tx := d.width * (openvg.VGfloat(60-delay) / 60)
openvg.BackgroundColor(d.bgcolor)
openvg.FillColor("black")
openvg.Rect(0, ty, d.width, th)
openvg.FillColor("white")
openvg.TextEnd(tx, ty+(th/4), fmt.Sprintf("start in %d ", delay), "sans", int(size))
openvg.Rect(tx, ty, d.width-tx, th)
openvg.End()
}
}
openvg.BackgroundColor(d.bgcolor)
}
func arrowhand(cx, cy, px, py, r openvg.VGfloat, t float64, value int, color string) {
ax := []openvg.VGfloat{cx, 0, px, 0, cx}
ay := []openvg.VGfloat{cy, 0, py, 0, cy}
t = minadjust(t, value) * deg2rad
rf := float64(r * 0.9)
tf := math.Pi / 45.0
ax[1] = cx + openvg.VGfloat(rf*math.Cos(t-tf))
ay[1] = cy + openvg.VGfloat(rf*math.Sin(t-tf))
ax[3] = cx + openvg.VGfloat(rf*math.Cos(t+tf))
ay[3] = cy + openvg.VGfloat(rf*math.Sin(t+tf))
openvg.FillColor(color)
openvg.Polygon(ax, ay)
}
//planets is an exploration of scale
func planets(width, height int, message string) {
w := float64(width)
h := float64(height)
y := h / 2
margin := 100.0
minsize := 7.0
labeloc := 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()
}
// 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()
openvg.Start(w, h)
openvg.FillColor("white")
openvg.Rect(0, 0, gwidth, gheight)
filenames := flag.Args()
if len(filenames) == 0 {
doplot(beginx, beginy, "")
} else {
plotgrid(beginx, beginy, filenames)
}
openvg.SaveEnd("vgplot.raw")
bufio.NewReader(os.Stdin).ReadByte()
openvg.Finish()
}
func combohand(cx, cy, px, py, r, stroke openvg.VGfloat, t float64, value int, color string) {
thinr := float64(r * 0.25)
t = minadjust(t, value) * deg2rad
tx := cx + openvg.VGfloat(thinr*math.Cos(t))
ty := cy + openvg.VGfloat(thinr*math.Sin(t))
openvg.FillColor(color)
openvg.Ellipse(px, py, stroke*2, stroke*2)
openvg.Ellipse(tx, ty, stroke*2, stroke*2)
openvg.StrokeWidth(stroke)
openvg.StrokeColor(color)
openvg.Line(cx, cy, tx, ty)
openvg.StrokeWidth(stroke * 2)
openvg.Line(tx, ty, px, py)
openvg.StrokeWidth(0)
}
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()
}
func main() {
width, height := openvg.Init() // OpenGL, etc initialization
w2 := float64(width / 2)
h2 := float64(height / 2)
w := float64(width)
openvg.Start(width, height) // Start the picture
openvg.BackgroundColor("black") // Black background
openvg.FillRGB(44, 77, 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.SaveEnd("hello.raw") // 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
}
}
}
func gradient(width, height int) {
w := float64(width)
h := float64(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()
}
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
}
// sun shows the icon for clear weather
func (d *dimen) sun(color string) {
x, y, w, h := d.x, d.y, d.width, d.height
cx := x + (w / 2)
cy := y + (h / 2)
r0 := w * 0.50
r1 := w * 0.45
r2 := w * 0.30
openvg.FillColor(color)
openvg.Circle(cx, cy, r0)
openvg.StrokeColor(color)
openvg.StrokeWidth(w / 30)
for t := 0.0; t < 2*math.Pi; t += math.Pi / 6 {
c := openvg.VGfloat(math.Cos(t))
s := openvg.VGfloat(math.Sin(t))
x1 := (r1 * c) + cx
y1 := (r1 * s) + cy
x2 := (r2 * c) + cx
y2 := (r2 * s) + cy
openvg.Line(x1, y1, x2, y2)
}
openvg.StrokeWidth(0)
}
func main() {
width, height := openvg.Init() // OpenGL, etc initialization
w2 := float64(width / 2)
h2 := float64(height / 2)
w := float64(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
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()
}
// plot places a plot at the specified location with the specified dimemsions
// using the specified settings, using the specified data
func plot(x, y, w, h float64, settings plotset, d []rawdata) {
nd := len(d)
if nd < 2 {
fmt.Fprintf(os.Stderr, "%d is not enough points to plot\n", len(d))
return
}
// Compute the minima and maxima of the data
maxx, minx := d[0].x, d[0].x
maxy, miny := d[0].y, d[0].y
for _, v := range d {
if v.x > maxx {
maxx = v.x
}
if v.y > maxy {
maxy = v.y
}
if v.x < minx {
minx = v.x
}
if v.y < miny {
miny = v.y
}
}
// Prepare for a area or line chart by allocating
// polygon coordinates; for the horizon plot, you need two extra coordinates
// for the extrema.
needpoly := settings.opt["area"] || settings.opt["connect"]
var xpoly, ypoly []float64
if needpoly {
xpoly = make([]float64, nd+2)
ypoly = make([]float64, nd+2)
// preload the extrema of the polygon,
// the bottom left and bottom right of the plot's rectangle
xpoly[0] = x
ypoly[0] = y
xpoly[nd+1] = x + w
ypoly[nd+1] = y
}
// Draw the plot's bounding rectangle
if settings.opt["showbg"] && !settings.opt["sameplot"] {
openvg.FillColor(settings.attr["bgcolor"])
openvg.Rect(x, y, w, h)
}
// Loop through the data, drawing items as specified
spacer := 10.0
for i, v := range d {
xp := fmap(v.x, minx, maxx, x, x+w)
yp := fmap(v.y, miny, maxy, y, y+h)
if needpoly {
xpoly[i+1] = xp
ypoly[i+1] = yp
}
if settings.opt["showbar"] {
openvg.StrokeColor(settings.attr["barcolor"])
openvg.StrokeWidth(settings.size["barsize"])
openvg.Line(xp, yp, xp, y)
}
if settings.opt["showdot"] {
openvg.FillColor(settings.attr["dotcolor"])
openvg.StrokeWidth(0)
openvg.Circle(xp, yp, settings.size["dotsize"])
}
if settings.opt["showx"] {
if i%int(settings.size["xinterval"]) == 0 {
openvg.FillColor("black")
openvg.TextMid(xp, y-(spacer*2), fmt.Sprintf("%d", int(v.x)), settings.attr["font"], int(settings.size["fontsize"]))
openvg.StrokeColor("silver")
openvg.StrokeWidth(1)
openvg.Line(xp, y, xp, y-spacer)
}
openvg.StrokeWidth(0)
}
}
// Done constructing the points for the area or line plots, display them in one shot
if settings.opt["area"] {
openvg.FillColor(settings.attr["areacolor"])
openvg.Polygon(xpoly, ypoly)
}
if settings.opt["connect"] {
openvg.StrokeColor(settings.attr["linecolor"])
openvg.StrokeWidth(settings.size["linesize"])
openvg.Polyline(xpoly[1:nd+1], ypoly[1:nd+1])
}
// Put on the y axis labels, if specified
if settings.opt["showy"] {
bot := math.Floor(miny)
top := math.Ceil(maxy)
yrange := top - bot
interval := yrange / float64(settings.size["yinterval"])
for yax := bot; yax <= top; yax += interval {
yaxp := fmap(yax, bot, top, float64(y), float64(y+h))
openvg.FillColor("black")
openvg.TextEnd(x-spacer, yaxp, fmt.Sprintf("%.1f", yax), settings.attr["font"], int(settings.size["fontsize"]))
openvg.StrokeColor("silver")
openvg.StrokeWidth(1)
openvg.Line(x-spacer, yaxp, x, yaxp)
}
openvg.StrokeWidth(0)
}
// Finally, tack on the label, if specified
if len(settings.attr["label"]) > 0 {
openvg.FillColor(settings.attr["labelcolor"], 0.3)
openvg.TextMid(x+(w/2), y+(h/2), settings.attr["label"], settings.attr["font"], int(w/8)) // int(settings.size["fontsize"]))
}
openvg.StrokeWidth(0)
}
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()
}
// regionFill colors a rectangular region, and sets the fill color for subsequent text
func (d *dimen) regionFill(bgcolor, textcolor string) {
openvg.FillColor(bgcolor)
openvg.Rect(d.x, d.y, d.width, d.height)
openvg.FillColor(textcolor)
}
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
}
func centerdot(cx, cy, size openvg.VGfloat) {
openvg.FillColor(centercolor)
openvg.Ellipse(cx, cy, size, size)
}
func frame(cx, cy, framesize, facesize, textsize openvg.VGfloat, framecolor, facecolor string) {
openvg.FillColor(framecolor)
openvg.Roundrect(cx-framesize/2, cy-framesize/2, framesize, framesize, textsize, textsize)
openvg.FillColor(facecolor)
openvg.Ellipse(cx, cy, facesize*2.4, facesize*2.4)
}