Golang nanovgo.Context类代码示例

func loadImageDirectory(ctx *nanovgo.Context, dir string) []nanogui.Image {
	var images []nanogui.Image
	files, err := ioutil.ReadDir(dir)
	if err != nil {
		panic(fmt.Sprintf("loadImageDirectory: read error %v\n", err))
	}
	for _, file := range files {
		if file.IsDir() {
			continue
		}
		ext := path.Ext(file.Name())
		if ext != ".png" {
			continue
		}
		fullPath := path.Join(dir, file.Name())
		img := ctx.CreateImage(fullPath, 0)
		if img == 0 {
			panic("Could not open image data!")
		}
		images = append(images, nanogui.Image{
			ImageID: img,
			Name:    fullPath[:len(fullPath)-4],
		})
	}
	return images
}

func (i *ImageView) PreferredSize(self Widget, ctx *nanovgo.Context) (int, int) {
	if i.image == 0 {
		return 0, 0
	}
	w, h, _ := ctx.ImageSize(i.image)
	return w, h
}

func drawLabel(ctx *nanovgo.Context, text string, x, y, w, h float32) {

	ctx.SetFontSize(18.0)
	ctx.SetFontFace("sans")
	ctx.SetFillColor(nanovgo.RGBA(255, 255, 255, 128))

	ctx.SetTextAlign(nanovgo.AlignLeft | nanovgo.AlignMiddle)
	ctx.Text(x, y+h*0.5, text)
}

func drawEditBox(ctx *nanovgo.Context, text string, x, y, w, h float32) {

	drawEditBoxBase(ctx, x, y, w, h)

	ctx.SetFontSize(20.0)
	ctx.SetFontFace("sans")
	ctx.SetFillColor(nanovgo.RGBA(255, 255, 255, 64))
	ctx.SetTextAlign(nanovgo.AlignLeft | nanovgo.AlignMiddle)
	ctx.Text(x+h*0.3, y+h*0.5, text)
}

func RenderDemo(ctx *nanovgo.Context, mx, my, width, height, t float32, blowup bool, data *DemoData) {
	drawEyes(ctx, width-250, 50, 150, 100, mx, my, t)
	drawParagraph(ctx, width-450, 50, 150, 100, mx, my)
	drawGraph(ctx, 0, height/2, width, height/2, t)
	drawColorWheel(ctx, width-300, height-300, 250.0, 250.0, t)

	// Line joints
	drawLines(ctx, 120, height-50, 600, 50, t)

	// Line widths
	drawWidths(ctx, 10, 50, 30)

	// Line caps
	drawCaps(ctx, 10, 300, 30)

	drawScissor(ctx, 50, height-80, t)

	ctx.Save()
	defer ctx.Restore()

	if blowup {
		ctx.Rotate(sinF(t*0.3) * 5.0 / 180.0 * nanovgo.PI)
		ctx.Scale(2.0, 2.0)
	}

	// Widgets
	drawWindow(ctx, "Widgets `n Stuff", 50, 50, 300, 400)
	var x float32 = 60.0
	var y float32 = 95.0
	drawSearchBox(ctx, "Search", x, y, 280, 25)
	y += 40
	drawDropDown(ctx, "Effects", x, y, 280, 28)
	popy := y + 14
	y += 45

	// Form
	drawLabel(ctx, "Login", x, y, 280, 20)
	y += 25
	drawEditBox(ctx, "Email", x, y, 280, 28)
	y += 35
	drawEditBox(ctx, "Password", x, y, 280, 28)
	y += 38
	drawCheckBox(ctx, "Remember me", x, y, 140, 28)
	drawButton(ctx, IconLOGIN, "Sign in", x+138, y, 140, 28, nanovgo.RGBA(0, 96, 128, 255))
	y += 45

	// Slider
	drawLabel(ctx, "Diameter", x, y, 280, 20)
	y += 25
	drawEditBoxNum(ctx, "123.00", "px", x+180, y, 100, 28)
	drawSlider(ctx, 0.4, x, y, 170, 28)
	y += 55

	drawButton(ctx, IconTRASH, "Delete", x, y, 160, 28, nanovgo.RGBA(128, 16, 8, 255))
	drawButton(ctx, 0, "Cancel", x+170, y, 110, 28, nanovgo.RGBA(0, 0, 0, 0))

	// Thumbnails box
	drawThumbnails(ctx, 365, popy-30, 160, 300, data.Images, t)
}

