Merge branch 'develop' into settings-callback

Author: dweymouth

app/preferences.go

@@ -51,7 +51,7 @@ func (p *preferences) resetSavedRecently() {
 		time.Sleep(time.Millisecond * 100) // writes are not always atomic. 10ms worked, 100 is safer.
 
 		// For test reasons we need to use current app not what we were initialised with as they can differ
-		fyne.Do(func() {
+		fyne.DoAndWait(func() {
 			p.prefLock.Lock()
 			p.savedRecently = false
 			changedDuringSaving := p.changedDuringSaving

data/binding/queue.go

@@ -11,5 +11,5 @@ func queueItem(f func()) {
 		return
 	}
 
-	fyne.Do(f)
+	fyne.DoAndWait(f)
 }

dialog/file.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"sort"
 	"strings"
 
 	"fyne.io/fyne/v2"
@@ -422,6 +423,18 @@ func (f *fileDialog) refreshDir(dir fyne.ListableURI) {
 		}
 	}
 
+	toSort := icons
+	if parent != nil {
+		toSort = icons[1:]
+	}
+	sort.Slice(toSort, func(i, j int) bool {
+		if parent != nil { // avoiding the parent in [0]
+			i++
+			j++
+		}
+
+		return strings.ToLower(icons[i].Name()) < strings.ToLower(icons[j].Name())
+	})
 	f.data = icons
 
 	f.files.Refresh()

dialog/file_test.go

@@ -276,7 +276,7 @@ func TestHiddenFiles(t *testing.T) {
 		t.Error("Failed to open testdata dir", err)
 	}
 
-	// git does not preserve windows hidden flag so we have to set it.
+	// git does not preserve windows hidden flag, so we have to set it.
 	// just an empty function for non windows builds
 	if err := hideFile(filepath.Join(testDataPath, ".hidden")); err != nil {
 		t.Error("Failed to hide .hidden", err)
@@ -326,7 +326,7 @@ func TestHiddenFiles(t *testing.T) {
 			target = item
 		}
 	}
-	assert.NotNil(t, target, "Failed,.hidden not found in testdata")
+	assert.NotNil(t, target, "Failed, .hidden not found in testdata")
 }
 
 func TestShowFileSave(t *testing.T) {
@@ -471,6 +471,47 @@ func TestFileFilters(t *testing.T) {
 	assert.Equal(t, 11, count)
 }
 
+func TestFileSort(t *testing.T) {
+	testDataPath, _ := filepath.Abs("testdata")
+	testData := storage.NewFileURI(testDataPath)
+	dir, err := storage.ListerForURI(testData)
+	if err != nil {
+		t.Error("Failed to open testdata dir", err)
+	}
+
+	win := test.NewTempWindow(t, widget.NewLabel("Content"))
+	d := NewFileOpen(func(file fyne.URIReadCloser, err error) {
+	}, win)
+	d.SetLocation(dir)
+	d.Show()
+
+	popup := win.Canvas().Overlays().Top().(*widget.PopUp)
+	defer win.Canvas().Overlays().Remove(popup)
+	assert.NotNil(t, popup)
+
+	ui := popup.Content.(*fyne.Container)
+
+	files := ui.Objects[0].(*container.Split).Trailing.(*fyne.Container).Objects[1].(*container.Scroll).Content.(*fyne.Container).Objects[0].(*widget.GridWrap)
+	objects := test.TempWidgetRenderer(t, files).Objects()[0].(*container.Scroll).Content.(*fyne.Container).Objects
+	assert.NotEmpty(t, objects)
+
+	binPos := -1
+	capitalPos := -1
+	for i, icon := range objects {
+		item := test.TempWidgetRenderer(t, icon.(fyne.Widget)).Objects()[1].(*fileDialogItem)
+		switch item.name {
+		case "bin":
+			binPos = i
+		case "Capitalised":
+			capitalPos = i
+		}
+	}
+
+	assert.NotEqual(t, -1, binPos, "bin file not found")
+	assert.NotEqual(t, -1, capitalPos, "Capitalised.txt file not found")
+	assert.Less(t, binPos, capitalPos)
+}
+
 func TestView(t *testing.T) {
 	win := test.NewTempWindow(t, widget.NewLabel("Content"))
 

dialog/file_xdg_flatpak.go

@@ -83,14 +83,14 @@ func fileOpenOSOverride(d *FileDialog) bool {
 	if folder {
 		go func() {
 			folder, err := openFolder(windowHandle, options)
-			fyne.Do(func() {
+			fyne.DoAndWait(func() {
 				folderCallback(folder, err)
 			})
 		}()
 	} else {
 		go func() {
 			file, err := openFile(windowHandle, options)
-			fyne.Do(func() {
+			fyne.DoAndWait(func() {
 				fileCallback(file, err)
 			})
 		}()
@@ -113,7 +113,7 @@ func fileSaveOSOverride(d *FileDialog) bool {
 
 	go func() {
 		file, err := saveFile(windowHandle, options)
-		fyne.Do(func() {
+		fyne.DoAndWait(func() {
 			callback(file, err)
 		})
 	}()

dialog/testdata/Capitalised.txt

@@ -0,0 +1 @@
+adsfasdfasdfasdfdsfasdfasdfafdafdasf

driver.go

@@ -47,11 +47,11 @@ type Driver interface {
 	// Since: 2.5
 	SetDisableScreenBlanking(bool)
 
-	// DoFromGoroutine provides a way to queue a function that is running on a goroutine back to
-	// the central thread for Fyne updates.
+	// DoFromGoroutine provides a way to queue a function `fn` that is running on a goroutine back to
+	// the central thread for Fyne updates, waiting for it to return if `wait` is true.
 	// The driver provides the implementation normally accessed through [fyne.Do].
 	// This is required when background tasks want to execute code safely in the graphical context.
 	//
 	// Since: 2.6
-	DoFromGoroutine(func())
+	DoFromGoroutine(fn func(), wait bool)
 }

internal/app/lifecycle.go

@@ -106,9 +106,9 @@ func (l *Lifecycle) QueueEvent(fn func()) {
 
 // RunEventQueue runs the event queue. This should called inside a go routine.
 // This function blocks.
-func (l *Lifecycle) RunEventQueue(run func(func())) {
+func (l *Lifecycle) RunEventQueue(run func(func(), bool)) {
 	for fn := range l.eventQueue.Out() {
-		run(fn)
+		run(fn, true)
 	}
 }
 

internal/app/lifecycle_test.go

@@ -17,7 +17,7 @@ func TestLifecycle(t *testing.T) {
 
 	var entered, exited, start, stop, hookedStop, called bool
 	life.InitEventQueue()
-	go life.RunEventQueue(func(fn func()) {
+	go life.RunEventQueue(func(fn func(), _ bool) {
 		fn()
 	})
 	life.QueueEvent(func() { called = true })

internal/async/goroutine.go

@@ -30,12 +30,12 @@ func IsMainGoroutine() bool {
 //
 // This will be removed later and should never be public
 func EnsureNotMain(fn func()) {
-	if build.MigratedToFyneDo() || !build.HasHints || !IsMainGoroutine() {
+	if build.MigratedToFyneDo() || !IsMainGoroutine() {
 		fn()
 		return
 	}
 
-	log.Println("*** Error in Fyne call thread, fyne.Do called from main goroutine ***")
+	log.Println("*** Error in Fyne call thread, fyne.Do[AndWait] called from main goroutine ***")
 
 	logStackTop(2)
 	go fn()
@@ -47,15 +47,15 @@ func EnsureNotMain(fn func()) {
 //
 // This will be removed later and should never be public
 func EnsureMain(fn func()) {
-	if build.MigratedToFyneDo() || !build.HasHints || IsMainGoroutine() {
+	if build.MigratedToFyneDo() || IsMainGoroutine() {
 		fn()
 		return
 	}
 
-	log.Println("*** Error in Fyne call thread, this should have been called in fyne.Do ***")
+	log.Println("*** Error in Fyne call thread, this should have been called in fyne.Do[AndWait] ***")
 
 	logStackTop(1)
-	fyne.Do(fn)
+	fyne.DoAndWait(fn)
 }
 
 func logStackTop(skip int) {

internal/driver/glfw/driver.go

@@ -56,9 +56,9 @@ func toOSIcon(icon []byte) ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-func (d *gLDriver) DoFromGoroutine(f func()) {
+func (d *gLDriver) DoFromGoroutine(f func(), wait bool) {
 	async.EnsureNotMain(func() {
-		runOnMain(f)
+		runOnMainWithWait(f, wait)
 	})
 }
 

internal/driver/glfw/loop.go

@@ -8,6 +8,7 @@ import (
 
 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/internal/app"
+	"fyne.io/fyne/v2/internal/async"
 	"fyne.io/fyne/v2/internal/cache"
 	"fyne.io/fyne/v2/internal/driver/common"
 	"fyne.io/fyne/v2/internal/painter"
@@ -20,7 +21,7 @@ type funcData struct {
 }
 
 // channel for queuing functions on the main thread
-var funcQueue = make(chan funcData)
+var funcQueue = async.NewUnboundedChan[funcData]()
 var running atomic.Bool
 var initOnce = &sync.Once{}
 
@@ -31,19 +32,27 @@ func init() {
 
 // force a function f to run on the main thread
 func runOnMain(f func()) {
+	runOnMainWithWait(f, true)
+}
+
+// force a function f to run on the main thread and specify if we should wait for it to return
+func runOnMainWithWait(f func(), wait bool) {
 	// If we are on main just execute - otherwise add it to the main queue and wait.
 	// The "running" variable is normally false when we are on the main thread.
 	if !running.Load() {
 		f()
 		return
 	}
 
-	done := common.DonePool.Get()
-	defer common.DonePool.Put(done)
-
-	funcQueue <- funcData{f: f, done: done}
+	if wait {
+		done := common.DonePool.Get()
+		defer common.DonePool.Put(done)
 
-	<-done
+		funcQueue.In() <- funcData{f: f, done: done}
+		<-done
+	} else {
+		funcQueue.In() <- funcData{f: f}
+	}
 }
 
 // Preallocate to avoid allocations on every drawSingleFrame.
@@ -110,9 +119,11 @@ func (d *gLDriver) runGL() {
 				l.QueueEvent(f)
 			}
 			return
-		case f := <-funcQueue:
+		case f := <-funcQueue.Out():
 			f.f()
-			f.done <- struct{}{}
+			if f.done != nil {
+				f.done <- struct{}{}
+			}
 		case <-eventTick.C:
 			d.pollEvents()
 			for i := 0; i < len(d.windows); i++ {

internal/driver/glfw/window.go

@@ -867,11 +867,7 @@ func (w *window) Context() any {
 
 func (w *window) runOnMainWhenCreated(fn func()) {
 	if w.view() != nil {
-		if async.IsMainGoroutine() {
-			fn()
-			return
-		}
-		fyne.Do(fn)
+		async.EnsureMain(fn)
 		return
 	}
 

internal/driver/glfw/window_desktop.go

@@ -114,23 +114,25 @@ type window struct {
 }
 
 func (w *window) SetFullScreen(full bool) {
-	w.fullScreen = full
-	if !w.visible {
-		return
-	}
+	w.runOnMainWhenCreated(func() {
+		w.fullScreen = full
+		if !w.visible {
+			return
+		}
 
-	monitor := w.getMonitorForWindow()
-	mode := monitor.GetVideoMode()
+		monitor := w.getMonitorForWindow()
+		mode := monitor.GetVideoMode()
 
-	if full {
-		w.viewport.SetMonitor(monitor, 0, 0, mode.Width, mode.Height, mode.RefreshRate)
-	} else {
-		if w.width == 0 && w.height == 0 { // if we were fullscreen on creation...
-			s := w.canvas.Size().Max(w.canvas.MinSize())
-			w.width, w.height = w.screenSize(s)
+		if full {
+			w.viewport.SetMonitor(monitor, 0, 0, mode.Width, mode.Height, mode.RefreshRate)
+		} else {
+			if w.width == 0 && w.height == 0 { // if we were fullscreen on creation...
+				s := w.canvas.Size().Max(w.canvas.MinSize())
+				w.width, w.height = w.screenSize(s)
+			}
+			w.viewport.SetMonitor(nil, w.xpos, w.ypos, w.width, w.height, 0)
 		}
-		w.viewport.SetMonitor(nil, w.xpos, w.ypos, w.width, w.height, 0)
-	}
+	})
 }
 
 func (w *window) CenterOnScreen() {

internal/driver/mobile/canvas.go

@@ -407,7 +407,7 @@ func (c *canvas) waitForDoubleTap(co fyne.CanvasObject, ev *fyne.PointEvent, tap
 		c.touchCancelFunc = nil
 		c.touchLastTapped = nil
 		c.touchCancelLock.Unlock()
-	})
+	}, true)
 }
 
 func (c *canvas) windowHeadIsDisplacing() bool {

internal/driver/mobile/canvas_test.go

@@ -142,7 +142,7 @@ func Test_canvas_Focusable(t *testing.T) {
 		c.tapUp(pos, 0, func(wid fyne.Tappable, ev *fyne.PointEvent) {
 			wid.Tapped(ev)
 		}, nil, nil, nil)
-	})
+	}, true)
 
 	waitAndCheck(tapDoubleDelay/time.Millisecond+150, func() {
 		assert.Equal(t, 1, content.focusedTimes)
@@ -154,7 +154,7 @@ func Test_canvas_Focusable(t *testing.T) {
 		c.tapUp(pos, 1, func(wid fyne.Tappable, ev *fyne.PointEvent) {
 			wid.Tapped(ev)
 		}, nil, nil, nil)
-	})
+	}, true)
 	waitAndCheck(tapDoubleDelay/time.Millisecond+150, func() {
 		assert.Equal(t, 1, content.focusedTimes)
 		assert.Equal(t, 0, content.unfocusedTimes)
@@ -177,7 +177,7 @@ func Test_canvas_Focusable(t *testing.T) {
 		c.tapDown(fyne.NewPos(10, 10), 2)
 		assert.Equal(t, 1, content.focusedTimes)
 		assert.Equal(t, 1, content.unfocusedTimes)
-	})
+	}, true)
 }
 
 func Test_canvas_InteractiveArea(t *testing.T) {
@@ -534,7 +534,7 @@ func waitAndCheck(msWait time.Duration, fn func()) {
 			fn()
 
 			waitForCheck <- struct{}{}
-		})
+		}, true)
 	}()
 	<-waitForCheck
 }