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/op/clip"
"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) {
defer os.Exit(0)
win := app.NewWindow(
app.Title("Gonum"),
app.Size(
unit.Dp(float32(w.Dots(dpi))),
unit.Dp(float32(h.Dots(dpi))),
),
)
done := time.NewTimer(2 * time.Second)
defer done.Stop()
for e := range win.Events() {
switch e := e.(type) {
case system.FrameEvent:
var (
ops op.Ops
gtx = layout.NewContext(&ops, e)
)
// register a global key listener for the escape key wrapping our entire UI.
area := clip.Rect{Max: gtx.Constraints.Max}.Push(gtx.Ops)
key.InputOp{
Tag: win,
Keys: key.NameEscape + "|Ctrl-Q|Alt-Q",
}.Add(gtx.Ops)
for _, e := range gtx.Events(win) {
switch e := e.(type) {
case key.Event:
switch e.Name {
case key.NameEscape:
return
case "Q":
if e.Modifiers.Contain(key.ModCtrl) {
return
}
if e.Modifiers.Contain(key.ModAlt) {
return
}
}
}
}
area.Pop()
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())
cnv := vggio.New(gtx, w, h, vggio.UseDPI(dpi))
p.Draw(draw.New(cnv))
e.Frame(cnv.Paint())
case system.DestroyEvent:
return
}
}
}(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) DrawImage ¶ added in v0.9.0
DrawImage draws the image, scaled to fit the destination rectangle.
func (*Canvas) FillString ¶ added in v0.9.0
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 ¶ added in v0.9.0
func (c *Canvas) Pop()
Pop restores the context saved by the corresponding call to Push().
func (*Canvas) Push ¶ added in v0.9.0
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 ¶ added in v0.9.0
Rotate applies a rotation transform to the context. The parameter is specified in radians.
func (*Canvas) Screenshot ¶ added in v0.9.0
Screenshot returns a screenshot of the canvas as an image.
func (*Canvas) SetColor ¶ added in v0.9.0
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 ¶ added in v0.9.0
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 ¶ added in v0.9.0
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