dock right click menu

examples/dock/dock_item/imp.rs

@@ -1,5 +1,9 @@
+use glib::subclass::Signal;
 use gtk4::glib;
+use gtk4::prelude::*;
 use gtk4::subclass::prelude::*;
+use gtk4::PopoverMenu;
+use once_cell::sync::Lazy;
 use std::cell::RefCell;
 use std::rc::Rc;
 
@@ -7,6 +11,8 @@ use std::rc::Rc;
 pub struct DockItem {
     pub image: Rc<RefCell<gtk4::Image>>,
     pub dots: Rc<RefCell<gtk4::Label>>,
+    pub item_box: Rc<RefCell<gtk4::Box>>,
+    pub popover_menu: Rc<RefCell<Option<PopoverMenu>>>,
 }
 
 #[glib::object_subclass]
@@ -16,7 +22,22 @@ impl ObjectSubclass for DockItem {
     type ParentType = gtk4::Button;
 }
 
-impl ObjectImpl for DockItem {}
+impl ObjectImpl for DockItem {
+    fn signals() -> &'static [Signal] {
+        static SIGNALS: Lazy<Vec<Signal>> = Lazy::new(|| {
+            vec![Signal::builder(
+                // Signal name
+                "popover-closed",
+                // Types of the values which will be sent to the signal handler
+                &[],
+                // Type of the value the signal handler sends back
+                <()>::static_type().into(),
+            )
+            .build()]
+        });
+        SIGNALS.as_ref()
+    }
+}
 
 impl WidgetImpl for DockItem {}
 

examples/dock/dock_item/mod.rs

@@ -1,6 +1,8 @@
 use cascade::cascade;
 use gio::DesktopAppInfo;
 use gio::Icon;
+use gio::Menu;
+use gio::MenuItem;
 use gtk4::glib;
 use gtk4::prelude::*;
 use gtk4::subclass::prelude::*;
@@ -9,6 +11,7 @@ use gtk4::Box;
 use gtk4::Image;
 use gtk4::Label;
 use gtk4::Orientation;
+use gtk4::PopoverMenu;
 
 use crate::dock_object::DockObject;
 use crate::utils::BoxedWindowList;
@@ -47,11 +50,24 @@ impl DockItem {
         };
         item_box.append(&image);
         item_box.append(&dots);
+        let popover_menu = cascade! {
+            PopoverMenu::from_model_full(&Menu::new(), gtk4::PopoverMenuFlags::NESTED);
+            ..set_autohide(true);
+        };
+        item_box.append(&popover_menu);
+        let self_clone = self_.clone();
+        popover_menu.connect_closed(move |_| {
+            self_clone
+                .emit_by_name::<&str>("popover-closed", &[])
+                .unwrap();
+        });
 
         let imp = imp::DockItem::from_instance(&self_);
         imp.image.replace(image);
         imp.dots.replace(dots);
-        self_.show();
+        imp.item_box.replace(item_box);
+        imp.popover_menu.replace(Some(popover_menu));
+
         self_
     }
 
@@ -83,5 +99,85 @@ impl DockItem {
                 }
             }
         }
+        if let Ok(popover_value) = dock_object.property("popover") {
+            if let Ok(popover) = popover_value.get::<bool>() {
+                dbg!(popover);
+                dbg!(dock_object);
+                if popover {
+                    self.add_popover(dock_object);
+                } else {
+                    self.clear_popover();
+                }
+            }
+        }
+    }
+
+    pub fn add_popover(&self, item: &DockObject) {
+        let imp = imp::DockItem::from_instance(self);
+        if let Some(popover_menu) = imp.popover_menu.borrow().as_ref() {
+            let menu = if let Some(m) = popover_menu.menu_model() {
+                m.downcast::<Menu>().unwrap()
+            } else {
+                Menu::new()
+            };
+            menu.remove_all();
+
+            let appinfo = item
+                .property("appinfo")
+                .expect("property appinfo missing from DockObject")
+                .get::<Option<DesktopAppInfo>>();
+            let window_list = item
+                .property("active")
+                .expect("property appinfo missing from DockObject")
+                .get::<BoxedWindowList>();
+
+            if let Ok(Some(_appinfo)) = appinfo {
+                let launch_menu = Menu::new();
+                let launch_subsection = MenuItem::new_section(None, &launch_menu);
+                launch_menu.append(Some("New Window"), None);
+                menu.append_item(&launch_subsection);
+            }
+
+            let favorites_menu = Menu::new();
+            let favorites_subsection = MenuItem::new_section(None, &favorites_menu);
+            match item.property("saved").unwrap().get::<bool>().unwrap() {
+                true => favorites_menu.append(Some("Remove from Favorites"), None),
+                false => favorites_menu.append(Some("Add to Favorites"), None),
+            };
+            menu.append_item(&favorites_subsection);
+
+            if let Ok(window_list) = window_list {
+                let window_list = window_list.0;
+                if window_list.len() > 0 {
+                    let all_windows_submenu_menu = Menu::new();
+                    for w in window_list {
+                        all_windows_submenu_menu.append(Some(w.name.as_str()), None);
+                    }
+
+                    let all_windows_menu = Menu::new();
+                    let all_windows_submenu =
+                        MenuItem::new_submenu(Some("All Windows"), &all_windows_submenu_menu);
+                    all_windows_menu.append_item(&all_windows_submenu);
+                    let all_windows_subsection = MenuItem::new_section(None, &all_windows_menu);
+
+                    let quit_windows_menu = Menu::new();
+                    quit_windows_menu.append(Some("Quit All"), None);
+                    let quit_windows_subsection = MenuItem::new_section(None, &quit_windows_menu);
+
+                    menu.prepend_item(&all_windows_subsection);
+                    menu.append_item(&quit_windows_subsection);
+                }
+            }
+            popover_menu.popup();
+        }
+    }
+
+    pub fn clear_popover(&self) {
+        let imp = imp::DockItem::from_instance(self);
+        let popover_menu = imp.popover_menu.borrow();
+
+        if let Some(popover) = popover_menu.as_ref() {
+            popover.popdown();
+        }
     }
 }