refactor(wayland): update to 0.30.0

This is pretty much a rewrite of the Wayland client code for `wayland-client` and `wayland-protocols` v0.30.0, and `smithay-client-toolkit` v0.17.0

src/modules/clipboard.rs

@@ -80,7 +80,7 @@ impl Module<Button> for ClipboardModule {
         spawn(async move {
             let mut rx = {
                 let client = clipboard::get_client();
-                client.subscribe(max_items).await
+                client.subscribe(max_items)
             };
 
             while let Some(event) = rx.recv().await {

src/modules/focused.rs

@@ -1,8 +1,8 @@
-use crate::clients::wayland::{self, ToplevelChange};
+use crate::clients::wayland::{self, ToplevelEvent};
 use crate::config::{CommonConfig, TruncateMode};
 use crate::image::ImageProvider;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::{await_sync, read_lock, send_async};
+use crate::{send_async, try_send};
 use color_eyre::Result;
 use glib::Continue;
 use gtk::prelude::*;
@@ -10,7 +10,7 @@ use gtk::Label;
 use serde::Deserialize;
 use tokio::spawn;
 use tokio::sync::mpsc::{Receiver, Sender};
-use tracing::error;
+use tracing::{debug, error};
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct FocusedModule {
@@ -49,38 +49,36 @@ impl Module<gtk::Box> for FocusedModule {
         tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
         _rx: Receiver<Self::ReceiveMessage>,
     ) -> Result<()> {
-        let focused = await_sync(async {
-            let wl = wayland::get_client().await;
-            let toplevels = read_lock!(wl.toplevels);
-
-            toplevels
-                .iter()
-                .find(|(_, (top, _))| top.active)
-                .map(|(_, (top, _))| top.clone())
-        });
-
-        if let Some(top) = focused {
-            tx.try_send(ModuleUpdateEvent::Update((top.title.clone(), top.app_id)))?;
-        }
-
         spawn(async move {
-            let mut wlrx = {
+            let (mut wlrx, handles) = {
                 let wl = wayland::get_client().await;
                 wl.subscribe_toplevels()
             };
 
-            while let Ok(event) = wlrx.recv().await {
-                let update = match event.change {
-                    ToplevelChange::Focus(focus) => focus,
-                    ToplevelChange::Title(_) => event.toplevel.active,
-                    _ => false,
-                };
+            let focused = handles.values().find_map(|handle| {
+                handle
+                    .info()
+                    .and_then(|info| if info.focused { Some(info) } else { None })
+            });
 
-                if update {
-                    send_async!(
-                        tx,
-                        ModuleUpdateEvent::Update((event.toplevel.title, event.toplevel.app_id))
-                    );
+            if let Some(focused) = focused {
+                try_send!(
+                    tx,
+                    ModuleUpdateEvent::Update((focused.title.clone(), focused.app_id))
+                );
+            };
+
+            while let Ok(event) = wlrx.recv().await {
+                if let ToplevelEvent::Update(handle) = event {
+                    let info = handle.info().unwrap_or_default();
+
+                    if info.focused {
+                        debug!("Changing focus");
+                        send_async!(
+                            tx,
+                            ModuleUpdateEvent::Update((info.title.clone(), info.app_id.clone()))
+                        );
+                    }
                 }
             }
         });

src/modules/launcher/item.rs

@@ -1,10 +1,11 @@
 use super::open_state::OpenState;
-use crate::clients::wayland::ToplevelInfo;
+use crate::clients::wayland::ToplevelHandle;
 use crate::image::ImageProvider;
 use crate::modules::launcher::{ItemEvent, LauncherUpdate};
 use crate::modules::ModuleUpdateEvent;
 use crate::popup::Popup;
 use crate::{read_lock, try_send};
+use color_eyre::{Report, Result};
 use gtk::prelude::*;
 use gtk::{Button, IconTheme, Orientation};
 use indexmap::IndexMap;
@@ -12,6 +13,7 @@ use std::rc::Rc;
 use std::sync::RwLock;
 use tokio::sync::mpsc::Sender;
 use tracing::error;
+use wayland_client::protocol::wl_seat::WlSeat;
 
 #[derive(Debug, Clone)]
 pub struct Item {
@@ -34,24 +36,30 @@ impl Item {
     }
 
     /// Merges the provided node into this launcher item
-    pub fn merge_toplevel(&mut self, node: ToplevelInfo) -> Window {
-        let id = node.id;
+    pub fn merge_toplevel(&mut self, handle: ToplevelHandle) -> Result<Window> {
+        let info = handle
+            .info()
+            .ok_or_else(|| Report::msg("Toplevel is missing associated info"))?;
+
+        let id = info.id;
 
         if self.windows.is_empty() {
-            self.name = node.title.clone();
+            self.name = info.title;
         }
 
-        let window: Window = node.into();
+        let window = Window::try_from(handle)?;
         self.windows.insert(id, window.clone());
 
         self.recalculate_open_state();
 
-        window
+        Ok(window)
     }
 
-    pub fn unmerge_toplevel(&mut self, node: &ToplevelInfo) {
-        self.windows.remove(&node.id);
-        self.recalculate_open_state();
+    pub fn unmerge_toplevel(&mut self, handle: &ToplevelHandle) {
+        if let Some(info) = handle.info() {
+            self.windows.remove(&info.id);
+            self.recalculate_open_state();
+        }
     }
 
     pub fn set_window_name(&mut self, window_id: usize, name: String) {
@@ -87,22 +95,29 @@ impl Item {
     }
 }
 
-impl From<ToplevelInfo> for Item {
-    fn from(toplevel: ToplevelInfo) -> Self {
-        let open_state = OpenState::from_toplevel(&toplevel);
-        let name = toplevel.title.clone();
-        let app_id = toplevel.app_id.clone();
+impl TryFrom<ToplevelHandle> for Item {
+    type Error = Report;
+
+    fn try_from(handle: ToplevelHandle) -> std::result::Result<Self, Self::Error> {
+        let info = handle
+            .info()
+            .ok_or_else(|| Report::msg("Toplevel is missing associated info"))?;
+
+        let name = info.title.clone();
+        let app_id = info.app_id.clone();
+        let open_state = OpenState::from(&info);
 
         let mut windows = IndexMap::new();
-        windows.insert(toplevel.id, toplevel.into());
+        let window = Window::try_from(handle)?;
+        windows.insert(info.id, window);
 
-        Self {
+        Ok(Self {
             app_id,
             favorite: false,
             open_state,
             windows,
             name,
-        }
+        })
     }
 }
 
@@ -111,17 +126,30 @@ pub struct Window {
     pub id: usize,
     pub name: String,
     pub open_state: OpenState,
+    handle: ToplevelHandle,
 }
 
-impl From<ToplevelInfo> for Window {
-    fn from(node: ToplevelInfo) -> Self {
-        let open_state = OpenState::from_toplevel(&node);
+impl TryFrom<ToplevelHandle> for Window {
+    type Error = Report;
 
-        Self {
-            id: node.id,
-            name: node.title,
+    fn try_from(handle: ToplevelHandle) -> Result<Self, Self::Error> {
+        let info = handle
+            .info()
+            .ok_or_else(|| Report::msg("Toplevel is missing associated info"))?;
+        let open_state = OpenState::from(&info);
+
+        Ok(Self {
+            id: info.id,
+            name: info.title,
             open_state,
-        }
+            handle,
+        })
+    }
+}
+
+impl Window {
+    pub fn focus(&self, seat: &WlSeat) {
+        self.handle.focus(seat);
     }
 }
 

src/modules/launcher/mod.rs

@@ -3,12 +3,12 @@ mod open_state;
 
 use self::item::{Item, ItemButton, Window};
 use self::open_state::OpenState;
-use crate::clients::wayland::{self, ToplevelChange};
+use crate::clients::wayland::{self, ToplevelEvent};
 use crate::config::CommonConfig;
 use crate::desktop_file::find_desktop_file;
 use crate::modules::launcher::item::AppearanceOptions;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::{lock, read_lock, try_send, write_lock};
+use crate::{lock, send_async, try_send, write_lock};
 use color_eyre::{Help, Report};
 use glib::Continue;
 use gtk::prelude::*;
@@ -18,7 +18,6 @@ use serde::Deserialize;
 use std::process::{Command, Stdio};
 use std::sync::{Arc, Mutex};
 use tokio::spawn;
-use tokio::sync::mpsc;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::{debug, error, trace};
 
@@ -111,70 +110,64 @@ impl Module<gtk::Box> for LauncherModule {
 
         let items = Arc::new(Mutex::new(items));
 
-        {
-            let items = Arc::clone(&items);
-            let tx = tx.clone();
-            spawn(async move {
-                let wl = wayland::get_client().await;
-                let open_windows = read_lock!(wl.toplevels);
-
-                let open_windows = open_windows.clone();
-                for (_, (window, _)) in open_windows {
-                    let mut items = lock!(items);
-                    let item = items.get_mut(&window.app_id);
-                    match item {
-                        Some(item) => {
-                            item.merge_toplevel(window);
-                        }
-                        None => {
-                            items.insert(window.app_id.clone(), window.into());
-                        }
-                    }
-                }
-
-                let items = lock!(items);
-                let items = items.iter();
-                for (_, item) in items {
-                    tx.try_send(ModuleUpdateEvent::Update(LauncherUpdate::AddItem(
-                        item.clone(),
-                    )))?;
-                }
-
-                Ok::<(), Report>(())
-            });
-        }
-
         let items2 = Arc::clone(&items);
+        let tx2 = tx.clone();
         spawn(async move {
             let items = items2;
+            let tx = tx2;
 
-            let mut wlrx = {
+            let (mut wlrx, handles) = {
                 let wl = wayland::get_client().await;
                 wl.subscribe_toplevels()
             };
 
+            for handle in handles.values() {
+                let Some(info) = handle.info() else { continue };
+
+                let mut items = lock!(items);
+                let item = items.get_mut(&info.app_id);
+                match item {
+                    Some(item) => {
+                        item.merge_toplevel(handle.clone())?;
+                    }
+                    None => {
+                        items.insert(info.app_id.clone(), Item::try_from(handle.clone())?);
+                    }
+                }
+            }
+
+            {
+                let items = lock!(items);
+                let items = items.iter();
+                for (_, item) in items {
+                    try_send!(
+                        tx,
+                        ModuleUpdateEvent::Update(LauncherUpdate::AddItem(item.clone()))
+                    );
+                }
+            }
+
             let send_update = |update: LauncherUpdate| tx.send(ModuleUpdateEvent::Update(update));
 
             while let Ok(event) = wlrx.recv().await {
                 trace!("event: {:?}", event);
 
-                let window = event.toplevel;
-                let app_id = window.app_id.clone();
+                match event {
+                    ToplevelEvent::New(handle) => {
+                        let Some(info) = handle.info() else { continue };
 
-                match event.change {
-                    ToplevelChange::New => {
                         let new_item = {
                             let mut items = lock!(items);
-                            let item = items.get_mut(&app_id);
+                            let item = items.get_mut(&info.app_id);
                             match item {
                                 None => {
-                                    let item: Item = window.into();
-                                    items.insert(app_id.clone(), item.clone());
+                                    let item: Item = handle.try_into()?;
+                                    items.insert(info.app_id.clone(), item.clone());
 
                                     ItemOrWindow::Item(item)
                                 }
                                 Some(item) => {
-                                    let window = item.merge_toplevel(window);
+                                    let window = item.merge_toplevel(handle)?;
                                     ItemOrWindow::Window(window)
                                 }
                             }
@@ -185,20 +178,40 @@ impl Module<gtk::Box> for LauncherModule {
                                 send_update(LauncherUpdate::AddItem(item)).await
                             }
                             ItemOrWindow::Window(window) => {
-                                send_update(LauncherUpdate::AddWindow(app_id, window)).await
+                                send_update(LauncherUpdate::AddWindow(info.app_id.clone(), window))
+                                    .await
                             }
                         }?;
                     }
-                    ToplevelChange::Close => {
+                    ToplevelEvent::Update(handle) => {
+                        let Some(info) = handle.info() else { continue };
+
+                        if let Some(item) = lock!(items).get_mut(&info.app_id) {
+                            item.set_window_focused(info.id, info.focused);
+                            item.set_window_name(info.id, info.title.clone());
+                        }
+
+                        send_update(LauncherUpdate::Focus(info.app_id.clone(), info.focused))
+                            .await?;
+                        send_update(LauncherUpdate::Title(
+                            info.app_id.clone(),
+                            info.id,
+                            info.title.clone(),
+                        ))
+                        .await?;
+                    }
+                    ToplevelEvent::Remove(handle) => {
+                        let Some(info) = handle.info() else { continue };
+
                         let remove_item = {
                             let mut items = lock!(items);
-                            let item = items.get_mut(&app_id);
+                            let item = items.get_mut(&info.app_id);
                             match item {
                                 Some(item) => {
-                                    item.unmerge_toplevel(&window);
+                                    item.unmerge_toplevel(&handle);
 
                                     if item.windows.is_empty() {
-                                        items.remove(&app_id);
+                                        items.remove(&info.app_id);
                                         Some(ItemOrWindowId::Item)
                                     } else {
                                         Some(ItemOrWindowId::Window)
@@ -210,56 +223,28 @@ impl Module<gtk::Box> for LauncherModule {
 
                         match remove_item {
                             Some(ItemOrWindowId::Item) => {
-                                send_update(LauncherUpdate::RemoveItem(app_id)).await?;
+                                send_update(LauncherUpdate::RemoveItem(info.app_id.clone()))
+                                    .await?;
                             }
                             Some(ItemOrWindowId::Window) => {
-                                send_update(LauncherUpdate::RemoveWindow(app_id, window.id))
-                                    .await?;
+                                send_update(LauncherUpdate::RemoveWindow(
+                                    info.app_id.clone(),
+                                    info.id,
+                                ))
+                                .await?;
                             }
                             None => {}
                         };
                     }
-                    ToplevelChange::Focus(focused) => {
-                        let mut update_title = false;
-
-                        if focused {
-                            if let Some(item) = lock!(items).get_mut(&app_id) {
-                                item.set_window_focused(window.id, true);
-
-                                // might be switching focus between windows of same app
-                                if item.windows.len() > 1 {
-                                    item.set_window_name(window.id, window.title.clone());
-                                    update_title = true;
-                                }
-                            }
-                        }
-
-                        send_update(LauncherUpdate::Focus(app_id.clone(), focused)).await?;
-
-                        if update_title {
-                            send_update(LauncherUpdate::Title(app_id, window.id, window.title))
-                                .await?;
-                        }
-                    }
-                    ToplevelChange::Title(title) => {
-                        if let Some(item) = lock!(items).get_mut(&app_id) {
-                            item.set_window_name(window.id, title.clone());
-                        }
-
-                        send_update(LauncherUpdate::Title(app_id, window.id, title)).await?;
-                    }
-                    ToplevelChange::Fullscreen(_) => {}
                 }
             }
 
-            Ok::<(), mpsc::error::SendError<ModuleUpdateEvent<LauncherUpdate>>>(())
+            Ok::<(), Report>(())
         });
 
         // listen to ui events
         spawn(async move {
             while let Some(event) = rx.recv().await {
-                trace!("{:?}", event);
-
                 if let ItemEvent::OpenItem(app_id) = event {
                     find_desktop_file(&app_id).map_or_else(
                         || error!("Could not find desktop file for {}", app_id),
@@ -295,11 +280,12 @@ impl Module<gtk::Box> for LauncherModule {
                     };
 
                     if let Some(id) = id {
-                        let toplevels = read_lock!(wl.toplevels);
-                        let seat = wl.seats.first().expect("Failed to get Wayland seat");
-                        if let Some((_top, handle)) = toplevels.get(&id) {
-                            handle.activate(seat);
-                        };
+                        if let Some(window) =
+                            items.iter().find_map(|(_, item)| item.windows.get(&id))
+                        {
+                            let seat = wl.get_seats().pop().expect("Failed to get Wayland seat");
+                            window.focus(&seat);
+                        }
                     }
 
                     // roundtrip to immediately send activate event
@@ -456,7 +442,7 @@ impl Module<gtk::Box> for LauncherModule {
 
                                 {
                                     let tx = controller_tx.clone();
-                                    button.connect_clicked(move |button| {
+                                    button.connect_clicked(move |_| {
                                         try_send!(tx, ItemEvent::FocusWindow(win.id));
 
                                         if let Some(win) = button.window() {
@@ -548,6 +534,9 @@ impl Module<gtk::Box> for LauncherModule {
 /// This is a hacky number derived from
 /// "what fits inside the 250px popup"
 /// and probably won't hold up with wide fonts.
+///
+/// TODO: Migrate this to truncate system
+///
 fn clamp(str: &str) -> String {
     const MAX_CHARS: usize = 24;
 

src/modules/launcher/open_state.rs

@@ -7,14 +7,15 @@ pub enum OpenState {
     Open { focused: bool },
 }
 
-impl OpenState {
-    /// Creates from `SwayNode`
-    pub const fn from_toplevel(toplevel: &ToplevelInfo) -> Self {
+impl From<&ToplevelInfo> for OpenState {
+    fn from(info: &ToplevelInfo) -> Self {
         Self::Open {
-            focused: toplevel.active,
+            focused: info.focused,
         }
     }
+}
 
+impl OpenState {
     /// Creates open with focused
     pub const fn focused(focused: bool) -> Self {
         Self::Open { focused }