Struct FileFilter 

pub struct FileFilter<'a> {
    pub name: &'a str,
    pub extensions: &'a [&'a str],
}

A named set of file extensions for a file dialog, such as “Images” over png and jpg. Extensions are bare names, without dots or wildcards; each backend decorates them into its own filter syntax. How much of the grouping survives is backend-dependent: macOS’s chooser takes one flat type list, so there the groups merge into a single extension set.

Fields

name: &'a str

extensions: &'a [&'a str]

Implementations

impl<'a> FileFilter<'a>

pub fn builder(name: &'a str) -> FileFilterBuilder<'a>

Start building a filter from its display name, as an alternative to the struct literal. Both constructions produce the same value:

use any_dialog::FileFilter;

let filter = FileFilter::builder("Images").extensions(&["png", "jpg"]);
assert_eq!(
    filter,
    FileFilter { name: "Images", extensions: &["png", "jpg"] }
);

Examples found in repository

examples/open_with_filters.rs (line 32)

fn main() -> Result<(), any_dialog::Error> {
    let dialogs = Dialogs::new();
    if !dialogs.available() {
        eprintln!("no dialog backend on this system (on Linux, install kdialog or zenity)");
        return Ok(());
    }

    // Extensions are bare, without a dot or a glob: "rs", not
    // "*.rs". Each filter is one named group in the picker. The
    // two constructions shown are interchangeable: a struct
    // literal, and the builder.
    let filters = [
        FileFilter {
            name: "Rust source",
            extensions: &["rs", "toml"],
        },
        FileFilter::builder("Text and markdown").extensions(&["txt", "md"]),
    ];

    match dialogs.prompt_open_file("Pick one file", None, &filters)? {
        Some(path) => println!("one file: {}", path.display()),
        None => {
            println!("cancelled at the single picker");
            return Ok(());
        }
    }

    match dialogs.prompt_open_files("Pick any number of files", None, &filters)? {
        Some(paths) => {
            println!("{} file(s) picked:", paths.len());
            for path in &paths {
                println!("  {}", path.display());
            }
        }
        None => println!("cancelled at the multiple picker"),
    }
    Ok(())
}

Trait Implementations

impl<'a> Clone for FileFilter<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for FileFilter<'a>

impl<'a> Debug for FileFilter<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for FileFilter<'a>

impl<'a> PartialEq for FileFilter<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for FileFilter<'a>