Documentation
¶
Overview ¶
Package vggio provides a vg.Canvas implementation backed by Gio, a toolkit that implements portable immediate GUI mode in Go.
More informations about Gio can be found at https://gioui.org/.
Index ¶
- Constants
- func UseBackgroundColor(c color.Color) option
- func UseDPI(dpi int) option
- type Canvas
- func (c *Canvas) DPI() float64
- func (c *Canvas) DrawImage(rect vg.Rectangle, img image.Image)
- func (c *Canvas) Fill(p vg.Path)
- func (c *Canvas) FillString(fnt font.Face, pt vg.Point, txt string)
- func (c *Canvas) Paint() *op.Ops
- func (c *Canvas) Pop()
- func (c *Canvas) Push()
- func (c *Canvas) Rotate(rad float64)
- func (c *Canvas) Scale(x, y float64)
- func (c *Canvas) Screenshot() (image.Image, error)
- func (c *Canvas) SetColor(clr color.Color)
- func (c *Canvas) SetLineDash(pattern []vg.Length, offset vg.Length)
- func (c *Canvas) SetLineWidth(w vg.Length)
- func (c *Canvas) Size() (w, h vg.Length)
- func (c *Canvas) Stroke(p vg.Path)
- func (c *Canvas) Translate(pt vg.Point)
Examples ¶
Constants ¶
const DefaultDPI = 96
DefaultDPI is the default dot resolution for image drawing in dots per inch.
Variables ¶
This section is empty.
Functions ¶
func UseBackgroundColor ¶
UseBackgroundColor specifies the image background color. Without UseBackgroundColor, the default color is white.
Types ¶
type Canvas ¶
type Canvas struct {
// contains filtered or unexported fields
}
Canvas implements the vg.Canvas interface, drawing to an image.Image using vgimg and painting that image into a Gioui context.
Example ¶
package main
import (
"image/color"
"math"
"os"
"time"
"gioui.org/app"
"gioui.org/io/key"
"gioui.org/io/system"
"gioui.org/layout"
"gioui.org/op"
"gioui.org/unit"
"gonum.org/v1/plot"
"gonum.org/v1/plot/plotter"
"gonum.org/v1/plot/vg"
"gonum.org/v1/plot/vg/draw"
"gonum.org/v1/plot/vg/vggio"
)
func main() {
const (
w = 20 * vg.Centimeter
h = 15 * vg.Centimeter
dpi = 96
)
go func(w, h vg.Length) {
win := app.NewWindow(
app.Title("Gonum"),
app.Size(
unit.Px(float32(w.Dots(dpi))),
unit.Px(float32(h.Dots(dpi))),
),
)
defer win.Close()
done := time.NewTimer(2 * time.Second)
defer done.Stop()
for e := range win.Events() {
switch e := e.(type) {
case system.FrameEvent:
p := plot.New()
p.Title.Text = "My title"
p.X.Label.Text = "X"
p.Y.Label.Text = "Y"
quad := plotter.NewFunction(func(x float64) float64 {
return x * x
})
quad.Color = color.RGBA{B: 255, A: 255}
exp := plotter.NewFunction(func(x float64) float64 {
return math.Pow(2, x)
})
exp.Dashes = []vg.Length{vg.Points(2), vg.Points(2)}
exp.Width = vg.Points(2)
exp.Color = color.RGBA{G: 255, A: 255}
sin := plotter.NewFunction(func(x float64) float64 {
return 10*math.Sin(x) + 50
})
sin.Dashes = []vg.Length{vg.Points(4), vg.Points(5)}
sin.Width = vg.Points(4)
sin.Color = color.RGBA{R: 255, A: 255}
p.Add(quad, exp, sin)
p.Legend.Add("x^2", quad)
p.Legend.Add("2^x", exp)
p.Legend.Add("10*sin(x)+50", sin)
p.Legend.ThumbnailWidth = 0.5 * vg.Inch
p.X.Min = 0
p.X.Max = 10
p.Y.Min = 0
p.Y.Max = 100
p.Add(plotter.NewGrid())
gtx := layout.NewContext(new(op.Ops), e)
cnv := vggio.New(gtx, w, h, vggio.UseDPI(dpi))
p.Draw(draw.New(cnv))
e.Frame(cnv.Paint())
case key.Event:
switch e.Name {
case "Q", key.NameEscape:
win.Close()
}
case system.DestroyEvent:
os.Exit(0)
}
}
}(w, h)
app.Main()
}
Output:
func New ¶
New returns a new image canvas with the provided dimensions and options. The currently accepted options are UseDPI and UseBackgroundColor. If the resolution or background color are not specified, defaults are used.
func (*Canvas) FillString ¶
FillString fills in text at the specified location using the given font. If the font size is zero, the text is not drawn.
func (*Canvas) Pop ¶
func (c *Canvas) Pop()
Pop restores the context saved by the corresponding call to Push().
func (*Canvas) Push ¶
func (c *Canvas) Push()
Push saves the current line width, the current dash pattern, the current transforms, and the current color onto a stack so that the state can later be restored by calling Pop().
func (*Canvas) Rotate ¶
Rotate applies a rotation transform to the context. The parameter is specified in radians.
func (*Canvas) Screenshot ¶
Screenshot returns a screenshot of the canvas as an image.
func (*Canvas) SetColor ¶
SetColor sets the current drawing color. Note that fill color and stroke color are the same, so if you want different fill and stroke colors then you must set a color, draw fills, set a new color and then draw lines.
The initial color is black. If SetColor is called with a nil color then black is used.
func (*Canvas) SetLineDash ¶
SetLineDash sets the dash pattern for lines. The pattern slice specifies the lengths of alternating dashes and gaps, and the offset specifies the distance into the dash pattern to start the dash.
The initial dash pattern is a solid line.
func (*Canvas) SetLineWidth ¶
SetLineWidth sets the width of stroked paths. If the width is not positive then stroked lines are not drawn.
The initial line width is 1 point.
Source Files