Struct File 

pub struct File { /* private fields */ }

A file or directory in the file explorer.

Implementations

impl File

pub fn name(&self) -> &str

Returns the name of the file or directory.

Examples

Suppose you have this tree file, with passport.png selected inside file_explorer:

/
├── .git
└── Documents
    ├── passport.png  <- selected
    └── resume.pdf

You can get the name of the selected file like this:

use fpicker::FileExplorer;

let file_explorer = FileExplorer::new().unwrap();

/* user select `password.png` */

let file = file_explorer.current();
assert_eq!(file.name(), "passport.png");

pub const fn path(&self) -> &PathBuf

Returns the path of the file or directory.

Examples

Suppose you have this tree file, with passport.png selected inside file_explorer:

/
├── .git
└── Documents
    ├── passport.png  <- selected
    └── resume.pdf

You can get the path of the selected file like this:

use fpicker::FileExplorer;

let file_explorer = FileExplorer::new().unwrap();

/* user select `password.png` */

let file = file_explorer.current();
assert_eq!(file.path().display().to_string(), "/Documents/passport.png");

Examples found in repository

examples/basic.rs (line 37)

fn main() -> io::Result<()> {
    enable_raw_mode()?;
    stdout().execute(EnterAlternateScreen)?;

    let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;

    // Create a new file explorer with the default theme and title.
    let theme = Theme::default().add_default_title();
    let mut file_explorer = FileExplorer::with_theme(theme)?;

    let mut selected_paths = vec![];

    loop {
        // Render the file explorer widget.
        terminal.draw(|f| {
            f.render_widget(&file_explorer.widget(), f.area());
        })?;

        // Read the next event from the terminal.
        let event = read()?;
        if let Event::Key(key) = event {
            if key.code == KeyCode::Char('q') {
                // Collect selected file paths.
                selected_paths = file_explorer
                    .selected_files()
                    .iter()
                    .map(|file| file.path().display().to_string())
                    .collect();
                break;
            }
        }
        // Handle the event in the file explorer.
        file_explorer.handle(&event)?;
    }

    // Restore the terminal to normal mode.
    disable_raw_mode()?;
    stdout().execute(LeaveAlternateScreen)?;

    // Print the selected file paths to stdout.
    for path in selected_paths {
        println!("{}", path);
    }

    // Return exit code 0 explicitly.
    process::exit(0);
}

examples/file_preview.rs (line 36)

fn main() -> io::Result<()> {
    enable_raw_mode()?;
    stdout().execute(EnterAlternateScreen)?;

    let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
    let layout = Layout::vertical([
        Constraint::Ratio(4, 5), // Main file explorer and content area
        Constraint::Ratio(1, 5), // Bottom window for selected file paths
    ]);

    // Inner layout for the top section
    let top_layout = Layout::horizontal([Constraint::Ratio(1, 3), Constraint::Ratio(2, 3)]);

    // Create a new file explorer with the default theme and title.
    let theme = get_theme();
    let mut file_explorer = FileExplorer::with_theme(theme)?;

    loop {
        // Get the content of the current selected file (if it's indeed a file).
        let file_content = get_file_content(file_explorer.current().path())?;
        let selected_files: String = file_explorer
            .selected_files()
            .iter()
            .map(|file| file.path().display().to_string())
            .collect::<Vec<String>>()
            .join("\n");

        // Render the file explorer widget, file content, and selected file paths.
        terminal.draw(|f| {
            let chunks = layout.split(f.area());
            let top_chunks = top_layout.split(chunks[0]);

            // Top section
            f.render_widget(&file_explorer.widget(), top_chunks[0]);
            f.render_widget(
                Paragraph::new(file_content).block(
                    Block::default()
                        .borders(Borders::ALL)
                        .border_type(BorderType::Double),
                ),
                top_chunks[1],
            );

            // Bottom section
            f.render_widget(
                Paragraph::new(selected_files.clone()).block(
                    Block::default()
                        .borders(Borders::ALL)
                        .title("q:Quit, c: copy selected file contents to clipboard, p: copy paths to clipboard"),
                ),
                chunks[1],
            );
        })?;

        // Read the next event from the terminal.
        let event = read()?;
        if let Event::Key(key) = event {
            match key.code {
                KeyCode::Char('q') => break, // Quit the application
                KeyCode::Char('c') => {
                    // Copy selected file paths to clipboard
                    if let Ok(mut clipboard) = ClipboardContext::new() {
                        if let Err(err) = clipboard.set_contents(get_selected_files_content(
                            &file_explorer.selected_files(),
                        )) {
                            eprintln!("Failed to copy to clipboard: {}", err);
                        }
                    } else {
                        eprintln!("Clipboard not available.");
                    }
                }
                KeyCode::Char('p') => {
                    // Copy selected file paths to clipboard
                    if let Ok(mut clipboard) = ClipboardContext::new() {
                        if let Err(err) = clipboard.set_contents(selected_files.clone()) {
                            eprintln!("Failed to copy to clipboard: {}", err);
                        }
                    } else {
                        eprintln!("Clipboard not available.");
                    }
                }
                _ => {}
            }
        }
        // Handle the event in the file explorer.
        file_explorer.handle(&event)?;
    }

    disable_raw_mode()?;
    stdout().execute(LeaveAlternateScreen)?;
    // Print the selected file paths to stdout.
    for file in file_explorer.selected_files() {
        println!("{}", file.path().display());
    }
    Ok(())
}

fn get_file_content(path: &Path) -> io::Result<String> {
    let mut content = String::new();

    // If the path is a file, read its content.
    if path.is_file() {
        content = read_to_string(path)?;
    }

    Ok(content)
}
fn get_selected_files_content(selected_files: &Vec<File>) -> String {
    selected_files
        .iter()
        .map(|file| {
            let path = file.path().display().to_string();
            let content = get_file_content(file.path())
                .unwrap_or_else(|_| "Unable to read file.".to_string());
            format!("File: {}\nContent:\n{}\n", path, content)
        })
        .collect::<Vec<String>>()
        .join("\n")
}

pub const fn is_dir(&self) -> bool

Returns true is the file is a directory.

Examples

Suppose you have this tree file, with passport.png selected inside file_explorer:

/
├── .git
└── Documents
    ├── passport.png  <- selected
    └── resume.pdf

You can know if the selected file is a directory like this:

use fpicker::FileExplorer;

let file_explorer = FileExplorer::new().unwrap();

/* user select `password.png` */

let file = file_explorer.current();
assert_eq!(file.is_dir(), false);

/* User select `Documents` */

let file = file_explorer.current();
assert_eq!(file.is_dir(), false);

pub fn set_selected(&mut self, selected: bool)

pub const fn is_selected(&self) -> bool

Trait Implementations

impl Clone for File

fn clone(&self) -> File

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for File

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for File

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for File

fn eq(&self, other: &File) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for File

impl StructuralPartialEq for File