Filesystem abstraction

examples/custom_filesystem.rs

@@ -0,0 +1,173 @@
+use egui_file_dialog::{Disk, Disks, FileDialog, FileDialogConfig, FileSystem};
+use std::{
+    path::{Component, Path, PathBuf},
+    sync::Arc,
+};
+
+use eframe::egui;
+
+struct MyApp {
+    file_dialog: FileDialog,
+    picked_file: Option<PathBuf>,
+}
+
+impl MyApp {
+    pub fn new(_cc: &eframe::CreationContext) -> Self {
+        let root = vec![
+            ("im_a_file.txt".to_string(), Node::File),
+            (
+                "folder_a".to_string(),
+                Node::Directory(vec![
+                    ("hello.txt".to_string(), Node::File),
+                    ("we are files.md".to_string(), Node::File),
+                    (
+                        "nesting".to_string(),
+                        Node::Directory(vec![(
+                            "Nesting for beginners.pdf".to_string(),
+                            Node::File,
+                        )]),
+                    ),
+                ]),
+            ),
+            (
+                "folder_b".to_string(),
+                Node::Directory(vec![(
+                    "Yeah this is also a directory.tar".to_string(),
+                    Node::File,
+                )]),
+            ),
+        ];
+
+        Self {
+            file_dialog: FileDialog::new().with_file_system(
+                Arc::new(MyFileSystem(root)),
+            ),
+            picked_file: None,
+        }
+    }
+}
+
+impl eframe::App for MyApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            if ui.button("Picked file").clicked() {
+                self.file_dialog.pick_file();
+            }
+
+            ui.label(format!("Picked file: {:?}", self.picked_file));
+
+            if let Some(path) = self.file_dialog.update(ctx).picked() {
+                self.picked_file = Some(path.to_path_buf());
+            }
+        });
+    }
+}
+
+fn main() -> eframe::Result<()> {
+    eframe::run_native(
+        "File dialog example",
+        eframe::NativeOptions::default(),
+        Box::new(|ctx| Ok(Box::new(MyApp::new(ctx)))),
+    )
+}
+
+type Directory = Vec<(String, Node)>;
+
+#[derive(Clone, PartialEq)]
+enum Node {
+    Directory(Directory),
+    File,
+}
+
+struct MyFileSystem(Directory);
+
+impl MyFileSystem {
+    fn browse(&self, path: &Path) -> std::io::Result<&Directory> {
+        let mut dir = &self.0;
+        for component in path.components() {
+            let Component::Normal(part) = component else {
+                continue;
+            };
+            let part = part.to_str().unwrap();
+
+            let subdir = dir
+                .iter()
+                .find_map(|(name, node)| match node {
+                    Node::File => None,
+                    Node::Directory(subdir) => (name == part).then(|| subdir),
+                })
+                .ok_or_else(|| {
+                    std::io::Error::new(
+                        std::io::ErrorKind::NotFound,
+                        "Directory not found".to_string(),
+                    )
+                })?;
+
+            dir = subdir;
+        }
+
+        Ok(dir)
+    }
+}
+
+impl FileSystem for MyFileSystem {
+    fn read_dir(&self, path: &Path) -> std::io::Result<Vec<PathBuf>> {
+        let dir = self.browse(path)?;
+        Ok(dir.iter().map(|(name, _)| path.join(name)).collect())
+    }
+
+    fn is_dir(&self, path: &Path) -> bool {
+        self.browse(path).is_ok()
+    }
+
+    fn is_file(&self, path: &Path) -> bool {
+        let Some(parent) = path.parent() else {
+            return false;
+        };
+        let Ok(dir) = self.browse(parent) else {
+            return false;
+        };
+        dir.iter().any(|(name, node)| {
+            node == &Node::File && Some(name.as_str()) == path.file_name().and_then(|s| s.to_str())
+        })
+    }
+
+    fn metadata(&self, path: &Path) -> std::io::Result<egui_file_dialog::Metadata> {
+        Ok(Default::default())
+    }
+
+    fn get_disks(&self, canonicalize_paths: bool) -> egui_file_dialog::Disks {
+        Disks::new(vec![Disk::new(
+            Some("I'm a fake disk"),
+            &PathBuf::from("/disk"),
+            false,
+            true,
+        )])
+    }
+
+    fn user_dirs(&self, canonicalize_paths: bool) -> Option<egui_file_dialog::UserDirectories> {
+        None
+    }
+
+    fn create_dir(&self, path: &Path) -> std::io::Result<()> {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Unsupported,
+            "Unsupported".to_string(),
+        ))
+    }
+
+    fn current_dir(&self) -> std::io::Result<PathBuf> {
+        Ok("folder_a".into())
+    }
+
+    fn is_path_hidden(&self, path: &Path) -> bool {
+        false
+    }
+
+    fn load_text_file_preview(&self, path: &Path, max_chars: usize) -> std::io::Result<String> {
+        Err(std::io::Error::new(
+            std::io::ErrorKind::Unsupported,
+            "Unsupported".to_string(),
+        ))
+    }
+}