func (i *ImageView) Draw(self Widget, ctx *nanovgo.Context) {
	if i.image == 0 {
		return
	}
	x := float32(i.x)
	y := float32(i.y)
	ow := float32(i.w)
	oh := float32(i.h)

	var w, h float32
	{
		iw, ih, _ := ctx.ImageSize(i.image)
		w = float32(iw)
		h = float32(ih)
	}

	if i.policy == ImageSizePolicyFixed {
		if ow < w {
			h = float32(int(h * ow / w))
			w = ow
		}
		if oh < h {
			w = float32(int(w * oh / h))
			h = oh
		}
	} else { // mPolicy == Expand
		// expand to width
		h = float32(int(h * ow / w))
		w = ow
		// shrink to height, if necessary
		if oh < h {
			w = float32(int(w * oh / h))
			h = oh
		}
	}

	imgPaint := nanovgo.ImagePattern(x, y, w, h, 0, i.image, 1.0)

	ctx.BeginPath()
	ctx.Rect(x, y, w, h)
	ctx.SetFillPaint(imgPaint)
	ctx.Fill()
}

func loadImageDirectory(ctx *nanovgo.Context, dir string) []nanogui.Image {
	var images []nanogui.Image
	files, err := AssetDir("icons")
	if err != nil {
		panic(err)
	}
	for _, file := range files {
		fullPath := fmt.Sprintf("%s/%s", "icons", file)
		img := ctx.CreateImageFromMemory(0, MustAsset(fullPath))
		if img == 0 {
			panic("Could not open image data!")
		}
		images = append(images, nanogui.Image{
			ImageID: img,
			Name:    fullPath[:len(fullPath)-4],
		})
	}
	return images
}

func (t *TextBox) PreferredSize(self Widget, ctx *nanovgo.Context) (int, int) {
	sizeH := float32(t.FontSize()) * 1.4

	var unitWidth, textWidth float32
	ctx.SetFontSize(float32(t.FontSize()))
	if t.unitImage > 0 {
		w, h, _ := ctx.ImageSize(t.unitImage)
		unitHeight := sizeH * 0.4
		unitWidth = float32(w) * unitHeight / float32(h)
	} else if t.units != "" {
		unitWidth, _ = ctx.TextBounds(0, 0, t.units)
	}

	textWidth, _ = ctx.TextBounds(0, 0, string(t.editingText()))
	sizeW := sizeH + textWidth + unitWidth
	return int(sizeW), int(sizeH)
}

func (c *CheckBox) PreferredSize(self Widget, ctx *nanovgo.Context) (int, int) {
	fw, fh := c.FixedSize()
	if fw > 0 || fh > 0 {
		return fw, fh
	}
	fontSize := float32(c.FontSize())
	ctx.SetFontSize(fontSize)
	ctx.SetFontFace(c.theme.FontNormal)
	w, _ := ctx.TextBounds(0, 0, c.caption)
	return int(w + 1.7*fontSize), int(fontSize * 1.3)
}

func (w *Window) PreferredSize(self Widget, ctx *nanovgo.Context) (int, int) {
	if w.buttonPanel != nil {
		w.buttonPanel.SetVisible(false)
	}
	width, height := w.WidgetImplement.PreferredSize(self, ctx)
	if w.buttonPanel != nil {
		w.buttonPanel.SetVisible(true)
	}
	ctx.SetFontSize(18.0)
	ctx.SetFontFace(w.theme.FontBold)
	_, bounds := ctx.TextBounds(0, 0, w.title)

	return maxI(width, int(bounds[2]-bounds[0])+20), maxI(height, int(bounds[3]-bounds[1]))
}

