WIP

examples/launcher/ipc.rs

@@ -0,0 +1,76 @@
+use pop_launcher::{Request, Response};
+use std::process;
+use std::io::{self, BufRead, Write};
+
+pub struct LauncherIpc {
+    child: process::Child,
+    stdin: process::ChildStdin,
+    stdout: io::BufReader<process::ChildStdout>,
+    exited: bool,
+}
+
+impl LauncherIpc {
+    pub fn new() -> io::Result<Self> {
+        let mut child = process::Command::new("pop-launcher")
+            .stdin(process::Stdio::piped())
+            .stdout(process::Stdio::piped())
+            .spawn()?;
+
+        let stdin = child.stdin.take().ok_or(
+            io::Error::new(io::ErrorKind::Other, "failed to find child stdin")
+        )?;
+
+        let stdout = io::BufReader::new(child.stdout.take().ok_or(
+                io::Error::new(io::ErrorKind::Other, "failed to find child stdout")
+        )?);
+
+        Ok(Self {
+            child,
+            stdin,
+            stdout,
+            exited: false,
+        })
+    }
+
+    fn send_request(&mut self, request: Request) -> io::Result<()> {
+        let mut request_json = serde_json::to_string(&request).map_err(|err| {
+            io::Error::new(io::ErrorKind::InvalidInput, err)
+        })?;
+        request_json.push('\n');
+        self.stdin.write_all(request_json.as_bytes())
+    }
+
+    fn recv_response(&mut self) -> io::Result<Response> {
+        let mut response_json = String::new();
+        self.stdout.read_line(&mut response_json)?;
+        serde_json::from_str(&response_json).map_err(|err| {
+            io::Error::new(io::ErrorKind::InvalidData, err)
+        })
+    }
+
+    pub fn request(&mut self, request: Request) -> io::Result<Response> {
+        self.send_request(request)?;
+        self.recv_response()
+    }
+
+    //TODO: better exit implementation
+    pub fn exit(&mut self) -> io::Result<Option<process::ExitStatus>> {
+        if ! self.exited {
+            self.send_request(Request::Exit)?;
+            let status = self.child.wait()?;
+            self.exited = true;
+            Ok(Some(status))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl Drop for LauncherIpc {
+    fn drop(&mut self) {
+        match self.exit() {
+            Ok(_) => (),
+            Err(err) => eprintln!("LauncherIpc::drop failed: {}", err),
+        }
+    }
+}

examples/launcher/main.rs

@@ -0,0 +1,83 @@
+use gdk4 as gdk;
+use gtk4 as gtk;
+
+use gdk::prelude::*;
+use gtk::prelude::*;
+use libcosmic::x;
+use std::{
+    cell::RefCell,
+    rc::Rc,
+};
+
+use self::ipc::LauncherIpc;
+mod ipc;
+
+fn main() {
+    let launcher = Rc::new(RefCell::new(
+        LauncherIpc::new().expect("failed to connect to launcher service")
+    ));
+
+    let app = gtk::Application::builder()
+        .application_id("com.system76.Launcher")
+        .build();
+
+    app.connect_activate(move |app| {
+        let display = gdk::Display::default().unwrap();
+        let monitors = display.monitors().unwrap();
+
+        for i in 0..monitors.n_items() {
+            let monitor: gdk::Monitor = monitors.item(i).unwrap().downcast().unwrap();
+            let rect = monitor.geometry();
+            //TODO: get monitor with mouse cursor
+            if i == 0 {
+                let window = gtk::ApplicationWindow::builder()
+                    .application(app)
+                    .default_width(480)
+                    .default_height(440)
+                    .title("Launcher")
+                    .build();
+
+                let vbox = gtk::Box::new(gtk::Orientation::Vertical, 4);
+                window.set_child(Some(&vbox));
+
+                let search = gtk::Entry::new();
+                vbox.append(&search);
+
+                {
+                    let launcher = launcher.clone();
+                    search.connect_changed(move |search| {
+                        let response = launcher.borrow_mut().request(
+                            pop_launcher::Request::Search(search.text().to_string())
+                        ).expect("failed to access launcher service");
+
+                        println!("{:?}", response);
+                    });
+                }
+
+                window.show();
+
+                if let Some((display, surface)) = x::get_window_x11(&window) {
+                    unsafe {
+                        x::change_property(
+                            &display,
+                            &surface,
+                            "_NET_WM_WINDOW_TYPE",
+                            x::PropMode::Replace,
+                            &[x::Atom::new(&display, "_NET_WM_WINDOW_TYPE_DIALOG").unwrap()],
+                        );
+                        x::set_position(
+                            &display,
+                            &surface,
+                            rect.x + (rect.width - 480) / 2,
+                            rect.y + (rect.height - 440) / 2
+                        );
+                    }
+                } else {
+                    println!("Failed to get X11 window");
+                }
+            }
+        }
+    });
+
+    app.run();
+}