examples/pick_file.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
+use egui_file_dialog::FileDialog;
 
 use eframe::egui;
-use egui_file_dialog::FileDialog;
 
 struct MyApp {
     file_dialog: FileDialog,

src/config/mod.rs

@@ -8,6 +8,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use crate::data::DirectoryEntry;
+use crate::{FileSystem, NativeFileSystem};
 
 /// Contains data of the `FileDialog` that should be stored persistently.
 #[derive(Debug, Clone)]
@@ -65,6 +66,8 @@ impl Default for FileDialogStorage {
 pub struct FileDialogConfig {
     // ------------------------------------------------------------------------
     // Core:
+    /// File system browsed by the file dialog; may be native or virtual.
+    pub file_system: Arc<dyn FileSystem + Send + Sync>,
     /// Persistent data of the file dialog.
     pub storage: FileDialogStorage,
     /// The labels that the dialog uses.
@@ -206,22 +209,33 @@ pub struct FileDialogConfig {
 }
 
 impl Default for FileDialogConfig {
-    /// Creates a new configuration with default values
     fn default() -> Self {
+        Self::default_from_filesystem(Arc::new(NativeFileSystem))
+    }
+}
+
+impl FileDialogConfig {
+    /// Creates a new configuration with default values
+    pub fn default_from_filesystem(file_system: Arc<dyn FileSystem + Send + Sync>) -> Self {
         Self {
             storage: FileDialogStorage::default(),
             labels: FileDialogLabels::default(),
             keybindings: FileDialogKeyBindings::default(),
 
             as_modal: true,
             modal_overlay_color: egui::Color32::from_rgba_premultiplied(0, 0, 0, 120),
-            initial_directory: std::env::current_dir().unwrap_or_default(),
+            initial_directory: file_system.current_dir().unwrap_or_default(),
             default_file_name: String::new(),
             allow_file_overwrite: true,
             allow_path_edit_to_save_file_without_extension: false,
             directory_separator: String::from(">"),
             canonicalize_paths: true,
+
+            #[cfg(target_arch = "wasm32")]
+            load_via_thread: false,
+            #[cfg(not(target_arch = "wasm32"))]
             load_via_thread: true,
+
             truncate_filenames: true,
 
             err_icon: String::from("⚠"),
@@ -269,6 +283,8 @@ impl Default for FileDialogConfig {
             show_places: true,
             show_devices: true,
             show_removable_devices: true,
+
+            file_system,
         }
     }
 }

src/create_directory_dialog.rs

@@ -1,7 +1,7 @@
-use std::fs;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
-use crate::{FileDialogConfig, FileDialogLabels};
+use crate::{FileDialogConfig, FileDialogLabels, FileSystem};
 
 pub struct CreateDirectoryResponse {
     /// Contains the path to the directory that was created.
@@ -47,11 +47,13 @@ pub struct CreateDirectoryDialog {
     scroll_to_error: bool,
     /// If the text input should request focus in the next frame
     request_focus: bool,
+
+    file_system: Arc<dyn FileSystem + Send + Sync>,
 }
 
 impl CreateDirectoryDialog {
     /// Creates a new dialog with default values
-    pub const fn new() -> Self {
+    pub fn from_filesystem(file_system: Arc<dyn FileSystem + Send + Sync>) -> Self {
         Self {
             open: false,
             init: false,
@@ -61,6 +63,7 @@ impl CreateDirectoryDialog {
             error: None,
             scroll_to_error: false,
             request_focus: true,
+            file_system,
         }
     }
 
@@ -177,7 +180,7 @@ impl CreateDirectoryDialog {
         if let Some(mut dir) = self.directory.clone() {
             dir.push(self.input.as_str());
 
-            match fs::create_dir(&dir) {
+            match self.file_system.create_dir(&dir) {
                 Ok(()) => {
                     self.close();
                     return CreateDirectoryResponse::new(dir.as_path());