func NewStandardTheme(ctx *nanovgo.Context) *Theme {
	ctx.CreateFontFromMemory("sans", MustAsset("fonts/Roboto-Regular.ttf"), 0)
	ctx.CreateFontFromMemory("sans-bold", MustAsset("fonts/Roboto-Bold.ttf"), 0)
	ctx.CreateFontFromMemory("icons", MustAsset("fonts/entypo.ttf"), 0)
	return &Theme{
		StandardFontSize:     16,
		ButtonFontSize:       20,
		TextBoxFontSize:      20,
		WindowCornerRadius:   2,
		WindowHeaderHeight:   30,
		WindowDropShadowSize: 10,
		ButtonCornerRadius:   2,

		DropShadow:        nanovgo.MONO(0, 128),
		Transparent:       nanovgo.MONO(0, 0),
		BorderDark:        nanovgo.MONO(29, 255),
		BorderLight:       nanovgo.MONO(92, 255),
		BorderMedium:      nanovgo.MONO(35, 255),
		TextColor:         nanovgo.MONO(255, 160),
		DisabledTextColor: nanovgo.MONO(255, 80),
		TextColorShadow:   nanovgo.MONO(0, 160),
		IconColor:         nanovgo.MONO(255, 160),

		ButtonGradientTopFocused:   nanovgo.MONO(64, 255),
		ButtonGradientBotFocused:   nanovgo.MONO(48, 255),
		ButtonGradientTopUnfocused: nanovgo.MONO(74, 255),
		ButtonGradientBotUnfocused: nanovgo.MONO(58, 255),
		ButtonGradientTopPushed:    nanovgo.MONO(41, 255),
		ButtonGradientBotPushed:    nanovgo.MONO(29, 255),

		WindowFillUnfocused:  nanovgo.MONO(43, 230),
		WindowFillFocused:    nanovgo.MONO(45, 230),
		WindowTitleUnfocused: nanovgo.MONO(220, 160),
		WindowTitleFocused:   nanovgo.MONO(255, 190),

		WindowHeaderGradientTop: nanovgo.MONO(74, 255),
		WindowHeaderGradientBot: nanovgo.MONO(58, 255),
		WindowHeaderSepTop:      nanovgo.MONO(92, 255),
		WindowHeaderSepBot:      nanovgo.MONO(29, 255),

		WindowPopup:            nanovgo.MONO(50, 255),
		WindowPopupTransparent: nanovgo.MONO(50, 0),

		FontNormal: "sans",
		FontBold:   "sans-bold",
		FontIcons:  "icons",
	}
}

func LoadDemo(ctx *nanovgo.Context) *demo.DemoData {
	d := &demo.DemoData{}
	for i := 0; i < 12; i++ {
		path := fmt.Sprintf("assets/image%d.jpg", i+1)
		d.Images = append(d.Images, ctx.CreateImageFromMemory(0, demo.MustAsset(path)))
		if d.Images[i] == 0 {
			log.Fatalf("Could not load %s", path)
		}
	}

	d.FontIcons = ctx.CreateFontFromMemory("icons", demo.MustAsset("assets/entypo.ttf"), 0)
	if d.FontIcons == -1 {
		log.Fatalln("Could not add font icons.")
	}
	d.FontNormal = ctx.CreateFontFromMemory("sans", demo.MustAsset("assets/Roboto-Regular.ttf"), 0)
	if d.FontNormal == -1 {
		log.Fatalln("Could not add font italic.")
	}
	d.FontBold = ctx.CreateFontFromMemory("sans-bold", demo.MustAsset("assets/Roboto-Bold.ttf"), 0)
	if d.FontBold == -1 {
		log.Fatalln("Could not add font bold.")
	}
	return d
}

