Can JavaFX filechooser “remember” the last directory it opened?

My view controller has a filechooser instance for opening and saving files

Every time I call showopendialog () or showsavedialog () from this instance, I want the generated dialog to be in the same directory as when I left it the last time I called one of them

Instead, every time I call one of these methods, the dialog box opens in the user's home directory

How to keep the "current directory" of the dialog box unchanged in different calls?

Examples of current behavior:

import java.io.File;
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.V@R_212_2419@;
import javafx.stage.FileChooser;
import javafx.stage.Stage;

/**
 * Demonstrates the use of an open dialog.
 * 
 * @author N99x
 */
public class FileChooserTest extends Application {

    private final FileChooser open = new FileChooser();
    private File lastOpened = null;

    @Override
    public void start(Stage primaryStage) {
        Label lbl = new Label("File Opened: <null>");
        lbl.setPadding(new Insets(8));
        Button btn = new Button();
        btn.setPadding(new Insets(8));
        btn.setText("Open");
        btn.setOnAction((ActionEvent event) -> {
            open.setInitialDirectory(lastOpened);
            File selected = open.showOpenDialog(primaryStage);
            if (selected == null) {
                lbl.setText("File Opened: <null>");
                // lastOpened = ??;
            } else {
                lbl.setText("File Opened: " + selected.getAbsolutePath());
                lastOpened = selected.getParentFile();
            }
        });

        V@R_212_2419@ root = new V@R_212_2419@(lbl,btn);
        root.setPadding(new Insets(8));
        root.setAlignment(Pos.TOP_CENTER);
        Scene scene = new Scene(root,300,300);

        primaryStage.setTitle("FileChooser Testing!");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        launch(args);
    }

}

I try to solve some problems by storing open values, but it doesn't work if I close or cancel the dialog box

Solution

You can modify the singleton pattern method for this

Therefore, you can only use a filechooser and monitor / control the initial directory there, but you will not directly expose the instance to modifications outside the class

For example:

public class RetentionFileChooser {
    private static FileChooser instance = null;
    private static SimpleObjectProperty<File> lastKNownDirectoryProperty = new SimpleObjectProperty<>();

    private RetentionFileChooser(){ }

    private static FileChooser getInstance(){
        if(instance == null) {
            instance = new FileChooser();
            instance.initialDirectoryproperty().bindBidirectional(lastKNownDirectoryProperty);
            //Set the FileExtensions you want to allow
            instance.getExtensionFilters().setAll(new ExtensionFilter("png files (*.png)","*.png"));
        }
        return instance;
    }

    public static File showOpenDialog(){
        return showOpenDialog(null);
    }

    public static File showOpenDialog(Window ownerWindow){
        File chosenFile = getInstance().showOpenDialog(ownerWindow);
        if(chosenFile != null){
            //Set the property to the directory of the chosenFile so the fileChooser will open here next
            lastKNownDirectoryProperty.setValue(chosenFile.getParentFile());
        }
        return chosenFile;
    }

    public static File showSaveDialog(){
        return showSaveDialog(null);
    }

    public static File showSaveDialog(Window ownerWindow){
        File chosenFile = getInstance().showSaveDialog(ownerWindow);
        if(chosenFile != null){
            //Set the property to the directory of the chosenFile so the fileChooser will open here next
            lastKNownDirectoryProperty.setValue(chosenFile.getParentFile());
        }
        return chosenFile;
    }
}

This will set the initial directory of filechooser to the directory of the last file reopened / saved by the user

Usage example:

File chosenFile = RetentionFileChooser.showOpenDialog();

But there is one limitation:

//Set the FileExtensions you want to allow 
instance.getExtensionFilters().setAll(new ExtensionFilter("png files (*.png)","*.png"));

Because no extensionfilter is provided, filechooser becomes less user-friendly and requires users to manually attach file types, but filters are provided when creating instances and cannot be updated, limiting them to the same filter

One way to improve this is to expose the optional filter provided by varargs in retention file chooser, so that you can choose when to modify the filter when the dialog box is displayed

For example, build on the previous:

public class RetentionFileChooser {
    public enum FilterMode {
        //Setup supported filters
        PNG_FILES("png files (*.png)","*.png"),TXT_FILES("txt files (*.txt)","*.txt");

        private ExtensionFilter extensionFilter;

        FilterMode(String extensionDisplayName,String... extensions){
            extensionFilter = new ExtensionFilter(extensionDisplayName,extensions);
        }

        public ExtensionFilter getExtensionFilter(){
            return extensionFilter;
        }
    }

    private static FileChooser instance = null;
    private static SimpleObjectProperty<File> lastKNownDirectoryProperty = new SimpleObjectProperty<>();

    private RetentionFileChooser(){ }

    private static FileChooser getInstance(FilterMode... filterModes){
        if(instance == null) {
            instance = new FileChooser();
            instance.initialDirectoryproperty().bindBidirectional(lastKNownDirectoryProperty);
        }
        //Set the filters to those provided
        //You Could add check's to ensure that a default filter is included,adding it if need be
        instance.getExtensionFilters().setAll(
                Arrays.stream(filterModes)
                        .map(FilterMode::getExtensionFilter)
                        .collect(Collectors.toList()));
        return instance;
    }

    public static File showOpenDialog(FilterMode... filterModes){
        return showOpenDialog(null,filterModes);
    }

    public static File showOpenDialog(Window ownerWindow,FilterMode...filterModes){
        File chosenFile = getInstance(filterModes).showOpenDialog(ownerWindow);
        if(chosenFile != null){
            lastKNownDirectoryProperty.setValue(chosenFile.getParentFile());
        }
        return chosenFile;
    }

    public static File showSaveDialog(FilterMode... filterModes){
        return showSaveDialog(null,filterModes);
    }

    public static File showSaveDialog(Window ownerWindow,FilterMode... filterModes){
        File chosenFile = getInstance(filterModes).showSaveDialog(ownerWindow);
        if(chosenFile != null){
            lastKNownDirectoryProperty.setValue(chosenFile.getParentFile());
        }
        return chosenFile;
    }
}

Usage example:

//Note the prevIoUs example still holds
File chosenFile = RetentionFileChooser.showOpenDialog();
File file = RetentionFileChooser.showSaveDialog(FilterMode.PNG_FILES);

Unfortunately, filechooser does not disclose information about the directory being checked until it closes / terminates If you decompile and trace a class, it will eventually trigger a native call Therefore, even if filechooser does not eventually allow it to be subclassed, it is unlikely to get this information

The only benefit provided by the above method is that it does not change the initial directory if this happens

If you are interested, the local keywords in this question have some very good answers and links:

> What is the native keyword in Java for?