Struct FileExplorer 

pub struct FileExplorer { /* private fields */ }

A file explorer that allows browsing and selecting files and directories.

The FileExplorer struct represents a file explorer widget that can be used to navigate through the file system. You can obtain a renderable widget from it with the widget method. It provides methods for handling user input from crossterm, termion and termwiz (depending on what feature is enabled).

Examples

Creating a new FileExplorer widget:

use fpicker::FileExplorer;

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

Handling user input:

use fpicker::FileExplorer;

let mut file_explorer = FileExplorer::new().unwrap();
let event = get_event(); // Get the event from the terminal (with crossterm, termion or termwiz)
file_explorer.handle(event).unwrap();

Accessing information about the current file selected and or the current working directory:

use fpicker::FileExplorer;

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

let current_file = file_explorer.current();
let current_working_directory = file_explorer.cwd();
println!("Current Directory: {}", current_working_directory.display());
println!("Name: {}", current_file.name());

Implementations

impl FileExplorer

pub fn new() -> Result<FileExplorer>

Creates a new instance of FileExplorer.

This method initializes a FileExplorer with the current working directory.

Examples

Suppose you have this tree file and your current working directory is /Documents:

/
├── .git
└── Documents  <- current working directory
    ├── passport.png
    └── resume.pdf

You can create a new FileExplorer like this:

use fpicker::FileExplorer;

let file_explorer = FileExplorer::new().unwrap();
assert_eq!(file_explorer.cwd().display().to_string(), "/Documents");

pub fn with_theme(theme: Theme) -> Result<FileExplorer>

Creates a new instance of FileExplorer with a specific theme.

This method initializes a FileExplorer with the current working directory.

Examples

use fpicker::{FileExplorer, Theme};

let file_explorer = FileExplorer::with_theme(Theme::default().add_default_title()).unwrap();

Examples found in repository

examples/basic.rs (line 19)

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/light_and_dark_theme.rs (line 23)

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 light theme.
    let mut dark_theme = false;
    let mut file_explorer = FileExplorer::with_theme(get_light_theme())?;

    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 the user presses `Ctrl + s`, switch the theme.
        // If the user presses `Ctrl + q`, quit the application.
        if let Event::Key(key) = event {
            if key.modifiers == crossterm::event::KeyModifiers::CONTROL {
                match key.code {
                    KeyCode::Char('s') => {
                        dark_theme = !dark_theme;
                        if dark_theme {
                            file_explorer.set_theme(get_dark_theme());
                        } else {
                            file_explorer.set_theme(get_light_theme());
                        }
                    }
                    KeyCode::Char('q') => {
                        break;
                    }
                    _ => {}
                }
            }
        }
        // Handle the event in the file explorer.
        file_explorer.handle(&event)?;
    }

    disable_raw_mode()?;
    stdout().execute(LeaveAlternateScreen)?;
    Ok(())
}

examples/file_preview.rs (line 32)

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(())
}

pub const fn widget(&self) -> impl WidgetRef + '_

Build a ratatui widget to render the file explorer. The widget can then be rendered with Frame::render_widget.

Examples

use ratatui::{Terminal, backend::CrosstermBackend};
use fpicker::FileExplorer;

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

let mut terminal = Terminal::new(CrosstermBackend::new(std::io::stdout())).unwrap();

loop {
    terminal.draw(|f| {
        let widget = file_explorer.widget(); // Get the widget to render the file explorer
        f.render_widget(&widget, f.area());
    }).unwrap();

    // ...
}

Examples found in repository

examples/basic.rs (line 26)

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/light_and_dark_theme.rs (line 28)

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 light theme.
    let mut dark_theme = false;
    let mut file_explorer = FileExplorer::with_theme(get_light_theme())?;

    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 the user presses `Ctrl + s`, switch the theme.
        // If the user presses `Ctrl + q`, quit the application.
        if let Event::Key(key) = event {
            if key.modifiers == crossterm::event::KeyModifiers::CONTROL {
                match key.code {
                    KeyCode::Char('s') => {
                        dark_theme = !dark_theme;
                        if dark_theme {
                            file_explorer.set_theme(get_dark_theme());
                        } else {
                            file_explorer.set_theme(get_light_theme());
                        }
                    }
                    KeyCode::Char('q') => {
                        break;
                    }
                    _ => {}
                }
            }
        }
        // Handle the event in the file explorer.
        file_explorer.handle(&event)?;
    }

    disable_raw_mode()?;
    stdout().execute(LeaveAlternateScreen)?;
    Ok(())
}

examples/file_preview.rs (line 50)

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(())
}

pub fn handle<I: Into<Input>>(&mut self, input: I) -> Result<()>

Handles input from user and updates the state of the file explorer. The different inputs are interpreted as follows:

• Up: Move the selection up.
• Down: Move the selection down.
• Left: Move to the parent directory.
• Right: Move to the selected directory.
• None: Do nothing.

Input implement From<Event> for Event of crossterm, termion and termwiz (InputEvent in this case).

Examples

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

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

You can handle input like this:

use fpicker::{FileExplorer, Input};

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

/* user select `password.png` */

file_explorer.handle(Input::Down).unwrap();
assert_eq!(file_explorer.current().name(), "resume.pdf");

file_explorer.handle(Input::Up).unwrap();
file_explorer.handle(Input::Up).unwrap();
assert_eq!(file_explorer.current().name(), "Documents");

file_explorer.handle(Input::Left).unwrap();
assert_eq!(file_explorer.cwd().display().to_string(), "/");

file_explorer.handle(Input::Right).unwrap();
assert_eq!(file_explorer.cwd().display().to_string(), "/Documents");

Examples found in repository