func (sf *SpinnerFilter) Draw(self nanogui.Widget, ctx *nanovgo.Context) {
	if sf.isActive() {
		var py int
		fw, fh := sf.Parent().Size()
		if window, ok := sf.Parent().(*nanogui.Window); ok {
			hh := window.Theme().WindowHeaderHeight
			py += hh
			fh -= hh
		}
		sf.SetPosition(0, py)
		sf.SetSize(fw, fh)

		currentTime := nanogui.GetTime() - sf.startTime

		var alpha float32
		var showSpinner bool
		if sf.state == SpinnerFadeIn {
			if currentTime > 1 {
				alpha = 0.7
				showSpinner = true
			} else {
				alpha = currentTime * 0.7
			}
		} else {
			if currentTime > 1 {
				alpha = 0.7
			} else {
				alpha = (1.0 - currentTime) * 0.7
			}
		}
		ctx.Save()
		ctx.BeginPath()
		ctx.SetFillColor(nanovgo.MONOf(0, alpha))
		ctx.Rect(0, float32(py), float32(fw), float32(fh))
		ctx.Fill()
		if showSpinner {
			cx := float32(fw / 2)
			cy := float32(py + fh/2)
			rotation := 2 * math.Pi * float64(currentTime*float32(sf.speed)*float32(sf.num)) / float64(sf.num)
			dr := float64(2 * math.Pi / float64(sf.num))
			ctx.SetStrokeWidth(sf.lineWidth)
			for i := 0; i < sf.num; i++ {
				ctx.BeginPath()
				ctx.MoveTo(cx+float32(math.Cos(rotation))*sf.c1, cy+float32(math.Sin(rotation))*sf.c1)
				ctx.LineTo(cx+float32(math.Cos(rotation))*sf.c2, cy+float32(math.Sin(rotation))*sf.c2)
				ctx.SetStrokeColor(nanovgo.MONOf(1.0, float32(i)/float32(sf.num)))
				ctx.Stroke()
				rotation += dr
			}
		}
		ctx.Restore()
	} else {
		sf.SetSize(0, 0)
		sf.SetVisible(false)
		return
	}
}

func (p *ProgressBar) Draw(self Widget, ctx *nanovgo.Context) {
	px := float32(p.x)
	py := float32(p.y)
	pw := float32(p.w)
	ph := float32(p.h)
	p.WidgetImplement.Draw(self, ctx)
	paint := nanovgo.BoxGradient(px+1, py+1, pw-2, ph, 3, 4, nanovgo.MONO(0, 32), nanovgo.MONO(0, 92))
	ctx.BeginPath()
	ctx.RoundedRect(px, py, pw, ph, 3)
	ctx.SetFillPaint(paint)
	ctx.Fill()

	value := clampF(p.value, 0.0, 1.0)
	barPos := (pw - 2) * value
	barPaint := nanovgo.BoxGradient(px, py, barPos+1.5, ph-1, 3, 4, nanovgo.MONO(220, 100), nanovgo.MONO(128, 100))
	ctx.BeginPath()
	ctx.RoundedRect(px+1, py+1, barPos, ph-2, 3)
	ctx.SetFillPaint(barPaint)
	ctx.Fill()
}

