WIP: Improve scroll speed

event.go

@@ -35,3 +35,26 @@ type DragEvent struct {
 	PointEvent
 	Dragged Delta
 }
+
+type EventFunc interface {
+	Execute()
+}
+
+type SimpleEventFunc func()
+
+func (fn SimpleEventFunc) Execute() {
+	fn()
+}
+
+type DragEventFunc struct {
+	wid Draggable
+	ev  *DragEvent
+}
+
+func NewDragEventFunc(wid Draggable, ev *DragEvent) *DragEventFunc {
+	return &DragEventFunc{wid, ev}
+}
+
+func (drag *DragEventFunc) Execute() {
+	drag.wid.Dragged(drag.ev)
+}

internal/async/chan_go1.21.go

@@ -26,11 +26,17 @@ func NewUnboundedInterfaceChan() *UnboundedInterfaceChan {
 // CanvasObject objects. A channel must be closed via Close method.
 type UnboundedCanvasObjectChan = UnboundedChan[fyne.CanvasObject]
 
+type UnboundedEventFuncChan = UnboundedChan[fyne.EventFunc]
+
 // NewUnboundedCanvasObjectChan returns a unbounded channel, of canvas objects, with unlimited capacity.
 func NewUnboundedCanvasObjectChan() *UnboundedChan[fyne.CanvasObject] {
 	return NewUnboundedChan[fyne.CanvasObject]()
 }
 
+func NewUnboundedEventFuncChan() *UnboundedChan[fyne.EventFunc] {
+	return NewUnboundedChan[fyne.EventFunc]()
+}
+
 // UnboundedChan is a channel with an unbounded buffer for caching
 // Func objects. A channel must be closed via Close method.
 type UnboundedChan[T any] struct {

internal/async/gen.go

@@ -43,6 +43,11 @@ func main() {
 				Name:    "Interface",
 				Imports: "",
 			},
+			"chan_eventfunc.go": {
+				Type:    "fyne.EventFunc",
+				Name:    "EventFunc",
+				Imports: `import "fyne.io/fyne/v2"`,
+			},
 		},
 	}
 

internal/driver/common/window.go

@@ -1,12 +1,13 @@
 package common
 
 import (
+	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/internal/async"
 )
 
 // Window defines common functionality for windows.
 type Window struct {
-	eventQueue *async.UnboundedFuncChan
+	eventQueue *async.UnboundedEventFuncChan
 }
 
 // DestroyEventQueue destroys the event queue.
@@ -17,20 +18,45 @@ func (w *Window) DestroyEventQueue() {
 // InitEventQueue initializes the event queue.
 func (w *Window) InitEventQueue() {
 	// This channel should be closed when the window is closed.
-	w.eventQueue = async.NewUnboundedFuncChan()
+	w.eventQueue = async.NewUnboundedEventFuncChan()
 }
 
 // QueueEvent uses this method to queue up a callback that handles an event. This ensures
 // user interaction events for a given window are processed in order.
-func (w *Window) QueueEvent(fn func()) {
+func (w *Window) QueueEvent(fn fyne.EventFunc) {
 	w.eventQueue.In() <- fn
 }
 
 // RunEventQueue runs the event queue. This should called inside a go routine.
 // This function blocks.
 func (w *Window) RunEventQueue() {
-	for fn := range w.eventQueue.Out() {
-		fn()
+	for evfn := range w.eventQueue.Out() {
+		if dragfn, ok := evfn.(*fyne.DragEventFunc); ok {
+			evfn = nil
+
+		L:
+			for {
+				select {
+				case nevfn := <-w.eventQueue.Out():
+					ndragfn, ok := nevfn.(*fyne.DragEventFunc)
+					if !ok {
+						evfn = nevfn
+						break L
+					}
+					dragfn = ndragfn
+				default:
+					break L
+				}
+			}
+
+			dragfn.Execute()
+			if evfn != nil {
+				evfn.Execute()
+			}
+			continue
+		}
+
+		evfn.Execute()
 	}
 }
 
@@ -39,7 +65,7 @@ func (w *Window) WaitForEvents() {
 	done := DonePool.Get()
 	defer DonePool.Put(done)
 
-	w.eventQueue.In() <- func() { done <- struct{}{} }
+	w.eventQueue.In() <- fyne.SimpleEventFunc(func() { done <- struct{}{} })
 	<-done
 }
 

internal/driver/glfw/driver.go

@@ -93,7 +93,7 @@ func (d *gLDriver) Device() fyne.Device {
 func (d *gLDriver) Quit() {
 	if curWindow != nil {
 		if f := fyne.CurrentApp().Lifecycle().(*intapp.Lifecycle).OnExitedForeground(); f != nil {
-			curWindow.QueueEvent(f)
+			curWindow.QueueEvent(fyne.SimpleEventFunc(f))
 		}
 		curWindow = nil
 		if d.trayStop != nil {

internal/driver/glfw/menu_darwin.go

@@ -246,7 +246,7 @@ func registerCallback(w *window, item *fyne.MenuItem, nextItemID int) int {
 		callbacks = append(callbacks, &menuCallbacks{
 			action: func() {
 				if item.Action != nil {
-					w.QueueEvent(item.Action)
+					w.QueueEvent(fyne.SimpleEventFunc(item.Action))
 				}
 			},
 			enabled: func() bool {