File dialog locations

dialog/file.go

@@ -35,13 +35,14 @@ type fileDialog struct {
 
 // FileDialog is a dialog containing a file picker for use in opening or saving files.
 type FileDialog struct {
-	save             bool
-	callback         interface{}
-	onClosedCallback func(bool)
-	filter           storage.FileFilter
-	parent           fyne.Window
-	dialog           *fileDialog
-	dismissText      string
+	save              bool
+	callback          interface{}
+	onClosedCallback  func(bool)
+	filter            storage.FileFilter
+	parent            fyne.Window
+	dialog            *fileDialog
+	dismissText       string
+	StartingDirectory string
 }
 
 // Declare conformity to Dialog interface
@@ -262,15 +263,52 @@ func (f *fileDialog) setSelected(file *fileDialogItem) {
 	}
 }
 
+// effectiveStartingDir calculates the directory at which the file dialog should
+// open, based on the values of StartingDirectory, CWD, home, and any error
+// conditions which occur.
+//
+// Order of precedence is:
+//
+// * file.StartingDirectory if non-empty and os.Stat()-able
+// * os.Getwd()
+// * os.UserHomeDir()
+// * "/" (should be filesystem root on all supported platforms)
+func (file *FileDialog) effectiveStartingDir() string {
+	if file.StartingDirectory != "" {
+		// the starting directory is set explicitly
+		if _, err := os.Stat(file.StartingDirectory); err != nil {
+			fyne.LogError("Error with StartingDirectory", err)
+		} else {
+			return file.StartingDirectory
+		}
+	}
+
+	// Either no custom starting directory was set, or there
+	// was an error with it...
+	//
+	// Try to use CWD
+	var err error = nil
+	dir, err := os.Getwd()
+	if err != nil {
+		// if that doesn't work, fail-over to ~/
+		fyne.LogError("Could not load CWD", err)
+		dir, err = os.UserHomeDir()
+		if err != nil {
+
+			// if that dosen't work, fail over to /
+			fyne.LogError("Could not load user home dir", err)
+			dir = "/"
+		}
+	}
+
+	return dir
+}
+
 func showFile(file *FileDialog) *fileDialog {
 	d := &fileDialog{file: file}
 	ui := d.makeUI()
-	dir, err := os.UserHomeDir()
-	if err != nil {
-		fyne.LogError("Could not load user home dir", err)
-		dir, _ = os.Getwd() //fallback
-	}
-	d.setDirectory(dir)
+
+	d.setDirectory(file.effectiveStartingDir())
 
 	size := ui.MinSize().Add(fyne.NewSize(fileIconCellWidth*2+theme.Padding()*4,
 		(fileIconSize+fileTextSize)+theme.Padding()*4))
@@ -363,20 +401,34 @@ func NewFileSave(callback func(fyne.URIWriteCloser, error), parent fyne.Window)
 // ShowFileOpen creates and shows a file dialog allowing the user to choose a file to open.
 // The dialog will appear over the window specified.
 func ShowFileOpen(callback func(fyne.URIReadCloser, error), parent fyne.Window) {
+	ShowFileOpenAt(callback, parent, "")
+}
+
+// ShowFileOpenAt works similarly to ShowFileOpen(), but with a custom starting
+// directory.
+func ShowFileOpenAt(callback func(fyne.URIReadCloser, error), parent fyne.Window, startdir string) {
 	dialog := NewFileOpen(callback, parent)
 	if fileOpenOSOverride(dialog) {
 		return
 	}
+	dialog.StartingDirectory = startdir
 	dialog.Show()
 }
 
 // ShowFileSave creates and shows a file dialog allowing the user to choose a file to save to (new or overwrite).
 // If the user chooses an existing file they will be asked if they are sure.
 // The dialog will appear over the window specified.
 func ShowFileSave(callback func(fyne.URIWriteCloser, error), parent fyne.Window) {
+	ShowFileSaveAt(callback, parent, "")
+}
+
+// ShowFileSaveAt works simialrly to ShowFileSave(), but with a custom starting
+// directory.
+func ShowFileSaveAt(callback func(fyne.URIWriteCloser, error), parent fyne.Window, startdir string) {
 	dialog := NewFileSave(callback, parent)
 	if fileSaveOSOverride(dialog) {
 		return
 	}
+	dialog.StartingDirectory = startdir
 	dialog.Show()
 }

dialog/file_test.go

@@ -15,6 +15,93 @@ import (
 	"fyne.io/fyne/widget"
 )
 
+// comparePaths compares if two file paths point to the same thing, and calls
+// t.Fatalf() if there is an error in performing the comparison.
+//
+// Returns true of both paths point to the same thing.
+//
+// You should use this if you need to compare file paths, since it explicitly
+// normalizes the paths to a stable canonical form. It also nicely
+// abstracts out the requisite error handling.
+//
+// You should only call this function on paths that you expect to be valid.
+func comparePaths(t *testing.T, p1, p2 string) bool {
+	a1, err := filepath.Abs(p1)
+	if err != nil {
+		t.Fatalf("Failed to normalize path '%s'", p1)
+	}
+
+	a2, err := filepath.Abs(p2)
+	if err != nil {
+		t.Fatalf("Failed to normalize path '%s'", p2)
+	}
+
+	return a1 == a2
+}
+
+func TestEffectiveStartingDir(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Skipf("os.Getwd() failed, cannot run this test on this system (error getting ./), error was '%s'", err)
+	}
+
+	parent := filepath.Dir(wd)
+	_, err = os.Stat(parent)
+	if err != nil {
+		t.Skipf("os.Getwd() failed, cannot run this test on this system (error stat()-ing ../) error was '%s'", err)
+	}
+
+	dialog := &FileDialog{}
+
+	// test that we get ./ when running with the default struct values
+	res := dialog.effectiveStartingDir()
+	expect := wd
+	if err != nil {
+		t.Skipf("os.Getwd() failed, cannot run this test on this system, error was '%s'", err)
+	}
+	if !comparePaths(t, res, expect) {
+		t.Errorf("Expected effectiveStartingDir() to be '%s', but it was '%s'",
+			expect, res)
+	}
+
+	// this should always be equivalent to the preceding test
+	dialog.StartingDirectory = ""
+	res = dialog.effectiveStartingDir()
+	expect = wd
+	if err != nil {
+		t.Skipf("os.Getwd() failed, cannot run this test on this system, error was '%s'", err)
+	}
+	if !comparePaths(t, res, expect) {
+		t.Errorf("Expected effectiveStartingDir() to be '%s', but it was '%s'",
+			expect, res)
+	}
+
+	// check using StartingDirectory with some other directory
+	dialog.StartingDirectory = parent
+	res = dialog.effectiveStartingDir()
+	expect = parent
+	if err != nil {
+		t.Skipf("os.Getwd() failed, cannot run this test on this system, error was '%s'", err)
+	}
+	if res != expect {
+		t.Errorf("Expected effectiveStartingDir() to be '%s', but it was '%s'",
+			expect, res)
+	}
+
+	// make sure we fail over if the specified directory does not exist
+	dialog.StartingDirectory = "/some/file/that/does/not/exist"
+	res = dialog.effectiveStartingDir()
+	expect = wd
+	if err != nil {
+		t.Skipf("os.Getwd() failed, cannot run this test on this system, error was '%s'", err)
+	}
+	if res != expect {
+		t.Errorf("Expected effectiveStartingDir() to be '%s', but it was '%s'",
+			expect, res)
+	}
+
+}
+
 func TestShowFileOpen(t *testing.T) {
 	var chosen fyne.URIReadCloser
 	var openErr error