focus windows using launcher IPC

Cargo.toml

@@ -10,7 +10,14 @@ gdk4-x11 = "0.3.0"
 gio = "0.14.8"
 gtk4 = "0.3.1"
 x11 = { version = "2", features = ["xlib"] }
+
 # examples/launcher
-pop-launcher = "=1.0.3"
+#pop-launcher = "1.0.3"
+pop-launcher = { git = "https://github.com/pop-os/launcher", branch = "client" }
 serde_json = "1.0.70"
-once_cell = "1.8.0"
+pop-launcher-service = { git = "https://github.com/pop-os/launcher", branch = "client" }
+postage = "0.4.1"
+futures = "0.3.18"
+glib = "0.14.8" 
+# examples/gtklauncher
+once_cell = "1.8.0"

examples/gtklauncher/README.md

@@ -1,5 +0,0 @@
-# ListView: Applications Launcher
-
-This example shows how to create a `gtk::ListView` and fill it with applications data from `gio::AppInfo` with the possibility to open an application when an item of the list is activated.
-
-![Screenshot](screenshot.png)

examples/gtklauncher/application_row/mod.rs

@@ -1,39 +0,0 @@
-use gtk4 as gtk;
-mod imp;
-
-use gtk::prelude::*;
-use gtk::subclass::prelude::*;
-use gtk::{gio, glib};
-
-glib::wrapper! {
-    pub struct ApplicationRow(ObjectSubclass<imp::ApplicationRow>)
-        @extends gtk::Widget, gtk::Box;
-}
-
-impl Default for ApplicationRow {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ApplicationRow {
-    pub fn new() -> Self {
-        glib::Object::new(&[]).expect("Failed to create ApplicationRow")
-    }
-
-    pub fn set_app_info(&self, app_info: &gio::AppInfo) {
-        let self_ = imp::ApplicationRow::from_instance(self);
-        self_.name.set_text(&app_info.name());
-        if let Some(desc) = app_info.description() {
-            self_.description.set_text(&desc);
-        }
-        if let Some(icon) = app_info.icon() {
-            self_.image.set_from_gicon(&icon);
-        }
-    }
-
-    pub fn set_shortcut(&self, indx: u32) {
-        let self_ = imp::ApplicationRow::from_instance(self);
-        self_.shortcut.set_text(&format!("Ctrl + {}", indx));
-    }
-}

examples/gtklauncher/main.rs

@@ -1,34 +0,0 @@
-mod application_row;
-mod window;
-
-use gtk::gdk::Display;
-use gtk::prelude::*;
-use gtk4 as gtk;
-
-use window::Window;
-
-fn main() {
-    let application = gtk::Application::new(
-        Some("com.github.gtk-rs.examples.apps_launcher"),
-        Default::default(),
-    );
-
-    application.connect_activate(|app| {
-        let provider = gtk::CssProvider::new();
-        provider.load_from_data(include_bytes!("style.css"));
-        gtk::StyleContext::add_provider_for_display(
-            &Display::default().expect("Error initializing gtk css provider."),
-            &provider,
-            gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
-        );
-        new_build_ui(app);
-    });
-
-    application.run();
-}
-
-fn new_build_ui(app: &gtk::Application) {
-    // Create a new custom window and show it
-    let window = Window::new(app);
-    window.show();
-}

examples/gtklauncher/style.css

@@ -1,15 +0,0 @@
-description {
-    line-height: 1.5em;
-    background-image: none;
-    background-color: red;
-}
-
-row.row1 {
-    background-image: none;
-    background-color: black;
-}
-
-shortcut {
-    background-image: none;
-    background-color: green;
-}

examples/launcher/application_object/imp.rs

@@ -1,7 +1,4 @@
-use glib::{
+use glib::{FromVariant, ParamFlags, ParamSpec, ToVariant, Value, Variant, VariantTy};
-    types::Type, FromVariant, ParamFlags, ParamSpec, ParamSpecObject, ToVariant, Value, Variant,
-    VariantTy,
-};
 use gtk4::glib;
 use gtk4::prelude::*;
 use gtk4::subclass::prelude::*;
@@ -21,7 +18,7 @@ pub struct ApplicationObject {
 // The central trait for subclassing a GObject
 #[glib::object_subclass]
 impl ObjectSubclass for ApplicationObject {
-    const NAME: &'static str = "LibCosmicLauncherApplicationObject";
+    const NAME: &'static str = "ApplicationObject";
     type Type = super::ApplicationObject;
     type ParentType = glib::Object;
 }
@@ -31,6 +28,20 @@ impl ObjectImpl for ApplicationObject {
     fn properties() -> &'static [ParamSpec] {
         static PROPERTIES: Lazy<Vec<ParamSpec>> = Lazy::new(|| {
             vec![
+                ParamSpec::new_uint(
+                    // Name
+                    "id",
+                    // Nickname
+                    "id",
+                    // Short description
+                    "ID of application in launcher search result",
+                    0,
+                    u32::MAX,
+                    // Default value
+                    0,
+                    // The property can be read and written to
+                    ParamFlags::READWRITE,
+                ),
                 ParamSpec::new_string(
                     // Name
                     "name",
@@ -102,6 +113,10 @@ impl ObjectImpl for ApplicationObject {
 
     fn set_property(&self, _obj: &Self::Type, _id: usize, value: &Value, pspec: &ParamSpec) {
         match pspec.name() {
+            "id" => {
+                let id = value.get().expect("The value needs to be of type `u32`.");
+                self.data.borrow_mut().0.id = id;
+            }
             "name" => {
                 let name = value
                     .get()
@@ -115,46 +130,44 @@ impl ObjectImpl for ApplicationObject {
                 self.data.borrow_mut().0.description = description;
             }
             "icon" => {
-                let icon = <Option<(i32, String)>>::from_variant(
+                let icon = <(i32, String)>::from_variant(
                     &value
                         .get::<Variant>()
                         .expect("The icon needs to be a Variant"),
                 )
-                .expect("The icon variant needs to be an Option<(i32, String)>");
+                .expect("The icon variant needs to be an (i32, String)");
-                if let Some(icon) = icon {
+                self.data.borrow_mut().0.icon = match icon {
-                    self.data.borrow_mut().0.icon = match icon {
+                    (i_type, name) if i_type == pop_launcher::IconSource::Name as i32 => {
-                        (i_type, name) if i_type == pop_launcher::IconSource::Name as i32 => {
+                        Some(pop_launcher::IconSource::Name(name.into()))
-                            Some(pop_launcher::IconSource::Name(name.into()))
+                    }
-                        }
+                    (i_type, name) if i_type == pop_launcher::IconSource::Mime as i32 => {
-                        (i_type, name) if i_type == pop_launcher::IconSource::Mime as i32 => {
+                        Some(pop_launcher::IconSource::Mime(name.into()))
-                            Some(pop_launcher::IconSource::Mime(name.into()))
+                    }
-                        }
+                    (i_type, name) => {
-                        _ => None,
+                        println!("Failed to set icon. {} {}", i_type, name);
-                    };
+                        None
-                } else {
+                    }
-                    self.data.borrow_mut().0.icon = None;
+                };
-                }
             }
             "categoryicon" => {
-                let icon = <Option<(i32, String)>>::from_variant(
+                let icon = <(i32, String)>::from_variant(
                     &value
                         .get::<Variant>()
                         .expect("The icon needs to be a Variant"),
                 )
                 .expect("The icon variant needs to be an Option<(i32, String)>");
-                if let Some(icon) = icon {
+                self.data.borrow_mut().0.category_icon = match icon {
-                    self.data.borrow_mut().0.icon = match icon {
+                    (i_type, name) if i_type == pop_launcher::IconSource::Name as i32 => {
-                        (i_type, name) if i_type == pop_launcher::IconSource::Name as i32 => {
+                        Some(pop_launcher::IconSource::Name(name.into()))
-                            Some(pop_launcher::IconSource::Name(name.into()))
+                    }
-                        }
+                    (i_type, name) if i_type == pop_launcher::IconSource::Mime as i32 => {
-                        (i_type, name) if i_type == pop_launcher::IconSource::Mime as i32 => {
+                        Some(pop_launcher::IconSource::Mime(name.into()))
-                            Some(pop_launcher::IconSource::Mime(name.into()))
+                    }
-                        }
+                    (i_type, name) => {
-                        _ => None,
+                        println!("Failed to set icon. {} {}", i_type, name);
-                    };
+                        None
-                } else {
+                    }
-                    self.data.borrow_mut().0.icon = None;
+                };
-                }
             }
             "window" => {
                 unimplemented!()
@@ -165,8 +178,9 @@ impl ObjectImpl for ApplicationObject {
 
     fn property(&self, _obj: &Self::Type, _id: usize, pspec: &ParamSpec) -> Value {
         match pspec.name() {
+            "id" => self.data.borrow().0.id.to_value(),
             "name" => self.data.borrow().0.name.to_value(),
-            "description" => self.data.borrow().0.name.to_value(),
+            "description" => self.data.borrow().0.description.to_value(),
             "icon" => match &self.data.borrow().0.icon {
                 Some(pop_launcher::IconSource::Name(icon_name)) => {
                     (pop_launcher::IconSource::Name as i32, icon_name.to_string())

examples/launcher/application_object/mod.rs

@@ -1,9 +1,9 @@
 mod imp;
 
 use gdk4::glib::Object;
+use glib::ObjectExt;
+use glib::ToVariant;
 use gtk4::glib;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 glib::wrapper! {
     pub struct ApplicationObject(ObjectSubclass<imp::ApplicationObject>);
@@ -11,8 +11,46 @@ glib::wrapper! {
 
 impl ApplicationObject {
     pub fn new(application_search_result: &pop_launcher::SearchResult) -> Self {
-        Object::new(&[("name", &application_search_result.name)])
+        let self_: Self = Object::new(&[
-            .expect("Failed to create `ApplicationObject`.")
+            ("id", &application_search_result.id),
+            ("name", &application_search_result.name),
+            ("description", &application_search_result.description),
+        ])
+        .expect("Failed to create `ApplicationObject`.");
+        if let Some(icon) = &application_search_result.icon {
+            if let Err(e) = self_.set_property(
+                "icon",
+                match icon {
+                    pop_launcher::IconSource::Name(name) => {
+                        (pop_launcher::IconSource::Name as i32, name.to_string()).to_variant()
+                    }
+                    pop_launcher::IconSource::Mime(name) => {
+                        (pop_launcher::IconSource::Mime as i32, name.to_string()).to_variant()
+                    }
+                },
+            ) {
+                println!("failed to set icon property");
+                dbg!(e);
+            };
+        }
+        if let Some(icon) = &application_search_result.category_icon {
+            if let Err(e) = self_.set_property(
+                "categoryicon",
+                match icon {
+                    pop_launcher::IconSource::Name(name) => {
+                        (pop_launcher::IconSource::Name as i32, name.to_string()).to_variant()
+                    }
+                    pop_launcher::IconSource::Mime(name) => {
+                        (pop_launcher::IconSource::Mime as i32, name.to_string()).to_variant()
+                    }
+                },
+            ) {
+                println!("failed to set category icon property");
+                dbg!(e);
+            };
+        }
+
+        self_
     }
 }
 

examples/launcher/application_row/application_row.ui

@@ -6,7 +6,12 @@
     <property name="margin-start">4</property>
     <property name="margin-end">4</property>
     <property name="hexpand">true</property>
-    <child>
+     <child>
+      <object class="GtkImage" id="categoryimage">
+        <property name="pixel-size">20</property>
+      </object>
+     </child>
+     <child>
       <object class="GtkImage" id="image">
         <property name="margin-top">4</property>
         <property name="margin-bottom">4</property>

examples/launcher/application_row/imp.rs

@@ -16,6 +16,8 @@ pub struct ApplicationRow {
     pub shortcut: TemplateChild<gtk::Label>,
     #[template_child]
     pub image: TemplateChild<gtk::Image>,
+    #[template_child]
+    pub categoryimage: TemplateChild<gtk::Image>,
 }
 
 #[glib::object_subclass]

examples/launcher/application_row/mod.rs

@@ -0,0 +1,79 @@
+use crate::icon_source;
+use glib::FromVariant;
+use glib::Variant;
+use gtk4 as gtk;
+mod imp;
+
+use crate::ApplicationObject;
+use gtk::glib;
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+
+glib::wrapper! {
+    pub struct ApplicationRow(ObjectSubclass<imp::ApplicationRow>)
+        @extends gtk::Widget, gtk::Box;
+}
+
+impl Default for ApplicationRow {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ApplicationRow {
+    pub fn new() -> Self {
+        glib::Object::new(&[]).expect("Failed to create ApplicationRow")
+    }
+
+    pub fn set_app_info(&self, app_obj: ApplicationObject) {
+        let self_ = imp::ApplicationRow::from_instance(self);
+
+        if let Ok(name) = app_obj.property("name") {
+            self_.name.set_text(
+                &name
+                    .get::<String>()
+                    .expect("Property name needs to be a String."),
+            );
+        }
+        if let Ok(desc) = app_obj.property("description") {
+            self_.description.set_text(
+                &desc
+                    .get::<String>()
+                    .expect("Property description needs to be a String."),
+            );
+        }
+        if let Ok(icon) = app_obj.property("icon") {
+            if let Ok(icon) = icon.get::<Variant>() {
+                let icon = match <(i32, String)>::from_variant(&icon) {
+                    Some((i_type, name)) if i_type == pop_launcher::IconSource::Name as i32 => {
+                        Some(pop_launcher::IconSource::Name(name.into()))
+                    }
+                    Some((i_type, name)) if i_type == pop_launcher::IconSource::Mime as i32 => {
+                        Some(pop_launcher::IconSource::Mime(name.into()))
+                    }
+                    _ => None,
+                };
+                icon_source(&self_.image, &icon);
+            }
+        }
+        if let Ok(icon) = app_obj.property("categoryicon") {
+            if let Ok(icon) = icon.get::<Variant>() {
+                let icon = match <(i32, String)>::from_variant(&icon) {
+                    Some((i_type, name)) if i_type == pop_launcher::IconSource::Name as i32 => {
+                        Some(pop_launcher::IconSource::Name(name.into()))
+                    }
+                    Some((i_type, name)) if i_type == pop_launcher::IconSource::Mime as i32 => {
+                        Some(pop_launcher::IconSource::Mime(name.into()))
+                    }
+                    _ => None,
+                };
+                icon_source(&self_.categoryimage, &icon);
+            }
+        }
+    }
+
+    pub fn set_shortcut(&self, indx: u32) {
+        let self_ = imp::ApplicationRow::from_instance(self);
+        self_.shortcut.set_text(&format!("Ctrl + {}", indx));
+    }
+}

examples/launcher/launcher_row/launcher_row.ui

@@ -1,40 +0,0 @@
-?xml version="1.0" encoding="UTF-8"?>
-<interface>
-  <template class="ApplicationRow" parent="GtkBox">
-    <property name="orientation">horizontal</property>
-    <property name="spacing">12</property>
-    <child>
-      <object class="GtkImage" id="image">
-        <property name="margin-top">6</property>
-        <property name="margin-bottom">6</property>
-        <property name="margin-start">6</property>
-        <property name="margin-end">6</property>
-        <property name="pixel-size">48</property>
-      </object>
-    </child>
-    <child>
-      <object class="GtkBox">
-        <property name="orientation">vertical</property>
-        <property name="margin-top">6</property>
-        <property name="margin-bottom">6</property>
-        <child>
-          <object class="GtkLabel" id="name">
-            <property name="halign">start</property>
-            <style>
-              <class name="title-4" />
-            </style>
-          </object>
-        </child>
-        <child>
-          <object class="GtkLabel" id="description">
-            <property name="halign">start</property>
-            <property name="wrap">True</property>
-            <style>
-              <class name="body" />
-            </style>
-          </object>
-        </child>
-      </object>
-    </child>
-  </template>
-</interface>

examples/launcher/main.rs

@@ -1,18 +1,22 @@
 mod application_object;
+mod application_row;
+use gio::DesktopAppInfo;
 use gtk4 as gtk;
+use gtk4::SliceListModel;
 
+use cascade::cascade;
 use gtk::gio;
 use gtk::prelude::*;
-use gtk::{
+use gtk::{glib, ListView, SignalListItemFactory, SingleSelection};
-    glib, Application, ApplicationWindow, Label, ListView, PolicyType, ScrolledWindow,
-    SignalListItemFactory, SingleSelection,
-};
 use libcosmic::x;
-use std::{cell::RefCell, rc::Rc};
+use pop_launcher_service::IpcClient;
+use postage::mpsc::Sender;
+use postage::prelude::*;
 
 use self::application_object::ApplicationObject;
-use self::ipc::LauncherIpc;
+use self::application_row::ApplicationRow;
-mod ipc;
+
+const NUM_LAUNCHER_ITEMS: u8 = 10;
 
 fn icon_source(icon: &gtk::Image, source: &Option<pop_launcher::IconSource>) {
     match source {
@@ -28,22 +32,50 @@ fn icon_source(icon: &gtk::Image, source: &Option<pop_launcher::IconSource>) {
     }
 }
 
-fn main() {
+enum Event {
-    let launcher = Rc::new(RefCell::new(
+    Response(pop_launcher::Response),
-        LauncherIpc::new().expect("failed to connect to launcher service"),
+    Search(String),
-    ));
+    Activate(u32),
+}
 
+fn spawn_launcher(mut tx: Sender<Event>) -> IpcClient {
+    let (launcher, responses) =
+        pop_launcher_service::IpcClient::new().expect("failed to connect to launcher service");
+
+    glib::MainContext::default().spawn_local(async move {
+        use futures::StreamExt;
+        futures::pin_mut!(responses);
+        while let Some(event) = responses.next().await {
+            let _ = tx.send(Event::Response(event)).await;
+        }
+    });
+
+    launcher
+}
+
+fn main() {
     let app = gtk::Application::builder()
         .application_id("com.system76.Launcher")
         .build();
 
     app.connect_activate(move |app| {
+        let (tx, mut rx) = postage::mpsc::channel(1);
+        let mut launcher = spawn_launcher(tx.clone());
+
+        //quit shortcut
+        app.set_accels_for_action("win.quit", &["<primary>W", "Escape"]);
+        //launch shortcuts
+        for i in 1..10 {
+            app.set_accels_for_action(&format!("win.launch{}", i), &[&format!("<primary>{}", i)]);
+        }
+
         let window = gtk::ApplicationWindow::builder()
             .application(app)
             .decorated(false)
-            .default_width(480)
+            .default_width(600)
             .default_height(440)
             .title("Launcher")
+            .resizable(false)
             .build();
 
         let vbox = gtk::Box::new(gtk::Orientation::Vertical, 16);
@@ -57,14 +89,11 @@ fn main() {
         search.set_placeholder_text(Some(" Type to search apps, or type '?' for more options."));
         vbox.append(&search);
 
-        let listbox = gtk::ListBox::new();
-        //vbox.append(&listbox);
-
         let model = gio::ListStore::new(ApplicationObject::static_type());
         let factory = SignalListItemFactory::new();
         factory.connect_setup(move |_, list_item| {
-            let label = Label::new(None);
+            let row = ApplicationRow::new();
-            list_item.set_child(Some(&label))
+            list_item.set_child(Some(&row))
         });
         factory.connect_bind(move |_, list_item| {
             let application_object = list_item
@@ -72,98 +101,85 @@ fn main() {
                 .expect("The item has to exist.")
                 .downcast::<ApplicationObject>()
                 .expect("The item has to be an `ApplicationObject`");
-            let name = application_object
+            let row = list_item
-                .property("name")
-                .expect("Property name of the wrong type or does not exist!")
-                .get::<String>()
-                .expect("Property name needs to be a String.");
-            let label = list_item
                 .child()
-                .expect("The child has to exist.")
+                .expect("The list item child needs to exist.")
-                .downcast::<Label>()
+                .downcast::<ApplicationRow>()
-                .expect("The child has to be a `label`");
+                .expect("The list item type needs to be `ApplicationRow`");
-            label.set_label(&name);
+            if list_item.position() < 9 {
+                row.set_shortcut(list_item.position() + 1);
+            }
+
+            row.set_app_info(application_object);
         });
-        let selection_model = SingleSelection::new(Some(&model));
+        let slice_model = SliceListModel::new(Some(&model), 0, NUM_LAUNCHER_ITEMS.into());
+        let selection_model = SingleSelection::new(Some(&slice_model));
         let list_view = ListView::new(Some(&selection_model), Some(&factory));
-        vbox.append(&list_view);
+        let scroll = cascade! {
+            gtk::ScrolledWindow::new();
+            ..set_min_content_height(400);
+            ..set_max_content_height(700);
+            ..set_propagate_natural_height(true);
+            ..set_vexpand(true);
+            ..set_policy(gtk::PolicyType::Never, gtk::PolicyType::Automatic);
+        };
+        scroll.set_child(Some(&list_view));
+        vbox.append(&scroll);
+
+        for i in 1..10 {
+            let action_launchi = gio::SimpleAction::new(&format!("launch{}", i), None);
+            window.add_action(&action_launchi);
+            action_launchi.connect_activate(
+                glib::clone!(@weak list_view, @strong tx =>  move |_action, _parameter| {
+                     println!("acitvating... {}", i);
+                     let model = list_view.model().unwrap();
+                     let app_info = model.item(i - 1);
+                     if app_info.is_none() {
+                         println!("oops no app for this row...");
+                         return;
+                     }
+                    if let Ok(id)= app_info.unwrap().property("id") {
+                         let id = id.get::<u32>().expect("App ID must be u32");
+                         let mut tx = tx.clone();
+
+                         glib::MainContext::default().spawn_local(async move {
+                             let _ = tx.send(Event::Activate(id)).await;
+                         });
+                     }
+                }),
+            );
+        }
+
+        list_view.connect_activate(glib::clone!(@strong tx =>  move |list_view, i| {
+            println!("acitvating... {}", i + 1);
+            let model = list_view.model().unwrap();
+            let app_info = model.item(i);
+            if app_info.is_none() {
+                println!("oops no app for this row...");
+                return;
+            }
+            if let Ok(id)= app_info.unwrap().property("id") {
+                let id = id.get::<u32>().expect("App ID must be u32");
+                let mut tx = tx.clone();
+
+                glib::MainContext::default().spawn_local(async move {
+                    let _ = tx.send(Event::Activate(id)).await;
+                });
+            }
+        }));
 
         {
-            let launcher = launcher.clone();
+            let search_changed = glib::clone!(@strong tx => move |search: &gtk::Entry| {
-            let search_changed = move |search: &gtk::Entry| {
+                let search = search.text().to_string();
-                let model_len = model.n_items();
-                //TODO: is this the best way to clear a listbox?
-                //while let Some(child) = listbox.last_child() {
-                //    listbox.remove(&child);
-                //}
 
-                let response_res = launcher
+                let mut tx = tx.clone();
-                    .borrow_mut()
+                glib::MainContext::default().spawn_local(async move {
-                    .request(pop_launcher::Request::Search(search.text().to_string()));
+                    let _ = tx.send(Event::Search(search)).await;
-
+                });
-                println!("{:#?}", response_res);
+            });
-
-                let num_items = 9;
-
-                if let Ok(pop_launcher::Response::Update(results)) = response_res {
-                    let new_results: Vec<glib::Object> = results
-                        [0..std::cmp::min(results.len(), num_items)]
-                        .iter()
-                        .map(|result| ApplicationObject::new(result).upcast())
-                        .collect();
-                    model.splice(0, model_len, &new_results[..]);
-                    // for (i, result) in results[0..std::cmp::min(results.len(), num_items)]
-                    //     .iter()
-                    //     .enumerate()
-                    // {
-                    //     dbg!(result);
-                    //     // Limit to 9 results
-                    //     // if i >= 9 {
-                    //     //     break 'result_loop;
-                    //     // }
-
-                    //     let row = gtk::ListBoxRow::new();
-                    //     listbox.append(&row);
-
-                    //     // Select first row
-                    //     if i == 0 {
-                    //         listbox.select_row(Some(&row));
-                    //     }
-
-                    //     let hbox = gtk::Box::new(gtk::Orientation::Horizontal, 8);
-                    //     hbox.set_margin_start(8);
-                    //     hbox.set_margin_end(8);
-                    //     hbox.set_margin_top(8);
-                    //     hbox.set_margin_bottom(8);
-                    //     row.set_child(Some(&hbox));
-
-                    //     let category_icon = gtk::Image::new();
-                    //     category_icon.set_pixel_size(16);
-                    //     icon_source(&category_icon, &result.category_icon);
-                    //     hbox.append(&category_icon);
-
-                    //     let icon = gtk::Image::new();
-                    //     icon.set_pixel_size(32);
-                    //     icon_source(&icon, &result.icon);
-                    //     hbox.append(&icon);
-
-                    //     let labels = gtk::Box::new(gtk::Orientation::Vertical, 4);
-                    //     hbox.append(&labels);
-
-                    //     let name = gtk::Label::new(Some(&result.name));
-                    //     name.set_halign(gtk::Align::Start);
-                    //     labels.append(&name);
-
-                    //     let description = gtk::Label::new(Some(&result.description));
-                    //     description.set_halign(gtk::Align::Start);
-                    //     labels.append(&description);
-                    // }
-                }
-            };
-
-            search.connect_changed(search_changed.clone());
 
             search_changed(&search);
+            search.connect_changed(search_changed);
         }
 
         // Setting the window to dialog type must happen between realize and show. Dialog windows
@@ -183,8 +199,54 @@ fn main() {
                 println!("failed to get X11 window");
             }
         });
+        let action_quit = gio::SimpleAction::new("quit", None);
+        action_quit.connect_activate(glib::clone!(@weak window => move |_, _| {
+            window.close();
+        }));
+        window.add_action(&action_quit);
+
+        window.connect_is_active_notify(|win| {
+            if !win.is_active() {
+                win.close();
+            }
+        });
 
         window.show();
+        glib::MainContext::default().spawn_local(async move {
+            while let Some(event) = rx.recv().await {
+                match event {
+                    Event::Search(search) => {
+                        let _ = launcher.send(pop_launcher::Request::Search(search)).await;
+                    }
+                    Event::Activate(index) => {
+                        let _ = launcher.send(pop_launcher::Request::Activate(index)).await;
+                    }
+
+                    Event::Response(event) => {
+                        if let pop_launcher::Response::Update(results) = event {
+                            let model_len = model.n_items();
+                            dbg!(&results);
+                            let new_results: Vec<glib::Object> = results
+                                [0..std::cmp::min(results.len(), NUM_LAUNCHER_ITEMS.into())]
+                                .iter()
+                                .map(|result| ApplicationObject::new(result).upcast())
+                                .collect();
+                            model.splice(0, model_len, &new_results[..]);
+                        } else if let pop_launcher::Response::DesktopEntry {
+                            path,
+                            gpu_preference: _gpu_preference, // TODO use GPU preference when launching app
+                        } = event
+                        {
+                            let app_info =
+                                DesktopAppInfo::new(&path.file_name().expect("desktop entry path needs to be a valid filename").to_string_lossy())
+                                    .expect("failed to create a Desktop App info for launching the application.");
+                            app_info
+                                .launch(&[], Some(&window.display().app_launch_context().clone())).expect("failed to launch the application.");
+                        }
+                    }
+                }
+            }
+        })
     });
 
     app.run();