feat: add destkop entries actions

Author: oknozor

Cargo.lock

@@ -33,6 +33,7 @@ dirs = "4.0.0"
 futures = "0.3.21"
 bytes = "1.1.0"
 recently-used-xbel = "1.0.0"
+shell-words = "1.1.0"
 
 [dependencies.reqwest]
 version = "0.11.10"

plugins/Cargo.toml

@@ -70,6 +70,8 @@ impl App {
         let options = vec![ContextOption {
             id: 0,
             name: "Qalculate! Manual".into(),
+            description: "Browse Qalculate! user manual".to_string(),
+            exec: None,
         }];
 
         crate::send(&mut self.out, PluginResponse::Context { id: 0, options }).await;

plugins/src/calc/mod.rs

@@ -9,22 +9,86 @@ use futures::StreamExt;
 use pop_launcher::*;
 use std::borrow::Cow;
 use std::hash::{Hash, Hasher};
-use std::path::PathBuf;
+use std::process::Command;
 use tokio::io::AsyncWrite;
+use tracing::error;
+use crate::desktop_entries::graphics::is_switchable;
 
 #[derive(Debug, Eq)]
 struct Item {
     appid: String,
     description: String,
+    context: Vec<ContextAction>,
+    prefer_non_default_gpu: bool,
     exec: String,
     icon: Option<String>,
     keywords: Option<Vec<String>>,
     name: String,
-    path: PathBuf,
-    prefers_non_default_gpu: bool,
     src: PathSource,
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum ContextAction {
+    Action(Action),
+    GpuPreference(GpuPreference)
+}
+
+impl Item {
+    fn run(&self, action_idx: Option<Indice>) {
+        match action_idx {
+            // No action provided just run the desktop entry with the default gpu
+            None => run_exec_command(&self.exec, self.prefer_non_default_gpu),
+            // Run the provided action
+            Some(idx) => {
+                match self.context.get(idx as usize) {
+                    None => error!("Could not find context action at index {idx}"),
+                    Some(action) => match action {
+                        ContextAction::Action(action) => run_exec_command(&action.exec, self.prefer_non_default_gpu),
+                        ContextAction::GpuPreference(pref) => match pref {
+                            GpuPreference::Default => run_exec_command(&self.exec, false),
+                            GpuPreference::NonDefault => run_exec_command(&self.exec, true),
+                        },
+                    },
+                }
+            }
+        }
+    }
+}
+
+fn run_exec_command(exec: &str, discrete_graphics: bool) {
+    let cmd = shell_words::split(exec);
+    let cmd: Vec<String> = cmd.unwrap();
+
+    let args = cmd
+        .iter()
+        // Filter desktop entries field code. Is this needed ?
+        // see: https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html
+        .filter(|arg| !arg.starts_with('%'))
+        .collect::<Vec<&String>>();
+
+    let mut cmd = Command::new(&args[0]);
+    let cmd = cmd.args(&args[1..]);
+
+    // FIXME: Will this work with Nvidia Gpu ?
+    // We probably want to look there : https://gitlab.freedesktop.org/hadess/switcheroo-control/-/blob/master/src/switcheroo-control.c
+    let cmd = if discrete_graphics {
+        cmd.env("DRI_PRIME", "1")
+    } else {
+        cmd
+    };
+
+    if let Err(err) = cmd.spawn() {
+        error!("Failed to run desktop entry: {err}");
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Action {
+    pub name: String,
+    pub description: String,
+    pub exec: String,
+}
+
 impl Hash for Item {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.appid.hash(state);
@@ -150,6 +214,44 @@ impl<W: AsyncWrite + Unpin> App<W> {
                                 continue;
                             }
 
+                            let mut actions = vec![];
+
+                            if let Some(entries) = entry.actions() {
+                                for action in entries.split(';') {
+                                    let action =
+                                        entry.action_name(action, locale).and_then(|name| {
+                                            entry.action_exec(action).map(|exec| Action {
+                                                name: action.to_string(),
+                                                description: name.to_string(),
+                                                exec: exec.to_string(),
+                                            })
+                                        });
+
+                                    if let Some(action) = action {
+                                        actions.push(action);
+                                    }
+                                }
+                            }
+
+                            let actions = actions
+                                .into_iter()
+                                .map(|action| ContextAction::Action(action));
+
+                            let entry_prefers_non_default_gpu = entry.prefers_non_default_gpu();
+                            let prefer_non_default_gpu = entry_prefers_non_default_gpu && is_switchable();
+                            let prefer_default_gpu = !entry_prefers_non_default_gpu && is_switchable();
+
+                            let context: Vec<ContextAction> = if prefer_non_default_gpu  {
+                                vec![ContextAction::GpuPreference(GpuPreference::Default)]
+                            } else if prefer_default_gpu {
+                                vec![ContextAction::GpuPreference(GpuPreference::NonDefault)]
+                            } else {
+                                vec![]
+                            }
+                                .into_iter()
+                                .chain(actions)
+                                .collect();
+
                             let item = Item {
                                 appid: entry.appid.to_owned(),
                                 name: name.to_string(),
@@ -163,9 +265,9 @@ impl<W: AsyncWrite + Unpin> App<W> {
                                 }),
                                 icon: entry.icon().map(|x| x.to_owned()),
                                 exec: exec.to_owned(),
-                                path: path.clone(),
-                                prefers_non_default_gpu: entry.prefers_non_default_gpu(),
                                 src,
+                                context,
+                                prefer_non_default_gpu: entry_prefers_non_default_gpu
                             };
 
                             deduplicator.insert(item);
@@ -179,57 +281,58 @@ impl<W: AsyncWrite + Unpin> App<W> {
     }
 
     async fn activate(&mut self, id: u32) {
+        send(&mut self.tx, PluginResponse::Close).await;
+
         if let Some(entry) = self.entries.get(id as usize) {
-            let response = PluginResponse::DesktopEntry {
-                path: entry.path.clone(),
-                gpu_preference: if entry.prefers_non_default_gpu {
-                    GpuPreference::NonDefault
-                } else {
-                    GpuPreference::Default
-                },
-            };
-
-            send(&mut self.tx, response).await;
+            entry.run(None);
+        } else {
+            error!("Desktop entry not found at index {id}");
         }
+
+        std::process::exit(0);
     }
 
     async fn activate_context(&mut self, id: u32, context: u32) {
-        if let Some(entry) = self.entries.get(id as usize) {
-            let response = match context {
-                0 => PluginResponse::DesktopEntry {
-                    path: entry.path.clone(),
-                    gpu_preference: if !entry.prefers_non_default_gpu {
-                        GpuPreference::NonDefault
-                    } else {
-                        GpuPreference::Default
-                    },
-                },
-                _ => return,
-            };
+        send(&mut self.tx, PluginResponse::Close).await;
 
-            send(&mut self.tx, response).await;
+        if let Some(entry) = self.entries.get(id as usize) {
+            entry.run(Some(context))
         }
     }
 
     async fn context(&mut self, id: u32) {
         if let Some(entry) = self.entries.get(id as usize) {
             let mut options = Vec::new();
 
-            if graphics::is_switchable() {
-                options.push(ContextOption {
-                    id: 0,
-                    name: (if entry.prefers_non_default_gpu {
-                        "Launch Using Integrated Graphics Card"
-                    } else {
-                        "Launch Using Discrete Graphics Card"
-                    })
-                    .to_owned(),
-                });
+            for (idx, action) in entry.context.iter().enumerate() {
+                match action {
+                    ContextAction::Action(action) => options.push(ContextOption {
+                        id: idx as u32,
+                        name: action.name.to_owned(),
+                        description: action.description.to_owned(),
+                        exec: Some(action.exec.to_string()),
+                    }),
+                    ContextAction::GpuPreference(pref) => {
+                        match pref {
+                            GpuPreference::Default => options.push(ContextOption {
+                                id: 0,
+                                name: "Integrated Graphics".to_owned(),
+                                description: "Launch Using Integrated Graphics Card".to_owned(),
+                                exec: None,
+                            }),
+                            GpuPreference::NonDefault => options.push(ContextOption {
+                                id: 0,
+                                name: "Discrete Graphics".to_owned(),
+                                description: "Launch Using Discrete Graphics Card".to_owned(),
+                                exec: None,
+                            }),
+                        }
+                    }
+                }
             }
 
             if !options.is_empty() {
                 let response = PluginResponse::Context { id, options };
-
                 send(&mut self.tx, response).await;
             }
         }

plugins/src/desktop_entries/mod.rs

@@ -166,17 +166,6 @@ impl<O: futures::Sink<Response> + Unpin> Service<O> {
                     }
                     PluginResponse::Fill(text) => self.fill(text).await,
                     PluginResponse::Finished => self.finished(plugin).await,
-                    PluginResponse::DesktopEntry {
-                        path,
-                        gpu_preference,
-                    } => {
-                        self.respond(Response::DesktopEntry {
-                            path,
-                            gpu_preference,
-                        })
-                        .await;
-                    }
-
                     // Report the plugin as finished and remove it from future polling
                     PluginResponse::Deactivate => {
                         self.finished(plugin).await;

service/src/lib.rs

@@ -48,9 +48,11 @@ pub type Indice = u32;
 pub struct ContextOption {
     pub id: Indice,
     pub name: String,
+    pub description: String,
+    pub exec: Option<String>,
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
 pub enum GpuPreference {
     Default,
     NonDefault,
@@ -80,11 +82,6 @@ pub enum PluginResponse {
     },
     /// Instruct the launcher service to deactivate this plugin.
     Deactivate,
-    // Notifies that a .desktop entry should be launched by the frontend.
-    DesktopEntry {
-        path: PathBuf,
-        gpu_preference: GpuPreference,
-    },
     /// Update the text in the launcher.
     Fill(String),
     /// Indicoates that a plugin is finished with its queries.