Revert using a separate draw thread

internal/animation/animation_test.go

@@ -12,6 +12,11 @@ import (
 	"fyne.io/fyne/v2"
 )
 
+func tick(run *Runner) {
+	time.Sleep(time.Millisecond * 5) // wait long enough that we are not at 0 time
+	run.TickAnimations()
+}
+
 func TestGLDriver_StartAnimation(t *testing.T) {
 	done := make(chan float32)
 	run := &Runner{}
@@ -22,6 +27,7 @@ func TestGLDriver_StartAnimation(t *testing.T) {
 		}}
 
 	run.Start(a)
+	go tick(run) // simulate a graphics draw loop
 	select {
 	case d := <-done:
 		assert.Greater(t, d, float32(0))
@@ -40,6 +46,7 @@ func TestGLDriver_StopAnimation(t *testing.T) {
 		}}
 
 	run.Start(a)
+	go tick(run) // simulate a graphics draw loop
 	select {
 	case d := <-done:
 		assert.Greater(t, d, float32(0))
@@ -63,8 +70,13 @@ func TestGLDriver_StopAnimationImmediatelyAndInsideTick(t *testing.T) {
 		Tick:     func(f float32) {},
 	}
 	run.Start(a)
+	go tick(run) // simulate a graphics draw loop
 	run.Stop(a)
 
+	run.animationMutex.RLock()
+	assert.Zero(t, len(run.animations))
+	run.animationMutex.RUnlock()
+
 	// stopping animation inside tick function
 	for i := 0; i < 10; i++ {
 		wg.Add(1)
@@ -85,7 +97,10 @@ func TestGLDriver_StopAnimationImmediatelyAndInsideTick(t *testing.T) {
 		Tick:     func(f float32) {},
 	}
 	run.Start(c)
+	go tick(run) // simulate a graphics draw loop
+
 	run.Stop(c)
+	go tick(run) // simulate a graphics draw loop
 
 	wg.Wait()
 	// animations stopped inside tick are really stopped in the next runner cycle

internal/animation/runner.go

@@ -24,7 +24,6 @@ func (r *Runner) Start(a *fyne.Animation) {
 	if !r.runnerStarted {
 		r.runnerStarted = true
 		r.animations = append(r.animations, newAnim(a))
-		r.runAnimations()
 	} else {
 		r.pendingAnimations = append(r.pendingAnimations, newAnim(a))
 	}
@@ -61,32 +60,34 @@ func (r *Runner) Stop(a *fyne.Animation) {
 	r.pendingAnimations = newList
 }
 
-func (r *Runner) runAnimations() {
-	draw := time.NewTicker(time.Second / 60)
-
-	go func() {
-		for done := false; !done; {
-			<-draw.C
-			r.animationMutex.Lock()
-			oldList := r.animations
-			r.animationMutex.Unlock()
-			newList := make([]*anim, 0, len(oldList))
-			for _, a := range oldList {
-				if !a.isStopped() && r.tickAnimation(a) {
-					newList = append(newList, a)
-				}
-			}
-			r.animationMutex.Lock()
-			r.animations = append(newList, r.pendingAnimations...)
-			r.pendingAnimations = nil
-			done = len(r.animations) == 0
-			r.animationMutex.Unlock()
+// TickAnimations progresses all running animations by one tick.
+// This will be called from the driver to update objects immediately before next paint.
+func (r *Runner) TickAnimations() {
+	if !r.runnerStarted {
+		return
+	}
+
+	done := false
+	r.animationMutex.Lock()
+	oldList := r.animations
+	r.animationMutex.Unlock()
+	newList := make([]*anim, 0, len(oldList))
+	for _, a := range oldList {
+		if !a.isStopped() && r.tickAnimation(a) {
+			newList = append(newList, a)
 		}
+	}
+	r.animationMutex.Lock()
+	r.animations = append(newList, r.pendingAnimations...)
+	r.pendingAnimations = nil
+	done = len(r.animations) == 0
+	r.animationMutex.Unlock()
+
+	if done {
 		r.animationMutex.Lock()
 		r.runnerStarted = false
 		r.animationMutex.Unlock()
-		draw.Stop()
-	}()
+	}
 }
 
 // tickAnimation will process a frame of animation and return true if this should continue animating

internal/driver/glfw/canvas.go

@@ -39,7 +39,7 @@ type glCanvas struct {
 
 func (c *glCanvas) Capture() image.Image {
 	var img image.Image
-	runOnDraw(c.context.(*window), func() {
+	runOnMainWithContext(c.context.(*window), func() {
 		img = c.Painter().Capture(c)
 	})
 	return img

internal/driver/glfw/driver.go

@@ -33,16 +33,12 @@ var curWindow *window
 // Declare conformity with Driver
 var _ fyne.Driver = (*gLDriver)(nil)
 
-// A workaround on Apple M1/M2, just use 1 thread until fixed upstream.
-const drawOnMainThread bool = runtime.GOOS == "darwin" && runtime.GOARCH == "arm64"
-
 const doubleTapDelay = 300 * time.Millisecond
 
 type gLDriver struct {
 	windowLock   sync.RWMutex
 	windows      []fyne.Window
 	done         chan struct{}
-	drawDone     chan struct{}
 	waitForStart chan struct{}
 
 	animation animation.Runner
@@ -181,7 +177,6 @@ func NewGLDriver() *gLDriver {
 
 	return &gLDriver{
 		done:         make(chan struct{}),
-		drawDone:     make(chan struct{}),
 		waitForStart: make(chan struct{}),
 	}
 }

internal/driver/glfw/glfw_test.go

@@ -36,7 +36,7 @@ func repaintWindow(w *window) {
 	// If we try to paint windows before the context is created, we will end up on the wrong thread.
 	<-w.driver.waitForStart
 
-	runOnDraw(w, func() {
+	runOnMainWithContext(w, func() {
 		d.repaintWindow(w)
 	})
 

internal/driver/glfw/loop.go

@@ -19,15 +19,8 @@ type funcData struct {
 	done chan struct{} // Zero allocation signalling channel
 }
 
-type drawData struct {
-	f    func()
-	win  *window
-	done chan struct{} // Zero allocation signalling channel
-}
-
 // channel for queuing functions on the main thread
 var funcQueue = make(chan funcData)
-var drawFuncQueue = make(chan drawData)
 var running atomic.Bool
 var initOnce = &sync.Once{}
 
@@ -55,16 +48,8 @@ func runOnMain(f func()) {
 }
 
 // force a function f to run on the draw thread
-func runOnDraw(w *window, f func()) {
-	if drawOnMainThread {
-		runOnMain(func() { w.RunWithContext(f) })
-		return
-	}
-	done := common.DonePool.Get().(chan struct{})
-	defer common.DonePool.Put(done)
-
-	drawFuncQueue <- drawData{f: f, win: w, done: done}
-	<-done
+func runOnMainWithContext(w *window, f func()) {
+	runOnMain(func() { w.RunWithContext(f) }) // TODO remove this completely
 }
 
 // Preallocate to avoid allocations on every drawSingleFrame.
@@ -117,12 +102,15 @@ func (d *gLDriver) runGL() {
 	if f := fyne.CurrentApp().Lifecycle().(*app.Lifecycle).OnStarted(); f != nil {
 		go f() // don't block main, we don't have window event queue
 	}
+
+	settingsChange := make(chan fyne.Settings)
+	fyne.CurrentApp().Settings().AddChangeListener(settingsChange)
+
 	eventTick := time.NewTicker(time.Second / 60)
 	for {
 		select {
 		case <-d.done:
 			eventTick.Stop()
-			d.drawDone <- struct{}{} // wait for draw thread to stop
 			d.Terminate()
 			if f := fyne.CurrentApp().Lifecycle().(*app.Lifecycle).OnStopped(); f != nil {
 				go f() // don't block main, we don't have window event queue
@@ -162,9 +150,8 @@ func (d *gLDriver) runGL() {
 					}
 				}
 
-				if drawOnMainThread {
-					d.drawSingleFrame()
-				}
+				d.animation.TickAnimations()
+				d.drawSingleFrame()
 			}
 			if windowsToRemove > 0 {
 				oldWindows := d.windowList()
@@ -199,6 +186,18 @@ func (d *gLDriver) runGL() {
 					d.Quit()
 				}
 			}
+		case set := <-settingsChange:
+			painter.ClearFontCache()
+			cache.ResetThemeCaches()
+			app.ApplySettingsWithCallback(set, fyne.CurrentApp(), func(w fyne.Window) {
+				c, ok := w.Canvas().(*glCanvas)
+				if !ok {
+					return
+				}
+				c.applyThemeOutOfTreeObjects()
+				go c.reloadScale()
+			})
+
 		}
 	}
 }
@@ -227,44 +226,6 @@ func (d *gLDriver) repaintWindow(w *window) {
 	})
 }
 
-func (d *gLDriver) startDrawThread() {
-	settingsChange := make(chan fyne.Settings)
-	fyne.CurrentApp().Settings().AddChangeListener(settingsChange)
-	var drawCh <-chan time.Time
-	if drawOnMainThread {
-		drawCh = make(chan time.Time) // don't tick when on M1
-	} else {
-		drawCh = time.NewTicker(time.Second / 60).C
-	}
-
-	go func() {
-		runtime.LockOSThread()
-
-		for {
-			select {
-			case <-d.drawDone:
-				return
-			case f := <-drawFuncQueue:
-				f.win.RunWithContext(f.f)
-				f.done <- struct{}{}
-			case set := <-settingsChange:
-				painter.ClearFontCache()
-				cache.ResetThemeCaches()
-				app.ApplySettingsWithCallback(set, fyne.CurrentApp(), func(w fyne.Window) {
-					c, ok := w.Canvas().(*glCanvas)
-					if !ok {
-						return
-					}
-					c.applyThemeOutOfTreeObjects()
-					go c.reloadScale()
-				})
-			case <-drawCh:
-				d.drawSingleFrame()
-			}
-		}
-	}()
-}
-
 // refreshWindow requests that the specified window be redrawn
 func refreshWindow(w *window) {
 	w.canvas.SetDirty()

internal/driver/glfw/loop_desktop.go

@@ -19,7 +19,6 @@ func (d *gLDriver) initGLFW() {
 		}
 
 		initCursors()
-		d.startDrawThread()
 	})
 }
 

internal/driver/glfw/loop_goxjs.go

@@ -7,8 +7,8 @@ import (
 
 	"fyne.io/fyne/v2"
 
-	gl "github.com/fyne-io/gl-js"
-	glfw "github.com/fyne-io/glfw-js"
+	"github.com/fyne-io/gl-js"
+	"github.com/fyne-io/glfw-js"
 )
 
 func (d *gLDriver) initGLFW() {
@@ -18,8 +18,6 @@ func (d *gLDriver) initGLFW() {
 			fyne.LogError("failed to initialise GLFW", err)
 			return
 		}
-
-		d.startDrawThread()
 	})
 }
 

internal/driver/glfw/loop_test.go

@@ -26,6 +26,6 @@ func BenchmarkRunOnDraw(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		runOnDraw(w, f)
+		runOnMainWithContext(w, f)
 	}
 }

internal/driver/glfw/window.go

@@ -171,7 +171,7 @@ func (w *window) doShow() {
 	if content := w.canvas.Content(); content != nil {
 		content.Show()
 
-		runOnDraw(w, func() {
+		runOnMainWithContext(w, func() {
 			w.driver.repaintWindow(w)
 		})
 	}
@@ -209,7 +209,7 @@ func (w *window) Close() {
 	}
 
 	// set w.closing flag inside draw thread to ensure we can free textures
-	runOnDraw(w, func() {
+	runOnMainWithContext(w, func() {
 		w.viewLock.Lock()
 		w.closing = true
 		w.viewLock.Unlock()

internal/driver/glfw/window_desktop.go

@@ -755,7 +755,7 @@ func (w *window) create() {
 	}
 
 	// run the GL init on the draw thread
-	runOnDraw(w, func() {
+	runOnMainWithContext(w, func() {
 		w.canvas.SetPainter(gl.NewPainter(w.canvas, w))
 		w.canvas.Painter().Init()
 	})

internal/driver/glfw/window_goxjs.go

@@ -515,7 +515,7 @@ func (w *window) create() {
 	}
 
 	// run the GL init on the draw thread
-	runOnDraw(w, func() {
+	runOnMainWithContext(w, func() {
 		w.canvas.SetPainter(gl.NewPainter(w.canvas, w))
 		w.canvas.Painter().Init()
 	})

internal/driver/glfw/window_notxdg.go

@@ -11,15 +11,8 @@ func (w *window) platformResize(canvasSize fyne.Size) {
 		return
 	}
 
-	if drawOnMainThread {
-		w.canvas.Resize(canvasSize)
-		d.repaintWindow(w)
-	} else {
-		runOnDraw(w, func() {
-			w.canvas.Resize(canvasSize)
-			d.repaintWindow(w)
-		})
-	}
+	w.canvas.Resize(canvasSize)
+	d.repaintWindow(w)
 }
 
 // GetWindowHandle returns the window handle. Only implemented for X11 currently.

internal/driver/mobile/driver.go

@@ -271,6 +271,7 @@ func (d *mobileDriver) handlePaint(e paint.Event, w fyne.Window) {
 		c.Painter().Init() // we cannot init until the context is set above
 	}
 
+	d.animation.TickAnimations()
 	canvasNeedRefresh := c.FreeDirtyTextures() > 0 || c.CheckDirtyAndClear()
 	if canvasNeedRefresh {
 		newSize := fyne.NewSize(float32(d.currentSize.WidthPx)/c.scale, float32(d.currentSize.HeightPx)/c.scale)