examples/basic.rs (line 43)

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/light_and_dark_theme.rs (line 54)

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 light theme.
    let mut dark_theme = false;
    let mut file_explorer = FileExplorer::with_theme(get_light_theme())?;

    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 the user presses `Ctrl + s`, switch the theme.
        // If the user presses `Ctrl + q`, quit the application.
        if let Event::Key(key) = event {
            if key.modifiers == crossterm::event::KeyModifiers::CONTROL {
                match key.code {
                    KeyCode::Char('s') => {
                        dark_theme = !dark_theme;
                        if dark_theme {
                            file_explorer.set_theme(get_dark_theme());
                        } else {
                            file_explorer.set_theme(get_light_theme());
                        }
                    }
                    KeyCode::Char('q') => {
                        break;
                    }
                    _ => {}
                }
            }
        }
        // Handle the event in the file explorer.
        file_explorer.handle(&event)?;
    }

    disable_raw_mode()?;
    stdout().execute(LeaveAlternateScreen)?;
    Ok(())
}

examples/file_preview.rs (line 102)

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(())
}

pub fn set_cwd<P: Into<PathBuf>>(&mut self, cwd: P) -> Result<()>

Sets the current working directory of the file explorer.

Examples

use fpicker::FileExplorer;

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

file_explorer.set_cwd("/Documents").unwrap();
assert_eq!(file_explorer.cwd().display().to_string(), "/Documents");

pub fn selected_files(&self) -> &Vec<File>

Examples found in repository

examples/basic.rs (line 35)

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 38)

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(())
}

pub fn set_theme(&mut self, theme: Theme)

Sets the theme of the file explorer.

Examples

use fpicker::{FileExplorer, Theme};

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

file_explorer.set_theme(Theme::default().add_default_title());

Examples found in repository

examples/light_and_dark_theme.rs (line 41)

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 light theme.
    let mut dark_theme = false;
    let mut file_explorer = FileExplorer::with_theme(get_light_theme())?;

    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 the user presses `Ctrl + s`, switch the theme.
        // If the user presses `Ctrl + q`, quit the application.
        if let Event::Key(key) = event {
            if key.modifiers == crossterm::event::KeyModifiers::CONTROL {
                match key.code {
                    KeyCode::Char('s') => {
                        dark_theme = !dark_theme;
                        if dark_theme {
                            file_explorer.set_theme(get_dark_theme());
                        } else {
                            file_explorer.set_theme(get_light_theme());
                        }
                    }
                    KeyCode::Char('q') => {
                        break;
                    }
                    _ => {}
                }
            }
        }
        // Handle the event in the file explorer.
        file_explorer.handle(&event)?;
    }

    disable_raw_mode()?;
    stdout().execute(LeaveAlternateScreen)?;
    Ok(())
}

pub fn set_selected_idx(&mut self, selected: usize)

Sets the selected file or directory index inside the current Vec of files and directories if the file explorer.

The file explorer add the parent directory at the beginning of the Vec of files, so setting the selected index to 0 will select the parent directory (if the current working directory not the root directory).

Panics

Panics if selected is greater or equal to the number of files (plus the parent directory if it exist) in the current working directory.

Examples

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

/
├── .git
└── Documents
    ├── passport.png  <- selected (index 2)
    └── resume.pdf

You can set the selected index like this:

use fpicker::FileExplorer;

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

/* user select `password.png` */

// Because the file explorer add the parent directory at the beginning
// of the [`Vec`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html) of files, index 0 is indeed the parent directory.
file_explorer.set_selected_idx(0);
assert_eq!(file_explorer.current().path().display().to_string(), "/");

file_explorer.set_selected_idx(1);
assert_eq!(file_explorer.current().path().display().to_string(), "/Documents");

#[test]
#[should_panic]
fn index_out_of_bound() {
   let mut file_explorer = FileExplorer::new().unwrap();
   file_explorer.set_selected_idx(4);
}

pub fn current(&self) -> &File

Returns the current file or directory selected.

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 current 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");

Examples found in repository

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(())
}

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

Returns the current working directory of the file explorer.

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 current working directory like this:

use fpicker::FileExplorer;

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

/* user select `password.png` */

let cwd = file_explorer.cwd();
assert_eq!(cwd.display().to_string(), "/Documents");

pub const fn files(&self) -> &Vec<File>

Returns the a Vec of files and directories in the current working directory of the file explorer, plus the parent directory if it exist.

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 Vec of files and directories like this:

use fpicker::FileExplorer;

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

/* user select `password.png` */

let files = file_explorer.files();
assert_eq!(files.len(), 4); // 3 files/directory and the parent directory

pub const fn selected_idx(&self) -> usize

Returns the index of the selected file or directory in the current Vec of files and directories in the current working directory of the file explorer.

Examples

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

/
├── .git
└── Documents
    ├── passport.png  <- selected (index 2)
    └── resume.pdf

You can get the selected index like this:

use fpicker::FileExplorer;

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

/* user select `password.png` */

let selected_idx = file_explorer.selected_idx();

// Because the file explorer add the parent directory at the beginning
// of the [`Vec`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html) of files, the selected index will be 2.
assert_eq!(selected_idx, 2);

pub const fn theme(&self) -> &Theme

Returns the theme of the file explorer.

Examples

use fpicker::{FileExplorer, Theme};

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

assert_eq!(file_explorer.theme(), &Theme::default());

Trait Implementations

impl Clone for FileExplorer

fn clone(&self) -> FileExplorer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FileExplorer

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

Formats the value using the given formatter.

impl Hash for FileExplorer

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 FileExplorer

fn eq(&self, other: &FileExplorer) -> 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 FileExplorer

impl StructuralPartialEq for FileExplorer