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 match_query<Q, L>( &self, query: Q, locales: &[L], additional_haystack_values: &[&str], ) -> f64

where Q: AsRef<str>, L: AsRef<str>,

The returned value is between 0.0 and 1.0 (higher value means more similar). You can use the additional_haystack_values parameter to add relevant string that are not part of the desktop entry.

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.

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 icon(&self) -> Option<&str>

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>>( &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 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 Eq for DesktopEntry