Struct DesktopEntry

pub struct DesktopEntry {
    pub appid: String,
    pub groups: Groups,
    pub path: PathBuf,
    pub ubuntu_gettext_domain: Option<String>,
}

Fields

appid: String

groups: Groups

path: PathBuf

ubuntu_gettext_domain: Option<String>

Implementations

impl DesktopEntry

pub fn from_str<L>( path: impl Into<PathBuf>, input: &str, locales_filter: Option<&[L]>, ) -> Result<DesktopEntry, DecodeError>

where L: AsRef<str>,

Examples found in repository

examples/bench.rs (line 27)

fn bench(it: u32) {
    let mut total_time = Duration::ZERO;

    for _ in 0..it {
        let locale = get_languages_from_env();
        let paths = Iter::new(default_paths());

        let now = Instant::now();

        for path in paths {
            if let Ok(bytes) = fs::read_to_string(&path) {
                if let Ok(_entry) = DesktopEntry::from_str(&path, &bytes, Some(&locale)) {}
            }
        }

        total_time += now.elapsed();
    }

    println!("time to parse all .desktop files: {:.2?}", total_time / it);
}

pub fn from_path<L>( path: impl Into<PathBuf>, locales_filter: Option<&[L]>, ) -> Result<DesktopEntry, DecodeError>

where L: AsRef<str>,

Return an owned DesktopEntry

Examples found in repository

examples/specific_file.rs (line 15)

fn main() {
    let path = Path::new("tests_entries/org.mozilla.firefox.desktop");
    let locales = &["fr_FR", "en", "it"];

    // if let Ok(bytes) = fs::read_to_string(path) {
    //     if let Ok(entry) = DesktopEntry::decode_from_str(path, &bytes, locales) {
    //         println!("{}\n---\n{}", path.display(), entry);
    //     }
    // }

    if let Ok(entry) = DesktopEntry::from_path(path.to_path_buf(), Some(locales)) {
        println!("{}\n---\n{}", path.display(), entry);
    }
}

impl DesktopEntry

pub fn parse_exec(&self) -> Result<Vec<String>, ExecError>

pub fn parse_exec_with_uris<L>( &self, uris: &[&str], locales: &[L], ) -> Result<Vec<String>, ExecError>

where L: AsRef<str>,

Macros like %f (cf .desktop spec) will be subtitued using the uris parameter.

pub fn parse_exec_action( &self, action_name: &str, ) -> Result<Vec<String>, ExecError>

pub fn parse_exec_action_with_uris<L>( &self, action_name: &str, uris: &[&str], locales: &[L], ) -> Result<Vec<String>, ExecError>

where L: AsRef<str>,

impl DesktopEntry

pub fn from_appid(appid: String) -> DesktopEntry

Construct a new DesktopEntry from an appid. The name field will be set to that appid.

pub fn matches_wm_class(&self, id: Ascii<&str>) -> bool

Entries with a matching StartupWMClass should be preferred over those that do not.

pub fn matches_id(&self, id: Ascii<&str>) -> bool

Match entry by desktop entry file name

pub fn matches_name(&self, name: Ascii<&str>) -> bool

impl DesktopEntry

pub fn id(&self) -> &str

pub fn desktop_entry(&self, key: &str) -> Option<&str>

A desktop entry field if any field under the [Desktop Entry] section.

pub fn desktop_entry_localized<'a, L: AsRef<str>>( &'a self, key: &str, locales: &[L], ) -> Option<Cow<'a, str>>

pub fn add_desktop_entry(&mut self, key: String, value: String)

Insert a new field to this DesktopEntry, in the [Desktop Entry] section, removing the previous value and locales in any.

pub fn name<L: AsRef<str>>(&self, locales: &[L]) -> Option<Cow<'_, str>>

pub fn generic_name<L: AsRef<str>>(&self, locales: &[L]) -> Option<Cow<'_, str>>

pub fn full_name<L: AsRef<str>>(&self, locales: &[L]) -> Option<Cow<'_, str>>

Get the full name of an application, and fall back to the name if that fails.

pub fn icon(&self) -> Option<&str>

Examples found in repository

examples/find_appid.rs (line 13)

fn main() {
    let locales = fde::get_languages_from_env();
    let desktop_entries = fde::desktop_entries(&locales);

    for arg in std::env::args().skip(1) {
        let arg = fde::unicase::Ascii::new(arg.as_str());

        let desktop_entry =
            fde::find_app_by_id(&desktop_entries, arg).expect("could not find appid");

        let icon_source = fde::IconSource::from_unknown(desktop_entry.icon().unwrap_or_default());

        println!("{arg}: {desktop_entry:#?} with icon {icon_source:?}");
    }
}

pub fn comment<L: AsRef<str>>(&self, locales: &[L]) -> Option<Cow<'_, str>>

This is an human readable description of the desktop file.

pub fn exec(&self) -> Option<&str>

pub fn categories(&self) -> Option<Vec<&str>>

Return categories

pub fn keywords<L: AsRef<str>>( &self, locales: &[L], ) -> Option<Vec<Cow<'_, str>>>

Return keywords

pub fn mime_type(&self) -> Option<Vec<&str>>

Return mime types

pub fn no_display(&self) -> bool

pub fn only_show_in(&self) -> Option<Vec<&str>>

pub fn not_show_in(&self) -> Option<Vec<&str>>

pub fn flatpak(&self) -> Option<&str>

pub fn prefers_non_default_gpu(&self) -> bool

pub fn startup_notify(&self) -> bool

pub fn startup_wm_class(&self) -> Option<&str>

pub fn terminal(&self) -> bool

pub fn type_(&self) -> Option<&str>

pub fn actions(&self) -> Option<Vec<&str>>

pub fn action_entry(&self, action: &str, key: &str) -> Option<&str>

An action is defined as [Desktop Action actions-name] where action-name is defined in the Actions field of [Desktop Entry]. Example: to get the Name field of this new-window action

[Desktop Action new-window]
Name=Open a New Window

you will need to call

entry.action_entry("new-window", "Name")

pub fn action_entry_localized<L: AsRef<str>>( &self, action: &str, key: &str, locales: &[L], ) -> Option<Cow<'_, str>>

pub fn action_name<L: AsRef<str>>( &self, action: &str, locales: &[L], ) -> Option<Cow<'_, str>>

pub fn action_exec(&self, action: &str) -> Option<&str>

pub fn localized_entry_splitted<'a, L: AsRef<str>>( &'a self, group: Option<&'a Group>, key: &str, locales: &[L], ) -> Option<Vec<Cow<'a, str>>>

Trait Implementations

impl Clone for DesktopEntry

fn clone(&self) -> DesktopEntry

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DesktopEntry

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

Formats the value using the given formatter.

impl Display for DesktopEntry

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

Formats the value using the given formatter.

impl Hash for DesktopEntry

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 Ord for DesktopEntry

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for DesktopEntry

fn eq(&self, other: &Self) -> 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 PartialOrd for DesktopEntry

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for DesktopEntry