func (c *ColorWheel) Draw(self Widget, ctx *nanovgo.Context) {
	c.WidgetImplement.Draw(self, ctx)

	if !c.visible {
		return
	}
	x := float32(c.x)
	y := float32(c.y)
	w := float32(c.w)
	h := float32(c.h)

	ctx.Save()
	defer ctx.Restore()

	cx := x + w*0.5
	cy := y + h*0.5
	r1 := toF(w < h, w, h)*0.5 - 5.0
	r0 := r1 * 0.75

	aeps := 0.7 / r1 // half a pixel arc length in radians (2pi cancels out).
	for i := 0; i < 6; i++ {
		a0 := float32(i)/6.0*nanovgo.PI*2.0 - aeps
		a1 := float32(i+1)/6.0*nanovgo.PI*2.0 + aeps
		ctx.BeginPath()
		ctx.Arc(cx, cy, r0, a0, a1, nanovgo.Clockwise)
		ctx.Arc(cx, cy, r1, a1, a0, nanovgo.CounterClockwise)
		ctx.ClosePath()

		sin1, cos1 := sinCosF(a0)
		sin2, cos2 := sinCosF(a1)
		ax := cx + cos1*(r0+r1)*0.5
		ay := cy + sin1*(r0+r1)*0.5
		bx := cx + cos2*(r0+r1)*0.5
		by := cy + sin2*(r0+r1)*0.5
		color1 := nanovgo.HSLA(a0/(nanovgo.PI*2), 1.0, 0.55, 255)
		color2 := nanovgo.HSLA(a1/(nanovgo.PI*2), 1.0, 0.55, 255)
		paint := nanovgo.LinearGradient(ax, ay, bx, by, color1, color2)
		ctx.SetFillPaint(paint)
		ctx.Fill()
	}

	ctx.BeginPath()
	ctx.Circle(cx, cy, r0-0.5)
	ctx.Circle(cx, cy, r1+0.5)
	ctx.SetStrokeColor(nanovgo.MONO(0, 64))
	ctx.Stroke()

	// Selector
	ctx.Save()
	defer ctx.Restore()
	ctx.Translate(cx, cy)
	ctx.Rotate(c.hue * nanovgo.PI * 2)

	// Marker on
	u := clampF(r1/50, 1.5, 4.0)
	ctx.SetStrokeWidth(u)
	ctx.BeginPath()
	ctx.Rect(r0-1, -2*u, r1-r0+2, 4*u)
	ctx.SetStrokeColor(nanovgo.MONO(255, 192))
	ctx.Stroke()

	paint := nanovgo.BoxGradient(r0-3, -5, r1-r0+6, 10, 2, 4, nanovgo.MONO(0, 128), nanovgo.MONO(0, 0))
	ctx.BeginPath()
	ctx.Rect(r0-2-10, -4-10, r1-r0+4+20, 8+20)
	ctx.Rect(r0-2, -4, r1-r0+4, 8)
	ctx.PathWinding(nanovgo.Hole)
	ctx.SetFillPaint(paint)
	ctx.Fill()

	// Center triangle
	r := r0 - 6
	sin1, cos1 := sinCosF(120.0 / 180.0 * nanovgo.PI)
	sin2, cos2 := sinCosF(-120.0 / 180.0 * nanovgo.PI)
	ax := cos1 * r
	ay := sin1 * r
	bx := cos2 * r
	by := sin2 * r
	ctx.BeginPath()
	ctx.MoveTo(r, 0)
	ctx.LineTo(ax, ay)
	ctx.LineTo(bx, by)
	ctx.ClosePath()
	triPaint1 := nanovgo.LinearGradient(r, 0, ax, ay, nanovgo.HSL(c.hue, 1.0, 0.5), nanovgo.MONO(255, 255))
	ctx.SetFillPaint(triPaint1)
	ctx.Fill()
	triPaint2 := nanovgo.LinearGradient((r+ax)*0.5, ay*0.5, bx, by, nanovgo.MONO(0, 0), nanovgo.MONO(0, 255))
	ctx.SetFillPaint(triPaint2)
	ctx.Fill()

	// selector circle on triangle
	px, py := c.calculatePosition()
	ctx.SetStrokeWidth(u)
	ctx.BeginPath()
	ctx.Circle(px, py, 2*u)
	ctx.SetStrokeColor(nanovgo.MONO(255, 192))
	ctx.Stroke()
}