New Activity widget :)

cmd/fyne_demo/tutorials/data.go

@@ -88,6 +88,11 @@ var (
  makeAccordionTab,
  true,
  },
+ "activity": {"Activity",
+ "A spinner indicating activity used in buttons etc.",
+ makeActivityTab,
+ true,
+ },
  "button": {"Button",
  "Simple widget for user tap handling.",
  makeButtonTab,
@@ -182,6 +187,6 @@ var (
  "": {"welcome", "canvas", "animations", "icons", "widgets", "collections", "containers", "dialogs", "windows", "binding", "advanced"},
  "collections": {"list", "table", "tree", "gridwrap"},
  "containers": {"apptabs", "border", "box", "center", "doctabs", "grid", "scroll", "split"},
- "widgets": {"accordion", "button", "card", "entry", "form", "input", "progress", "text", "toolbar"},
+ "widgets": {"accordion", "activity", "button", "card", "entry", "form", "input", "progress", "text", "toolbar"},
  }
 )

cmd/fyne_demo/tutorials/widget.go

@@ -11,6 +11,7 @@ import (
  "fyne.io/fyne/v2/cmd/fyne_demo/data"
  "fyne.io/fyne/v2/container"
  "fyne.io/fyne/v2/data/validation"
+ "fyne.io/fyne/v2/dialog"
  "fyne.io/fyne/v2/driver/mobile"
  "fyne.io/fyne/v2/layout"
  "fyne.io/fyne/v2/theme"
@@ -55,6 +56,55 @@ func makeAccordionTab(_ fyne.Window) fyne.CanvasObject {
  return ac
 }
 
+func makeActivityTab(win fyne.Window) fyne.CanvasObject {
+ a1 := widget.NewActivity()
+ a2 := widget.NewActivity()
+
+ var button *widget.Button
+ start := func() {
+ button.Disable()
+ a1.Start()
+ a1.Show()
+ a2.Start()
+ a2.Show()
+
+ defer func() {
+ go func() {
+ time.Sleep(time.Second * 10)
+ a1.Stop()
+ a1.Hide()
+ a2.Stop()
+ a2.Hide()
+
+ button.Enable()
+ }()
+ }()
+ }
+
+ button = widget.NewButton("Animate", start)
+ start()
+
+ return container.NewCenter(container.NewGridWithColumns(1,
+ container.NewCenter(container.NewVBox(
+ container.NewHBox(widget.NewLabel("Working..."), a1),
+ container.NewStack(button, a2))),
+ container.NewCenter(widget.NewButton("Show dialog", func() {
+ prop := canvas.NewRectangle(color.Transparent)
+ prop.SetMinSize(fyne.NewSize(50, 50))
+
+ a3 := widget.NewActivity()
+ d := dialog.NewCustomWithoutButtons("Please wait...", container.NewStack(prop, a3), win)
+ a3.Start()
+ d.Show()
+
+ go func() {
+ time.Sleep(time.Second * 5)
+ a3.Stop()
+ d.Hide()
+ }()
+ }))))
+}
+
 func makeButtonTab(_ fyne.Window) fyne.CanvasObject {
  disabled := widget.NewButton("Disabled", func() {})
  disabled.Disable()

internal/painter/draw.go

@@ -16,14 +16,15 @@ const quarterCircleControl = 1 - 0.55228
 // The bounds of the output image will be increased by vectorPad to allow for stroke overflow at the edges.
 // The scale function is used to understand how many pixels are required per unit of size.
 func DrawCircle(circle *canvas.Circle, vectorPad float32, scale func(float32) float32) *image.RGBA {
- radius := fyne.Min(circle.Size().Width, circle.Size().Height) / 2
+ size := circle.Size()
+ radius := fyne.Min(size.Width, size.Height) / 2
 
- width := int(scale(circle.Size().Width + vectorPad*2))
- height := int(scale(circle.Size().Height + vectorPad*2))
+ width := int(scale(size.Width + vectorPad*2))
+ height := int(scale(size.Height + vectorPad*2))
  stroke := scale(circle.StrokeWidth)
 
  raw := image.NewRGBA(image.Rect(0, 0, width, height))
- scanner := rasterx.NewScannerGV(int(circle.Size().Width), int(circle.Size().Height), raw, raw.Bounds())
+ scanner := rasterx.NewScannerGV(int(size.Width), int(size.Height), raw, raw.Bounds())
 
  if circle.FillColor != nil {
  filler := rasterx.NewFiller(width, height, scanner)

internal/painter/gl/draw.go

@@ -29,6 +29,65 @@ func (p *painter) defineVertexArray(prog Program, name string, size, stride, off
 func (p *painter) drawCircle(circle *canvas.Circle, pos fyne.Position, frame fyne.Size) {
  p.drawTextureWithDetails(circle, p.newGlCircleTexture, pos, circle.Size(), frame, canvas.ImageFillStretch,
  1.0, paint.VectorPad(circle))
+
+ size := circle.Size()
+ radius := size.Width / 2
+ if size.Height < size.Width {
+ radius = size.Height / 2
+ }
+ program := p.roundRectangleProgram
+
+ // Vertex: BEG
+ bounds, points := p.vecSquareCoords(pos, circle, frame)
+ p.ctx.UseProgram(program)
+ vbo := p.createBuffer(points)
+ p.defineVertexArray(program, "vert", 2, 4, 0)
+ p.defineVertexArray(program, "normal", 2, 4, 2)
+
+ p.ctx.BlendFunc(srcAlpha, oneMinusSrcAlpha)
+ p.logError()
+ // Vertex: END
+
+ // Fragment: BEG
+ frameSizeUniform := p.ctx.GetUniformLocation(program, "frame_size")
+ frameWidthScaled, frameHeightScaled := p.scaleFrameSize(frame)
+ p.ctx.Uniform2f(frameSizeUniform, frameWidthScaled, frameHeightScaled)
+
+ rectCoordsUniform := p.ctx.GetUniformLocation(program, "rect_coords")
+ x1Scaled, x2Scaled, y1Scaled, y2Scaled := p.scaleRectCoords(bounds[0], bounds[2], bounds[1], bounds[3])
+ p.ctx.Uniform4f(rectCoordsUniform, x1Scaled, x2Scaled, y1Scaled, y2Scaled)
+
+ strokeWidthScaled := roundToPixel(circle.StrokeWidth*p.pixScale, 1.0)
+ strokeUniform := p.ctx.GetUniformLocation(program, "stroke_width_half")
+ p.ctx.Uniform1f(strokeUniform, strokeWidthScaled*0.5)
+
+ rectSizeUniform := p.ctx.GetUniformLocation(program, "rect_size_half")
+ rectSizeWidthScaled := x2Scaled - x1Scaled - strokeWidthScaled
+ rectSizeHeightScaled := y2Scaled - y1Scaled - strokeWidthScaled
+ p.ctx.Uniform2f(rectSizeUniform, rectSizeWidthScaled*0.5, rectSizeHeightScaled*0.5)
+
+ radiusUniform := p.ctx.GetUniformLocation(program, "radius")
+ radiusScaled := roundToPixel(radius*p.pixScale, 1.0)
+ p.ctx.Uniform1f(radiusUniform, radiusScaled)
+
+ var r, g, b, a float32
+ fillColorUniform := p.ctx.GetUniformLocation(program, "fill_color")
+ r, g, b, a = getFragmentColor(circle.FillColor)
+ p.ctx.Uniform4f(fillColorUniform, r, g, b, a)
+
+ strokeColorUniform := p.ctx.GetUniformLocation(program, "stroke_color")
+ strokeColor := circle.StrokeColor
+ if strokeColor == nil {
+ strokeColor = color.Transparent
+ }
+ r, g, b, a = getFragmentColor(strokeColor)
+ p.ctx.Uniform4f(strokeColorUniform, r, g, b, a)
+ p.logError()
+ // Fragment: END
+
+ p.ctx.DrawArrays(triangleStrip, 0, 4)
+ p.logError()
+ p.freeBuffer(vbo)
 }
 
 func (p *painter) drawGradient(o fyne.CanvasObject, texCreator func(fyne.CanvasObject) Texture, pos fyne.Position, frame fyne.Size) {
@@ -338,15 +397,19 @@ func rectInnerCoords(size fyne.Size, pos fyne.Position, fill canvas.ImageFill, a
 }
 
 func (p *painter) vecRectCoords(pos fyne.Position, rect *canvas.Rectangle, frame fyne.Size) ([4]float32, []float32) {
+ return p.vecRectCoordsWithPad(pos, rect, frame, 0, 0)
+}
+
+func (p *painter) vecRectCoordsWithPad(pos fyne.Position, rect fyne.CanvasObject, frame fyne.Size, xPad, yPad float32) ([4]float32, []float32) {
  size := rect.Size()
  pos1 := rect.Position()
 
- xPosDiff := pos.X - pos1.X
- yPosDiff := pos.Y - pos1.Y
+ xPosDiff := pos.X - pos1.X + xPad
+ yPosDiff := pos.Y - pos1.Y + yPad
  pos1.X = roundToPixel(pos1.X+xPosDiff, p.pixScale)
  pos1.Y = roundToPixel(pos1.Y+yPosDiff, p.pixScale)
- size.Width = roundToPixel(size.Width, p.pixScale)
- size.Height = roundToPixel(size.Height, p.pixScale)
+ size.Width = roundToPixel(size.Width-2*xPad, p.pixScale)
+ size.Height = roundToPixel(size.Height-2*yPad, p.pixScale)
 
  x1Pos := pos1.X
  x1Norm := -1 + x1Pos*2/frame.Width
@@ -367,6 +430,18 @@ func (p *painter) vecRectCoords(pos fyne.Position, rect *canvas.Rectangle, frame
  return [4]float32{x1Pos, y1Pos, x2Pos, y2Pos}, coords
 }
 
+func (p *painter) vecSquareCoords(pos fyne.Position, rect fyne.CanvasObject, frame fyne.Size) ([4]float32, []float32) {
+ xPad, yPad := float32(0), float32(0)
+ size := rect.Size()
+ if size.Width > size.Height {
+ xPad = (size.Width - size.Height) / 2
+ } else {
+ yPad = (size.Height - size.Width) / 2
+ }
+
+ return p.vecRectCoordsWithPad(pos, rect, frame, xPad, yPad)
+}
+
 func roundToPixel(v float32, pixScale float32) float32 {
  if pixScale == 1.0 {
  return float32(math.Round(float64(v)))

widget/activity.go

@@ -0,0 +1,148 @@
+package widget
+
+import (
+ "image/color"
+ "time"
+
+ "fyne.io/fyne/v2"
+ "fyne.io/fyne/v2/canvas"
+ "fyne.io/fyne/v2/internal/cache"
+ "fyne.io/fyne/v2/theme"
+)
+
+var _ fyne.Widget = (*Activity)(nil)
+
+// Activity is used to indicate that something is happening that should be waited for,
+// or is in the background (depending on usage).
+//
+// Since: 2.5
+type Activity struct {
+ BaseWidget
+}
+
+// NewActivity returns a widget for indicating activity
+//
+// Since: 2.5
+func NewActivity() *Activity {
+ a := &Activity{}
+ a.ExtendBaseWidget(a)
+ return a
+}
+
+func (a *Activity) MinSize() fyne.Size {
+ a.ExtendBaseWidget(a)
+
+ return fyne.NewSquareSize(theme.IconInlineSize())
+}
+
+// Start the activity indicator animation
+func (a *Activity) Start() {
+ if r, ok := cache.Renderer(a.super()).(*activityRenderer); ok {
+ r.start()
+ }
+}
+
+// Stop the activity indicator animation
+func (a *Activity) Stop() {
+ if r, ok := cache.Renderer(a.super()).(*activityRenderer); ok {
+ r.stop()
+ }
+}
+
+func (a *Activity) CreateRenderer() fyne.WidgetRenderer {
+ dots := make([]fyne.CanvasObject, 3)
+ for i := range dots {
+ dots[i] = canvas.NewCircle(theme.ForegroundColor())
+ }
+ r := &activityRenderer{dots: dots}
+ r.anim = &fyne.Animation{
+ Duration: time.Second * 2,
+ RepeatCount: fyne.AnimationRepeatForever,
+ Tick: r.animate}
+ r.updateColor()
+ return r
+}
+
+var _ fyne.WidgetRenderer = (*activityRenderer)(nil)
+
+type activityRenderer struct {
+ anim *fyne.Animation
+ dots []fyne.CanvasObject
+
+ bound fyne.Size
+ maxCol color.NRGBA
+ maxRad float32
+}
+
+func (a *activityRenderer) Destroy() {
+ a.stop()
+}
+
+func (a *activityRenderer) Layout(size fyne.Size) {
+ a.maxRad = fyne.Min(size.Width, size.Height) / 2
+ a.bound = size
+}
+
+func (a *activityRenderer) MinSize() fyne.Size {
+ return fyne.NewSquareSize(theme.IconInlineSize())
+}
+
+func (a *activityRenderer) Objects() []fyne.CanvasObject {
+ return a.dots
+}
+
+func (a *activityRenderer) Refresh() {
+ a.updateColor()
+}
+
+func (a *activityRenderer) animate(done float32) {
+ off := done * 2
+ if off > 1 {
+ off = 2 - off
+ }
+
+ off1 := (done + 0.25) * 2
+ if done >= 0.75 {
+ off1 = (done - 0.75) * 2
+ }
+ if off1 > 1 {
+ off1 = 2 - off1
+ }
+
+ off2 := (done + 0.75) * 2
+ if done >= 0.25 {
+ off2 = (done - 0.25) * 2
+ }
+ if off2 > 1 {
+ off2 = 2 - off2
+ }
+
+ a.scaleDot(a.dots[0].(*canvas.Circle), off)
+ a.scaleDot(a.dots[1].(*canvas.Circle), off1)
+ a.scaleDot(a.dots[2].(*canvas.Circle), off2)
+}
+
+func (a *activityRenderer) scaleDot(dot *canvas.Circle, off float32) {
+ rad := a.maxRad - a.maxRad*off/1.2
+ mid := fyne.NewPos(a.bound.Width/2, a.bound.Height/2)
+
+ dot.Move(mid.Subtract(fyne.NewSquareOffsetPos(rad)))
+ dot.Resize(fyne.NewSquareSize(rad * 2))
+
+ alpha := uint8(0 + int(float32(a.maxCol.A)*off))
+ dot.FillColor = color.NRGBA{R: a.maxCol.R, G: a.maxCol.G, B: a.maxCol.B, A: alpha}
+ dot.Refresh()
+}
+
+func (a *activityRenderer) start() {
+ a.anim.Start()
+}
+
+func (a *activityRenderer) stop() {
+ a.anim.Stop()
+}
+
+func (a *activityRenderer) updateColor() {
+ rr, gg, bb, aa := theme.ForegroundColor().RGBA()
+ a.maxCol = color.NRGBA{R: uint8(rr >> 8), G: uint8(gg >> 8), B: uint8(bb >> 8), A: uint8(aa >> 8)}
+}

widget/activity_internal_test.go

@@ -0,0 +1,33 @@
+package widget
+
+import (
+ "testing"
+
+ "fyne.io/fyne/v2/test"
+)
+
+func TestActivity_Animation(t *testing.T) {
+ test.NewApp()
+ defer test.NewApp()
+ test.ApplyTheme(t, test.NewTheme())
+
+ a := NewActivity()
+ w := test.NewWindow(a)
+ w.SetPadded(false)
+ defer w.Close()
+ w.Resize(a.MinSize())
+
+ render := test.WidgetRenderer(a).(*activityRenderer)
+ render.anim.Tick(0)
+ test.AssertImageMatches(t, "activity/animate_0.0.png", w.Canvas().Capture())
+
+ render.anim.Tick(0.25)
+ test.AssertImageMatches(t, "activity/animate_0.25.png", w.Canvas().Capture())
+
+ render.anim.Tick(0.5)
+ test.AssertImageMatches(t, "activity/animate_0.5.png", w.Canvas().Capture())
+
+ // check reset to loop
+ render.anim.Tick(1.0)
+ test.AssertImageMatches(t, "activity/animate_0.0.png", w.Canvas().Capture())
+}