Use open signal for files

src/main.rs

@@ -32,10 +32,10 @@ mod popup_menu;
 mod project;
 mod tabline;
 
-use gtk::prelude::*;
 
 use std::env;
-use gio::ApplicationExt;
+use gtk::prelude::*;
+use gio::{ApplicationExt, FileExt};
 
 use ui::Ui;
 
@@ -44,33 +44,46 @@ const BIN_PATH_ARG: &'static str = "--nvim-bin-path";
 fn main() {
     env_logger::init().expect("Can't initialize env_logger");
 
+    let app_flags = gio::APPLICATION_HANDLES_OPEN;
+
     let app = if cfg!(debug_assertions) {
             gtk::Application::new(Some("org.daa.NeovimGtkDebug"),
-                                  gio::ApplicationFlags::empty())
+                                  app_flags)
         } else {
-            gtk::Application::new(Some("org.daa.NeovimGtk"), gio::ApplicationFlags::empty())
+            gtk::Application::new(Some("org.daa.NeovimGtk"), app_flags)
         }
         .expect("Failed to initialize GTK application");
 
     app.connect_activate(activate);
+    {
+        use gio::ApplicationExtManual;
+        app.connect_open(open);
+    }
 
     let args: Vec<String> = env::args().collect();
-    let mut argv: Vec<&str> = args.iter()
+    let argv: Vec<&str> = args.iter()
         .filter(|a| !a.starts_with(BIN_PATH_ARG))
         .map(String::as_str)
         .collect();
-    if open_arg().is_some() {
-        argv.pop();
-    }
     app.run(argv.len() as i32, &argv);
 }
 
+fn open(app: &gtk::Application, files: &[gio::File], _: &str) {
+    for f in files {
+        let mut ui = Ui::new();
+
+        ui.init(app,
+                nvim_bin_path(std::env::args()).as_ref(),
+                f.get_path().as_ref().map(|p| p.to_str()).unwrap_or(None));
+    }
+}
+
 fn activate(app: &gtk::Application) {
     let mut ui = Ui::new();
 
     ui.init(app,
             nvim_bin_path(std::env::args()).as_ref(),
-            open_arg().as_ref());
+            None);
 }
 
 fn nvim_bin_path<I>(args: I) -> Option<String>
@@ -82,23 +95,6 @@ fn nvim_bin_path<I>(args: I) -> Option<String>
         .unwrap_or(None)
 }
 
-fn open_arg() -> Option<String> {
-    open_arg_impl(std::env::args())
-}
-
-fn open_arg_impl<I>(args: I) -> Option<String>
-    where I: Iterator<Item = String>
-{
-    args.skip(1)
-        .last()
-        .map(|a| if !a.starts_with("-") {
-                 Some(a.to_owned())
-             } else {
-                 None
-             })
-        .unwrap_or(None)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -110,20 +106,4 @@ mod tests {
                                      .iter()
                                      .map(|s| s.to_string())));
     }
-
-    #[test]
-    fn test_open_arg() {
-        assert_eq!(Some("some_file.txt".to_string()),
-                   open_arg_impl(vec!["neovim-gtk",
-                                      "--nvim-bin-path=/test_path",
-                                      "some_file.txt"]
-                                         .iter()
-                                         .map(|s| s.to_string())));
-    }
-
-    #[test]
-    fn test_empty_open_arg() {
-        assert_eq!(None,
-                   open_arg_impl(vec!["neovim-gtk"].iter().map(|s| s.to_string())));
-    }
 }

src/ui.rs

@@ -73,7 +73,7 @@ impl Ui {
     pub fn init(&mut self,
                 app: &gtk::Application,
                 nvim_bin_path: Option<&String>,
-                open_path: Option<&String>) {
+                open_path: Option<&str>) {
         if self.initialized {
             return;
         }