chore(release): v0.6.0

* feat: more positioning options

Can now display the bar on the left/right, and avoid anchoring to edges to centre the bar.

BREAKING CHANGE: The `left` and `right` config options have been renamed to `start` and `end`

.github/workflows/deploy.yml

@@ -17,12 +17,16 @@ jobs:
           toolchain: stable
           override: true
 
+      - name: Install build deps
+        run: sudo apt install libgtk-3-dev libgtk-layer-shell-dev
+
       - name: Update CHANGELOG
         id: changelog
         uses: Requarks/changelog-action@v1
         with:
           token: ${{ github.token }}
           tag: ${{ github.ref_name }}
+          excludeTypes: 'build,chore,style'
 
       - name: Create release
         uses: ncipollo/release-action@v1

.idea/runConfigurations/Format.xml

@@ -0,0 +1,17 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Format" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="command" value="fmt" />
+    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <option name="channel" value="DEFAULT" />
+    <option name="requiredFeatures" value="true" />
+    <option name="allFeatures" value="false" />
+    <option name="emulateTerminal" value="false" />
+    <option name="withSudo" value="false" />
+    <option name="buildTarget" value="REMOTE" />
+    <option name="backtrace" value="SHORT" />
+    <envs />
+    <option name="isRedirectInput" value="false" />
+    <option name="redirectInputPath" value="" />
+    <method v="2" />
+  </configuration>
+</component>

.idea/runConfigurations/Run.xml

@@ -12,6 +12,7 @@
     <envs>
       <env name="IRONBAR_CONFIG" value="examples/config.json" />
       <env name="PATH" value="/usr/local/bin:/usr/bin:$USER_HOME$/.local/share/npm/bin" />
+      <env name="RUST_LOG" value="debug" />
     </envs>
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />

.idea/runConfigurations/Run__GTK_Debug_.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Run (Debug)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+  <configuration default="false" name="Run (GTK Debug)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="command" value="run --package ironbar --bin ironbar" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="channel" value="DEFAULT" />
@@ -12,6 +12,8 @@
     <envs>
       <env name="GTK_DEBUG" value="interactive" />
       <env name="IRONBAR_CONFIG" value="examples/config.json" />
+      <env name="RUST_LOG" value="debug" />
+      <env name="PATH" value="/usr/local/bin:/usr/bin:$USER_HOME$/.local/share/npm/bin" />
     </envs>
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />

.idea/runConfigurations/Run__Live_Config_.xml

@@ -11,6 +11,7 @@
     <option name="backtrace" value="SHORT" />
     <envs>
       <env name="PATH" value="/usr/local/bin:/usr/bin:$USER_HOME$/.local/share/npm/bin" />
+      <env name="RUST_LOG" value="debug" />
     </envs>
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />

CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v0.5.2] - 2022-09-07
+### :wrench: Chores
+- [`b801751`](https://github.com/JakeStanger/ironbar/commit/b801751bdabd8416084f46e6b6d803ea28a259ec) - **release**: v0.5.2 *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.5.1] - 2022-09-06
+### :bug: Bug Fixes
+- [`b81927e`](https://github.com/JakeStanger/ironbar/commit/b81927e3a57808188e31419695a36aa4ea3f2830) - **launcher**: opening new instances when focused/urgent *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`a35d255`](https://github.com/JakeStanger/ironbar/commit/a35d25520cd3fd235cdc77ec6209d88499ca3639) - **launcher**: item state changes not handled correctly *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :wrench: Chores
+- [`481adfc`](https://github.com/JakeStanger/ironbar/commit/481adfcaa41c0d3a1ba7d61edb68db49d959c78f) - **intellij**: update run configs *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`6871126`](https://github.com/JakeStanger/ironbar/commit/6871126bd8def89ccbf2934180d615e781ec32c7) - **release**: v0.5.1 *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.5.0] - 2022-08-25
+### :sparkles: New Features
+- [`1e38719`](https://github.com/JakeStanger/ironbar/commit/1e387199962b81caeb40ffbd99a956f24abdf4e3) - introduce logging in some areas *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :bug: Bug Fixes
+- [`023c2fb`](https://github.com/JakeStanger/ironbar/commit/023c2fb118f46f3592f1dfe1a6704014c062ab3f) - **workspaces**: not listening to move event *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`6dcae66`](https://github.com/JakeStanger/ironbar/commit/6dcae66570cf5434e077ec823cded33771b4239c) - avoid creating loads of sway/mpd clients *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :wrench: Chores
+- [`015dcd3`](https://github.com/JakeStanger/ironbar/commit/015dcd3204dfa6a1ebcef1b4f3b345ed733fee2f) - **release**: v0.5.0 *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.4.0] - 2022-08-22
+### :sparkles: New Features
+- [`ab8f7ec`](https://github.com/JakeStanger/ironbar/commit/ab8f7ecfc8fa4b96fce78518af75794641950140) - logging support and proper error handling *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :bug: Bug Fixes
+- [`f2ee2df`](https://github.com/JakeStanger/ironbar/commit/f2ee2dfe7a0f5575d0c3ec09644ca990b088cd85) - error when using with `swaybar_command` *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :wrench: Chores
+- [`1d7c377`](https://github.com/JakeStanger/ironbar/commit/1d7c3772e4b97c7198043cb55fe9c71695a211ab) - **release**: v0.4.0 *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+[v0.4.0]: https://github.com/JakeStanger/ironbar/compare/v0.3.0...v0.4.0
+[v0.5.0]: https://github.com/JakeStanger/ironbar/compare/v0.4.0...v0.5.0
+[v0.5.1]: https://github.com/JakeStanger/ironbar/compare/v0.5.0...v0.5.1
+[v0.5.2]: https://github.com/JakeStanger/ironbar/compare/v0.5.1...v0.5.2

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ironbar"
-version = "0.4.0"
+version = "0.6.0"
 edition = "2021"
 license = "MIT"
 description = "Customisable wlroots/sway bar"
@@ -8,10 +8,11 @@ description = "Customisable wlroots/sway bar"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+derive_builder = "0.11.2"
 gtk = "0.15.5"
 gtk-layer-shell = "0.4.1"
 glib = "0.15.12"
-tokio = { version = "1.20.1", features = ["macros", "rt-multi-thread", "time"] }
+tokio = { version = "1.21.2", features = ["macros", "rt-multi-thread", "time"] }
 tracing = "0.1.36"
 tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
 tracing-error = "0.2.0"
@@ -24,14 +25,17 @@ serde = { version = "1.0.141", features = ["derive"] }
 serde_json = "1.0.82"
 serde_yaml = "0.9.4"
 toml = "0.5.9"
-cornfig = "0.2.0"
+cornfig = "0.3.0"
+lazy_static = "1.4.0"
+async_once = "0.2.6"
 regex = "1.6.0"
-stray = "0.1.1"
+stray = { git = "https://github.com/JakeStanger/stray.git", branch = "fix/tracing" }
 dirs = "4.0.0"
 walkdir = "2.3.2"
-notify = "4.0.17"
+notify = "5.0.0"
-mpd_client = "0.7.5"
+mpd_client = "1.0.0"
-ksway = "0.1.0"
+swayipc-async = { git = "https://github.com/JakeStanger/swayipc-rs.git", branch = "feat/derive-clone" }
-sysinfo = "0.25.1"
+sysinfo = "0.26.2"
-# required for wrapping ksway
+wayland-client = "0.29.5"
-crossbeam-channel = "0.3.9"
+wayland-protocols = { version = "0.29.5", features=["unstable_protocols", "client"] }
+smithay-client-toolkit = "0.16.0"

README.md

@@ -1,6 +1,6 @@
 # Ironbar
 
-Ironbar is a customisable and feature-rich bar targeting the Sway compositor, written in Rust. 
+Ironbar is a customisable and feature-rich bar targeting wlroots compositors, written in Rust.
 It uses GTK3 and gtk-layer-shell.
 
 The bar can be styled to your liking using CSS and hot-loads style changes.
@@ -26,6 +26,8 @@ cargo install ironbar
 yay -S ironbar-git
 ```
 
+[aur package](https://aur.archlinux.org/packages/ironbar-git)
+
 ### Source
 
 ```sh
@@ -36,7 +38,7 @@ cargo build --release
 install target/release/ironbar ~/.local/bin/ironbar
 ```
 
-[aur package](https://aur.archlinux.org/packages/ironbar-git)
+[repo](https://github.com/jakestanger/ironbar)
 
 ## Configuration
 
@@ -48,7 +50,8 @@ A full configuration guide can be found [here](https://github.com/JakeStanger/ir
 
 ## Styling
 
-To get started, create a stylesheet at `.config/ironbar/style.css`. Changes will be hot-reloaded every time you save the file.
+To get started, create a stylesheet at `.config/ironbar/style.css`. Changes will be hot-reloaded every time you save the
+file.
 
 A full styling guide can be found [here](https://github.com/JakeStanger/ironbar/wiki/styling-guide).
 
@@ -75,3 +78,4 @@ Please check [here](https://github.com/JakeStanger/ironbar/blob/master/CONTRIBUT
 
 - [Waybar](https://github.com/Alexays/Waybar) - A lot of the initial inspiration, and a pretty great bar.
 - [Rustbar](https://github.com/zeroeightysix/rustbar) - Served as a good demo for writing a basic GTK bar in Rust
+- [Smithay Client Toolkit](https://github.com/Smithay/client-toolkit) - Essential in being able to communicate to Wayland

examples/config.corn

@@ -39,5 +39,7 @@ let {
     $right = [ $mpd_local $mpd_server $phone_battery $sys_info $clock ]
 }
 in {
-    left = $left right = $right
+    anchor_to_edges = true
+    position = "top"
+    start = $left end = $right
 }

examples/config.json

@@ -1,18 +1,43 @@
 {
-  "monitors": {
+  "start": [
-    "DP-1": [
     {
-        "left": [{"type":  "clock"}]
+      "type": "workspaces"
     },
     {
-        "position": "top",
+      "type": "launcher",
-        "left": []
+      "icon_theme": "Paper",
+      "favorites": [
+        "firefox",
+        "discord",
+        "Steam"
+      ],
+      "show_names": false
     }
   ],
-    "DP-2": {
+  "end": [
-      "position": "bottom",
+    {
-      "height": 30,
+      "type": "mpd"
-      "left": []
+    },
-    }
+    {
+      "type": "mpd",
+      "host": "chloe:6600"
+    },
+    {
+      "path": "/home/jake/bin/phone-battery",
+      "type": "script"
+    },
+    {
+      "format": [
+        "{cpu-percent}% ",
+        "{memory-percent}% "
+      ],
+      "type": "sys-info"
+    },
+    {
+      "type": "tray"
+    },
+    {
+      "type": "clock"
     }
+  ]
 }

src/bar.rs

@@ -1,11 +1,25 @@
+use crate::bridge_channel::BridgeChannel;
 use crate::config::{BarPosition, ModuleConfig};
-use crate::modules::{Module, ModuleInfo, ModuleLocation};
+use crate::modules::launcher::{ItemEvent, LauncherUpdate};
+use crate::modules::mpd::{PlayerCommand, SongUpdate};
+use crate::modules::workspaces::WorkspaceUpdate;
+use crate::modules::{Module, ModuleInfoBuilder, ModuleLocation, ModuleUpdateEvent, WidgetContext};
+use crate::popup::Popup;
 use crate::Config;
+use chrono::{DateTime, Local};
 use color_eyre::Result;
 use gtk::gdk::Monitor;
 use gtk::prelude::*;
 use gtk::{Application, ApplicationWindow, Orientation};
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+use stray::message::NotifierItemCommand;
+use stray::NotifierItemMessage;
+use tokio::sync::mpsc;
+use tracing::{debug, info};
 
+/// Creates a new window for a bar,
+/// sets it up and adds its widgets.
 pub fn create_bar(
     app: &Application,
     monitor: &Monitor,
@@ -14,42 +28,64 @@ pub fn create_bar(
 ) -> Result<()> {
     let win = ApplicationWindow::builder().application(app).build();
 
-    setup_layer_shell(&win, monitor, &config.position);
+    setup_layer_shell(&win, monitor, config.position, config.anchor_to_edges);
+
+    let orientation = config.position.get_orientation();
 
     let content = gtk::Box::builder()
-        .orientation(Orientation::Horizontal)
+        .orientation(orientation)
         .spacing(0)
         .hexpand(false)
-        .height_request(config.height)
+        .name("bar");
-        .name("bar")
+
+    let content = if orientation == Orientation::Horizontal {
+        content.height_request(config.height)
+    } else {
+        content.width_request(config.height)
+    }
     .build();
 
-    let left = gtk::Box::builder().spacing(0).name("left").build();
+    let start = gtk::Box::builder()
-    let center = gtk::Box::builder().spacing(0).name("center").build();
+        .orientation(orientation)
-    let right = gtk::Box::builder().spacing(0).name("right").build();
+        .spacing(0)
+        .name("start")
+        .build();
+    let center = gtk::Box::builder()
+        .orientation(orientation)
+        .spacing(0)
+        .name("center")
+        .build();
+    let end = gtk::Box::builder()
+        .orientation(orientation)
+        .spacing(0)
+        .name("end")
+        .build();
 
     content.style_context().add_class("container");
-    left.style_context().add_class("container");
+    start.style_context().add_class("container");
     center.style_context().add_class("container");
-    right.style_context().add_class("container");
+    end.style_context().add_class("container");
 
-    content.add(&left);
+    content.add(&start);
     content.set_center_widget(Some(&center));
-    content.pack_end(&right, false, false, 0);
+    content.pack_end(&end, false, false, 0);
 
-    load_modules(&left, &center, &right, app, config, monitor, monitor_name)?;
+    load_modules(&start, &center, &end, app, config, monitor, monitor_name)?;
     win.add(&content);
 
     win.connect_destroy_event(|_, _| {
+        info!("Shutting down");
         gtk::main_quit();
         Inhibit(false)
     });
 
+    debug!("Showing bar");
     win.show_all();
 
     Ok(())
 }
 
+/// Loads the configured modules onto a bar.
 fn load_modules(
     left: &gtk::Box,
     center: &gtk::Box,
@@ -59,71 +95,160 @@ fn load_modules(
     monitor: &Monitor,
     output_name: &str,
 ) -> Result<()> {
-    if let Some(modules) = config.left {
+    let mut info_builder = ModuleInfoBuilder::default();
-        let info = ModuleInfo {
+    let info_builder = info_builder
-            app,
+        .app(app)
-            location: ModuleLocation::Left,
+        .bar_position(config.position)
-            bar_position: &config.position,
+        .monitor(monitor)
-            monitor,
+        .output_name(output_name);
-            output_name,
-        };
 
-        add_modules(left, modules, &info)?;
+    if let Some(modules) = config.start {
+        let info_builder = info_builder.location(ModuleLocation::Left);
+
+        add_modules(left, modules, info_builder)?;
     }
 
     if let Some(modules) = config.center {
-        let info = ModuleInfo {
+        let info_builder = info_builder.location(ModuleLocation::Center);
-            app,
-            location: ModuleLocation::Center,
-            bar_position: &config.position,
-            monitor,
-            output_name,
-        };
 
-        add_modules(center, modules, &info)?;
+        add_modules(center, modules, info_builder)?;
     }
 
-    if let Some(modules) = config.right {
+    if let Some(modules) = config.end {
-        let info = ModuleInfo {
+        let info_builder = info_builder.location(ModuleLocation::Right);
-            app,
-            location: ModuleLocation::Right,
-            bar_position: &config.position,
-            monitor,
-            output_name,
-        };
 
-        add_modules(right, modules, &info)?;
+        add_modules(right, modules, info_builder)?;
     }
 
     Ok(())
 }
 
-fn add_modules(content: &gtk::Box, modules: Vec<ModuleConfig>, info: &ModuleInfo) -> Result<()> {
+/// Adds modules into a provided GTK box,
+/// which should be one of its left, center or right containers.
+fn add_modules(
+    content: &gtk::Box,
+    modules: Vec<ModuleConfig>,
+    info_builder: &mut ModuleInfoBuilder,
+) -> Result<()> {
+    let base_popup_info = info_builder.module_name("").build()?;
+    let popup = Popup::new(&base_popup_info);
+    let popup = Arc::new(RwLock::new(popup));
+
     macro_rules! add_module {
-        ($module:expr, $name:literal) => {{
+        ($module:expr, $id:expr, $name:literal, $send_message:ty, $receive_message:ty) => {
-            let widget = $module.into_widget(&info)?;
+            let info = info_builder.module_name($name).build()?;
-            widget.set_widget_name($name);
+
-            content.add(&widget);
+            let (w_tx, w_rx) = glib::MainContext::channel::<$send_message>(glib::PRIORITY_DEFAULT);
-        }};
+            let (p_tx, p_rx) = glib::MainContext::channel::<$send_message>(glib::PRIORITY_DEFAULT);
+
+            let channel = BridgeChannel::<ModuleUpdateEvent<$send_message>>::new();
+            let (ui_tx, ui_rx) = mpsc::channel::<$receive_message>(16);
+
+            $module.spawn_controller(&info, channel.create_sender(), ui_rx)?;
+
+            let context = WidgetContext {
+                id: $id,
+                widget_rx: w_rx,
+                popup_rx: p_rx,
+                tx: channel.create_sender(),
+                controller_tx: ui_tx,
+            };
+
+            let widget = $module.into_widget(context, &info)?;
+
+            content.add(&widget.widget);
+            widget.widget.set_widget_name(info.module_name);
+
+            let has_popup = widget.popup.is_some();
+            if let Some(popup_content) = widget.popup {
+                popup
+                    .write()
+                    .expect("Failed to get write lock on popup")
+                    .register_content($id, popup_content);
             }
 
-    for config in modules {
+            let popup2 = Arc::clone(&popup);
+            channel.recv(move |ev| {
+                let popup = popup2.clone();
+                match ev {
+                    ModuleUpdateEvent::Update(update) => {
+                        if has_popup {
+                            p_tx.send(update.clone())
+                                .expect("Failed to send update to popup");
+                        }
+
+                        w_tx.send(update).expect("Failed to send update to module");
+                    }
+                    ModuleUpdateEvent::TogglePopup(geometry) => {
+                        debug!("Toggling popup for {} [#{}]", $name, $id);
+                        let popup = popup.read().expect("Failed to get read lock on popup");
+                        if popup.is_visible() {
+                            popup.hide()
+                        } else {
+                            popup.show_content($id);
+                            popup.show(geometry);
+                        }
+                    }
+                    ModuleUpdateEvent::OpenPopup(geometry) => {
+                        debug!("Opening popup for {} [#{}]", $name, $id);
+
+                        let popup = popup.read().expect("Failed to get read lock on popup");
+                        popup.hide();
+                        popup.show_content($id);
+                        popup.show(geometry);
+                    }
+                    ModuleUpdateEvent::ClosePopup => {
+                        debug!("Closing popup for {} [#{}]", $name, $id);
+
+                        let popup = popup.read().expect("Failed to get read lock on popup");
+                        popup.hide();
+                    }
+                }
+
+                Continue(true)
+            });
+        };
+    }
+
+    for (id, config) in modules.into_iter().enumerate() {
         match config {
-            ModuleConfig::Clock(module) => add_module!(module, "clock"),
+            ModuleConfig::Clock(module) => {
-            ModuleConfig::Mpd(module) => add_module!(module, "mpd"),
+                add_module!(module, id, "clock", DateTime<Local>, ());
-            ModuleConfig::Tray(module) => add_module!(module, "tray"),
+            }
-            ModuleConfig::Workspaces(module) => add_module!(module, "workspaces"),
+            ModuleConfig::Script(module) => {
-            ModuleConfig::SysInfo(module) => add_module!(module, "sysinfo"),
+                add_module!(module, id, "script", String, ());
-            ModuleConfig::Launcher(module) => add_module!(module, "launcher"),
+            }
-            ModuleConfig::Script(module) => add_module!(module, "script"),
+            ModuleConfig::SysInfo(module) => {
-            ModuleConfig::Focused(module) => add_module!(module, "focused"),
+                add_module!(module, id, "sysinfo", HashMap<String, String>, ());
+            }
+            ModuleConfig::Focused(module) => {
+                add_module!(module, id, "focused", (String, String), ());
+            }
+            ModuleConfig::Workspaces(module) => {
+                add_module!(module, id, "workspaces", WorkspaceUpdate, String);
+            }
+            ModuleConfig::Tray(module) => {
+                add_module!(module, id, "tray", NotifierItemMessage, NotifierItemCommand);
+            }
+            ModuleConfig::Mpd(module) => {
+                add_module!(module, id, "mpd", Option<SongUpdate>, PlayerCommand);
+            }
+            ModuleConfig::Launcher(module) => {
+                add_module!(module, id, "launcher", LauncherUpdate, ItemEvent);
+            }
         }
     }
 
     Ok(())
 }
 
-fn setup_layer_shell(win: &ApplicationWindow, monitor: &Monitor, position: &BarPosition) {
+/// Sets up GTK layer shell for a provided application window.
+fn setup_layer_shell(
+    win: &ApplicationWindow,
+    monitor: &Monitor,
+    position: BarPosition,
+    anchor_to_edges: bool,
+) {
     gtk_layer_shell::init_for_window(win);
     gtk_layer_shell::set_monitor(win, monitor);
     gtk_layer_shell::set_layer(win, gtk_layer_shell::Layer::Top);
@@ -134,16 +259,30 @@ fn setup_layer_shell(win: &ApplicationWindow, monitor: &Monitor, position: &BarP
     gtk_layer_shell::set_margin(win, gtk_layer_shell::Edge::Left, 0);
     gtk_layer_shell::set_margin(win, gtk_layer_shell::Edge::Right, 0);
 
+    let bar_orientation = position.get_orientation();
+
     gtk_layer_shell::set_anchor(
         win,
         gtk_layer_shell::Edge::Top,
-        position == &BarPosition::Top,
+        position == BarPosition::Top
+            || (bar_orientation == Orientation::Vertical && anchor_to_edges),
     );
     gtk_layer_shell::set_anchor(
         win,
         gtk_layer_shell::Edge::Bottom,
-        position == &BarPosition::Bottom,
+        position == BarPosition::Bottom
+            || (bar_orientation == Orientation::Vertical && anchor_to_edges),
+    );
+    gtk_layer_shell::set_anchor(
+        win,
+        gtk_layer_shell::Edge::Left,
+        position == BarPosition::Left
+            || (bar_orientation == Orientation::Horizontal && anchor_to_edges),
+    );
+    gtk_layer_shell::set_anchor(
+        win,
+        gtk_layer_shell::Edge::Right,
+        position == BarPosition::Right
+            || (bar_orientation == Orientation::Horizontal && anchor_to_edges),
     );
-    gtk_layer_shell::set_anchor(win, gtk_layer_shell::Edge::Left, true);
-    gtk_layer_shell::set_anchor(win, gtk_layer_shell::Edge::Right, true);
 }

src/bridge_channel.rs

@@ -0,0 +1,43 @@
+use tokio::spawn;
+use tokio::sync::mpsc;
+
+/// MPSC async -> sync channel.
+/// The sender uses `tokio::sync::mpsc`
+/// while the receiver uses `glib::MainContext::channel`.
+///
+/// This makes it possible to send events asynchronously
+/// and receive them on the main thread,
+/// allowing UI updates to be handled on the receiving end.
+pub struct BridgeChannel<T> {
+    async_tx: mpsc::Sender<T>,
+    sync_rx: glib::Receiver<T>,
+}
+
+impl<T: Send + 'static> BridgeChannel<T> {
+    /// Creates a new channel
+    pub fn new() -> Self {
+        let (async_tx, mut async_rx) = mpsc::channel(32);
+        let (sync_tx, sync_rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
+
+        spawn(async move {
+            while let Some(val) = async_rx.recv().await {
+                sync_tx.send(val).expect("Failed to send message");
+            }
+        });
+
+        Self { async_tx, sync_rx }
+    }
+
+    /// Gets a clone of the sender.
+    pub fn create_sender(&self) -> mpsc::Sender<T> {
+        self.async_tx.clone()
+    }
+
+    /// Attaches a callback to the receiver.
+    pub fn recv<F>(self, f: F) -> glib::SourceId
+    where
+        F: FnMut(T) -> glib::Continue + 'static,
+    {
+        self.sync_rx.attach(None, f)
+    }
+}

src/collection.rs

@@ -1,5 +1,6 @@
 use serde::Serialize;
 use std::slice::{Iter, IterMut};
+use std::vec;
 
 /// An ordered map.
 /// Internally this is just two vectors -
@@ -11,6 +12,7 @@ pub struct Collection<TKey, TData> {
 }
 
 impl<TKey: PartialEq, TData> Collection<TKey, TData> {
+    /// Creates a new empty collection.
     pub const fn new() -> Self {
         Self {
             keys: vec![],
@@ -18,6 +20,7 @@ impl<TKey: PartialEq, TData> Collection<TKey, TData> {
         }
     }
 
+    /// Inserts a new key/value pair at the end of the collection.
     pub fn insert(&mut self, key: TKey, value: TData) {
         self.keys.push(key);
         self.values.push(value);
@@ -25,6 +28,8 @@ impl<TKey: PartialEq, TData> Collection<TKey, TData> {
         assert_eq!(self.keys.len(), self.values.len());
     }
 
+    /// Gets a reference of the value for the specified key
+    /// if it exists in the collection.
     pub fn get(&self, key: &TKey) -> Option<&TData> {
         let index = self.keys.iter().position(|k| k == key);
         match index {
@@ -33,6 +38,8 @@ impl<TKey: PartialEq, TData> Collection<TKey, TData> {
         }
     }
 
+    /// Gets a mutable reference for the value with the specified key
+    /// if it exists in the collection.
     pub fn get_mut(&mut self, key: &TKey) -> Option<&mut TData> {
         let index = self.keys.iter().position(|k| k == key);
         match index {
@@ -41,6 +48,14 @@ impl<TKey: PartialEq, TData> Collection<TKey, TData> {
         }
     }
 
+    /// Checks if a value for the given key exists inside the collection
+    pub fn contains(&self, key: &TKey) -> bool {
+        self.keys.contains(key)
+    }
+
+    /// Removes the key/value from the collection
+    /// if it exists
+    /// and returns the removed value.
     pub fn remove(&mut self, key: &TKey) -> Option<TData> {
         assert_eq!(self.keys.len(), self.values.len());
 
@@ -53,26 +68,32 @@ impl<TKey: PartialEq, TData> Collection<TKey, TData> {
         }
     }
 
+    /// Gets the length of the collection.
     pub fn len(&self) -> usize {
         self.keys.len()
     }
 
+    /// Gets a reference to the first value in the collection.
     pub fn first(&self) -> Option<&TData> {
         self.values.first()
     }
 
+    /// Gets the values as a slice.
     pub fn as_slice(&self) -> &[TData] {
         self.values.as_slice()
     }
 
+    /// Checks whether the collection is empty.
     pub fn is_empty(&self) -> bool {
         self.keys.is_empty()
     }
 
+    /// Gets an iterator for the collection.
     pub fn iter(&self) -> Iter<'_, TData> {
         self.values.iter()
     }
 
+    /// Gets a mutable iterator for the collection
     pub fn iter_mut(&mut self) -> IterMut<'_, TData> {
         self.values.iter_mut()
     }
@@ -129,3 +150,12 @@ impl<TKey: PartialEq, TData> Default for Collection<TKey, TData> {
         Self::new()
     }
 }
+
+impl<TKey: PartialEq, TData> IntoIterator for Collection<TKey, TData> {
+    type Item = TData;
+    type IntoIter = vec::IntoIter<TData>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.values.into_iter()
+    }
+}

src/config.rs

@@ -10,6 +10,7 @@ use color_eyre::eyre::{Context, ContextCompat};
 use color_eyre::{eyre, Help, Report};
 use dirs::config_dir;
 use eyre::Result;
+use gtk::Orientation;
 use serde::Deserialize;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
@@ -35,11 +36,13 @@ pub enum MonitorConfig {
     Multiple(Vec<Config>),
 }
 
-#[derive(Debug, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Deserialize, Copy, Clone, PartialEq, Eq)]
 #[serde(rename_all = "kebab-case")]
 pub enum BarPosition {
     Top,
     Bottom,
+    Left,
+    Right,
 }
 
 impl Default for BarPosition {
@@ -48,16 +51,36 @@ impl Default for BarPosition {
     }
 }
 
+impl BarPosition {
+    pub fn get_orientation(self) -> Orientation {
+        if self == Self::Top || self == Self::Bottom {
+            Orientation::Horizontal
+        } else {
+            Orientation::Vertical
+        }
+    }
+
+    pub const fn get_angle(self) -> f64 {
+        match self {
+            Self::Top | Self::Bottom => 0.0,
+            Self::Left => 90.0,
+            Self::Right => 270.0,
+        }
+    }
+}
+
 #[derive(Debug, Deserialize, Clone, Default)]
 pub struct Config {
     #[serde(default = "default_bar_position")]
     pub position: BarPosition,
+    #[serde(default = "default_true")]
+    pub anchor_to_edges: bool,
     #[serde(default = "default_bar_height")]
     pub height: i32,
 
-    pub left: Option<Vec<ModuleConfig>>,
+    pub start: Option<Vec<ModuleConfig>>,
     pub center: Option<Vec<ModuleConfig>>,
-    pub right: Option<Vec<ModuleConfig>>,
+    pub end: Option<Vec<ModuleConfig>>,
 
     pub monitors: Option<HashMap<String, MonitorConfig>>,
 }
@@ -71,6 +94,8 @@ const fn default_bar_height() -> i32 {
 }
 
 impl Config {
+    /// Attempts to load the config file from file,
+    /// parse it and return a new instance of `Self`.
     pub fn load() -> Result<Self> {
         let config_path = if let Ok(config_path) = env::var("IRONBAR_CONFIG") {
             let path = PathBuf::from(config_path);
@@ -87,6 +112,10 @@ impl Config {
         Self::load_file(&config_path)
     }
 
+    /// Attempts to discover the location of the config file
+    /// by checking each valid format's extension.
+    ///
+    /// Returns the path of the first valid match, if any.
     fn try_find_config() -> Result<PathBuf> {
         let config_dir = config_dir().wrap_err("Failed to locate user config dir")?;
 
@@ -110,6 +139,8 @@ impl Config {
         }
     }
 
+    /// Loads the config file at the specified path
+    /// and parses it into `Self` based on its extension.
     fn load_file(path: &Path) -> Result<Self> {
         let file = fs::read(path).wrap_err("Failed to read config file")?;
         let extension = path

src/icon.rs

@@ -86,6 +86,10 @@ enum IconLocation {
     File(PathBuf),
 }
 
+/// Attempts to get the location of an icon.
+///
+/// Handles icons that are part of a GTK theme, icons specified as path
+/// and icons for steam games.
 fn get_icon_location(theme: &IconTheme, app_id: &str, size: i32) -> Option<IconLocation> {
     let has_icon = theme
         .lookup_icon(app_id, size, IconLookupFlags::empty())

src/logging.rs

@@ -26,6 +26,10 @@ impl<'a> MakeWriter<'a> for MakeFileWriter {
     }
 }
 
+/// Installs tracing into the current application.
+///
+/// The returned `WorkerGuard` must remain in scope
+/// for the lifetime of the application for logging to file to work.
 pub fn install_tracing() -> Result<WorkerGuard> {
     let fmt_layer = fmt::layer().with_target(true);
     let filter_layer = EnvFilter::try_from_default_env().or_else(|_| EnvFilter::try_new("info"))?;

src/main.rs

@@ -1,4 +1,5 @@
 mod bar;
+mod bridge_channel;
 mod collection;
 mod config;
 mod icon;
@@ -7,24 +8,26 @@ mod modules;
 mod popup;
 mod style;
 mod sway;
+mod wayland;
 
 use crate::bar::create_bar;
 use crate::config::{Config, MonitorConfig};
 use crate::style::load_css;
-use crate::sway::{get_client_error, SwayOutput};
 use color_eyre::eyre::Result;
 use color_eyre::Report;
 use dirs::config_dir;
 use gtk::gdk::Display;
 use gtk::prelude::*;
 use gtk::Application;
-use ksway::client::Client;
-use ksway::IpcCommand;
 use std::env;
+use std::future::Future;
 use std::process::exit;
+use tokio::runtime::Handle;
+use tokio::task::block_in_place;
 
 use crate::logging::install_tracing;
 use tracing::{debug, error, info};
+use wayland::WaylandClient;
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
@@ -44,19 +47,21 @@ async fn main() -> Result<()> {
     info!("Ironbar version {}", VERSION);
     info!("Starting application");
 
+    let wayland_client = wayland::get_client().await;
+
     let app = Application::builder()
         .application_id("dev.jstanger.ironbar")
         .build();
 
     app.connect_activate(move |app| {
-        let display = match Display::default() {
+        let display = Display::default().map_or_else(
-            Some(display) => display,
+            || {
-            None => {
                 let report = Report::msg("Failed to get default GTK display");
                 error!("{:?}", report);
                 exit(1)
-            }
+            },
-        };
+            |display| display,
+        );
 
         let config = match Config::load() {
             Ok(config) => config,
@@ -67,21 +72,21 @@ async fn main() -> Result<()> {
         };
         debug!("Loaded config file");
 
-        if let Err(err) = create_bars(app, &display, &config) {
+        if let Err(err) = create_bars(app, &display, wayland_client, &config) {
             error!("{:?}", err);
             exit(2);
         }
 
         debug!("Created bars");
 
-        let style_path = match config_dir() {
+        let style_path = config_dir().map_or_else(
-            Some(dir) => dir.join("ironbar").join("style.css"),
+            || {
-            None => {
                 let report = Report::msg("Failed to locate user config dir");
                 error!("{:?}", report);
                 exit(3);
-            }
+            },
-        };
+            |dir| dir.join("ironbar").join("style.css"),
+        );
 
         if style_path.exists() {
             load_css(style_path);
@@ -96,35 +101,38 @@ async fn main() -> Result<()> {
     Ok(())
 }
 
-fn create_bars(app: &Application, display: &Display, config: &Config) -> Result<()> {
+/// Creates each of the bars across each of the (configured) outputs.
-    let mut sway_client = match Client::connect() {
+fn create_bars(
-        Ok(client) => Ok(client),
+    app: &Application,
-        Err(err) => Err(get_client_error(err)),
+    display: &Display,
-    }?;
+    wl: &WaylandClient,
+    config: &Config,
+) -> Result<()> {
+    let outputs = wl.outputs.as_slice();
 
-    let outputs = match sway_client.ipc(IpcCommand::GetOutputs) {
+    debug!("Received {} outputs from Wayland", outputs.len());
-        Ok(outputs) => Ok(outputs),
+    debug!("Output names: {:?}", outputs);
-        Err(err) => Err(get_client_error(err)),
-    }?;
-
-    let outputs = serde_json::from_slice::<Vec<SwayOutput>>(&outputs)?;
 
     let num_monitors = display.n_monitors();
 
     for i in 0..num_monitors {
-        let monitor = display.monitor(i).ok_or_else(|| Report::msg("GTK and Sway are reporting a different number of outputs - this is a severe bug and should never happen"))?;
+        let monitor = display.monitor(i).ok_or_else(|| Report::msg("GTK and Sway are reporting a different set of outputs - this is a severe bug and should never happen"))?;
-        let monitor_name = &outputs.get(i as usize).ok_or_else(|| Report::msg("GTK and Sway are reporting a different set of outputs - this is a severe bug and should never happen"))?.name;
+        let output = outputs.get(i as usize).ok_or_else(|| Report::msg("GTK and Sway are reporting a different set of outputs - this is a severe bug and should never happen"))?;
+        let monitor_name = &output.name;
 
+        // TODO: Could we use an Arc<Config> or `Cow<Config>` here to avoid cloning?
         config.monitors.as_ref().map_or_else(
             || create_bar(app, &monitor, monitor_name, config.clone()),
             |config| {
                 let config = config.get(monitor_name);
                 match &config {
                     Some(MonitorConfig::Single(config)) => {
+                        info!("Creating bar on '{}'", monitor_name);
                         create_bar(app, &monitor, monitor_name, config.clone())
                     }
                     Some(MonitorConfig::Multiple(configs)) => {
                         for config in configs {
+                            info!("Creating bar on '{}'", monitor_name);
                             create_bar(app, &monitor, monitor_name, config.clone())?;
                         }
 
@@ -138,3 +146,15 @@ fn create_bars(app: &Application, display: &Display, config: &Config) -> Result<
 
     Ok(())
 }
+
+/// Blocks on a `Future` until it resolves.
+///
+/// This is not an `async` operation
+/// so can be used outside of an async function.
+///
+/// Do note it must be called from within a Tokio runtime still.
+///
+/// Use sparingly! Prefer async functions wherever possible.
+pub fn await_sync<F: Future>(f: F) -> F::Output {
+    block_in_place(|| Handle::current().block_on(f))
+}

src/modules/clock.rs

@@ -0,0 +1,120 @@
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::popup::Popup;
+use chrono::{DateTime, Local};
+use color_eyre::Result;
+use glib::Continue;
+use gtk::prelude::*;
+use gtk::{Align, Button, Calendar, Label, Orientation};
+use serde::Deserialize;
+use tokio::spawn;
+use tokio::sync::mpsc;
+use tokio::time::sleep;
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct ClockModule {
+    /// Date/time format string.
+    /// Default: `%d/%m/%Y %H:%M`
+    ///
+    /// Detail on available tokens can be found here:
+    /// <https://docs.rs/chrono/latest/chrono/format/strftime/index.html>
+    #[serde(default = "default_format")]
+    pub(crate) format: String,
+}
+
+fn default_format() -> String {
+    String::from("%d/%m/%Y %H:%M")
+}
+
+impl Module<Button> for ClockModule {
+    type SendMessage = DateTime<Local>;
+    type ReceiveMessage = ();
+
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: mpsc::Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        _rx: mpsc::Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        spawn(async move {
+            loop {
+                let date = Local::now();
+                tx.send(ModuleUpdateEvent::Update(date))
+                    .await
+                    .expect("Failed to send date");
+                sleep(tokio::time::Duration::from_millis(500)).await;
+            }
+        });
+
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<Button>> {
+        let button = Button::new();
+        let label = Label::new(None);
+        label.set_angle(info.bar_position.get_angle());
+        button.add(&label);
+
+        let orientation = info.bar_position.get_orientation();
+        button.connect_clicked(move |button| {
+            context
+                .tx
+                .try_send(ModuleUpdateEvent::TogglePopup(Popup::button_pos(
+                    button,
+                    orientation,
+                )))
+                .expect("Failed to toggle popup");
+        });
+
+        let format = self.format.clone();
+        {
+            context.widget_rx.attach(None, move |date| {
+                let date_string = format!("{}", date.format(&format));
+                label.set_label(&date_string);
+                Continue(true)
+            });
+        }
+
+        let popup = self.into_popup(context.controller_tx, context.popup_rx);
+
+        Ok(ModuleWidget {
+            widget: button,
+            popup,
+        })
+    }
+
+    fn into_popup(
+        self,
+        _tx: mpsc::Sender<Self::ReceiveMessage>,
+        rx: glib::Receiver<Self::SendMessage>,
+    ) -> Option<gtk::Box> {
+        let container = gtk::Box::builder()
+            .orientation(Orientation::Vertical)
+            .name("popup-clock")
+            .build();
+
+        let clock = Label::builder()
+            .name("calendar-clock")
+            .halign(Align::Center)
+            .build();
+        let format = "%H:%M:%S";
+
+        container.add(&clock);
+
+        let calendar = Calendar::builder().name("calendar").build();
+        container.add(&calendar);
+
+        {
+            rx.attach(None, move |date| {
+                let date_string = format!("{}", date.format(format));
+                clock.set_label(&date_string);
+                Continue(true)
+            });
+        }
+
+        Some(container)
+    }
+}

src/modules/clock/mod.rs

@@ -1,71 +0,0 @@
-mod popup;
-
-use self::popup::Popup;
-use crate::modules::{Module, ModuleInfo};
-use chrono::Local;
-use color_eyre::Result;
-use glib::Continue;
-use gtk::prelude::*;
-use gtk::{Button, Orientation};
-use serde::Deserialize;
-use tokio::spawn;
-use tokio::time::sleep;
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct ClockModule {
-    /// Date/time format string.
-    /// Default: `%d/%m/%Y %H:%M`
-    ///
-    /// Detail on available tokens can be found here:
-    /// <https://docs.rs/chrono/latest/chrono/format/strftime/index.html>
-    #[serde(default = "default_format")]
-    pub(crate) format: String,
-}
-
-fn default_format() -> String {
-    String::from("%d/%m/%Y %H:%M")
-}
-
-impl Module<Button> for ClockModule {
-    fn into_widget(self, info: &ModuleInfo) -> Result<Button> {
-        let button = Button::new();
-
-        let popup = Popup::new(
-            "popup-clock",
-            info.app,
-            info.monitor,
-            Orientation::Vertical,
-            info.bar_position,
-        );
-        popup.add_clock_widgets();
-
-        button.show_all();
-
-        button.connect_clicked(move |button| {
-            popup.show(button);
-        });
-
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-        spawn(async move {
-            let format = self.format.as_str();
-            loop {
-                let date = Local::now();
-                let date_string = format!("{}", date.format(format));
-
-                tx.send(date_string).expect("Failed to send date string");
-
-                sleep(tokio::time::Duration::from_millis(500)).await;
-            }
-        });
-
-        {
-            let button = button.clone();
-            rx.attach(None, move |s| {
-                button.set_label(s.as_str());
-                Continue(true)
-            });
-        }
-
-        Ok(button)
-    }
-}

src/modules/clock/popup.rs

@@ -1,40 +0,0 @@
-pub use crate::popup::Popup;
-use chrono::Local;
-use gtk::prelude::*;
-use gtk::{Align, Calendar, Label};
-use tokio::spawn;
-use tokio::time::sleep;
-
-impl Popup {
-    pub fn add_clock_widgets(&self) {
-        let clock = Label::builder()
-            .name("calendar-clock")
-            .halign(Align::Center)
-            .build();
-        let format = "%H:%M:%S";
-
-        self.container.add(&clock);
-
-        let calendar = Calendar::builder().name("calendar").build();
-        self.container.add(&calendar);
-
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-        spawn(async move {
-            loop {
-                let date = Local::now();
-                let date_string = format!("{}", date.format(format));
-
-                tx.send(date_string).expect("Failed to send date string");
-
-                sleep(tokio::time::Duration::from_millis(500)).await;
-            }
-        });
-
-        {
-            rx.attach(None, move |s| {
-                clock.set_label(s.as_str());
-                Continue(true)
-            });
-        }
-    }
-}

src/modules/focused.rs

@@ -1,24 +1,27 @@
-use crate::icon;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::modules::{Module, ModuleInfo};
+use crate::wayland::ToplevelChange;
-use crate::sway::{SwayClient, WindowEvent};
+use crate::{await_sync, icon, wayland};
 use color_eyre::Result;
 use glib::Continue;
 use gtk::prelude::*;
-use gtk::{IconTheme, Image, Label, Orientation};
+use gtk::{IconTheme, Image, Label};
-use ksway::IpcEvent;
 use serde::Deserialize;
-use tokio::task::spawn_blocking;
+use tokio::spawn;
-use tracing::error;
+use tokio::sync::mpsc::{Receiver, Sender};
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct FocusedModule {
+    /// Whether to show icon on the bar.
     #[serde(default = "crate::config::default_true")]
     show_icon: bool,
+    /// Whether to show app name on the bar.
     #[serde(default = "crate::config::default_true")]
     show_title: bool,
 
+    /// Icon size in pixels.
     #[serde(default = "default_icon_size")]
     icon_size: i32,
+    /// GTK icon theme to use.
     icon_theme: Option<String>,
 }
 
@@ -27,14 +30,69 @@ const fn default_icon_size() -> i32 {
 }
 
 impl Module<gtk::Box> for FocusedModule {
-    fn into_widget(self, _info: &ModuleInfo) -> Result<gtk::Box> {
+    type SendMessage = (String, String);
+    type ReceiveMessage = ();
+
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        _rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        let focused = await_sync(async {
+            let wl = wayland::get_client().await;
+            let toplevels = wl
+                .toplevels
+                .read()
+                .expect("Failed to get read lock on toplevels")
+                .clone();
+
+            toplevels.into_iter().find(|(top, _)| top.active)
+        });
+
+        if let Some((top, _)) = focused {
+            tx.try_send(ModuleUpdateEvent::Update((top.title.clone(), top.app_id)))?;
+        }
+
+        spawn(async move {
+            let mut wlrx = {
+                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,
+                };
+
+                if update {
+                    tx.send(ModuleUpdateEvent::Update((
+                        event.toplevel.title,
+                        event.toplevel.app_id,
+                    )))
+                    .await
+                    .expect("Failed to send focus update");
+                }
+            }
+        });
+
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<gtk::Box>> {
         let icon_theme = IconTheme::new();
 
         if let Some(theme) = self.icon_theme {
             icon_theme.set_custom_theme(Some(&theme));
         }
 
-        let container = gtk::Box::new(Orientation::Horizontal, 5);
+        let container = gtk::Box::new(info.bar_position.get_orientation(), 5);
 
         let icon = Image::builder().name("icon").build();
         let label = Label::builder().name("label").build();
@@ -42,62 +100,25 @@ impl Module<gtk::Box> for FocusedModule {
         container.add(&icon);
         container.add(&label);
 
-        let mut sway = SwayClient::connect()?;
-
-        let srx = sway.subscribe(vec![IpcEvent::Window])?;
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-
-        let focused = sway
-            .get_open_windows()?
-            .into_iter()
-            .find(|node| node.focused);
-
-        if let Some(focused) = focused {
-            tx.send(focused)?;
-        }
-
-        spawn_blocking(move || loop {
-            while let Ok((_, payload)) = srx.try_recv() {
-                match serde_json::from_slice::<WindowEvent>(&payload) {
-                    Ok(payload) => {
-                        let update = match payload.change.as_str() {
-                            "focus" => true,
-                            "title" => payload.container.focused,
-                            _ => false,
-                        };
-
-                        if update {
-                            tx.send(payload.container)
-                                .expect("Failed to sendf focus update");
-                        }
-                    }
-                    Err(err) => error!("{:?}", err),
-                }
-            }
-
-            if let Err(err) = sway.poll() {
-                error!("{:?}", err);
-            }
-        });
-
         {
-            rx.attach(None, move |node| {
+            context.widget_rx.attach(None, move |(name, id)| {
-                let value = node.name.as_deref().unwrap_or_else(|| node.get_id());
+                let pixbuf = icon::get_icon(&icon_theme, &id, self.icon_size);
-
-                let pixbuf = icon::get_icon(&icon_theme, node.get_id(), self.icon_size);
 
                 if self.show_icon {
                     icon.set_pixbuf(pixbuf.as_ref());
                 }
 
                 if self.show_title {
-                    label.set_label(value);
+                    label.set_label(&name);
                 }
 
                 Continue(true)
             });
         }
 
-        Ok(container)
+        Ok(ModuleWidget {
+            widget: container,
+            popup: None,
+        })
     }
 }

src/modules/launcher/item.rs

@@ -1,287 +1,258 @@
+use super::open_state::OpenState;
 use crate::collection::Collection;
-use crate::icon::{find_desktop_file, get_icon};
+use crate::icon::get_icon;
-use crate::modules::launcher::popup::Popup;
+use crate::modules::launcher::{ItemEvent, LauncherUpdate};
-use crate::modules::launcher::FocusEvent;
+use crate::modules::ModuleUpdateEvent;
-use crate::sway::SwayNode;
+use crate::popup::Popup;
-use crate::Report;
+use crate::wayland::ToplevelInfo;
-use color_eyre::Help;
 use gtk::prelude::*;
-use gtk::{Button, IconTheme, Image};
+use gtk::{Button, IconTheme, Image, Orientation};
-use std::process::{Command, Stdio};
 use std::rc::Rc;
-use std::sync::{Arc, Mutex, RwLock};
+use std::sync::RwLock;
-use tokio::spawn;
+use tokio::sync::mpsc::Sender;
-use tokio::sync::mpsc;
-use tracing::error;
 
 #[derive(Debug, Clone)]
-pub struct LauncherItem {
+pub struct Item {
     pub app_id: String,
     pub favorite: bool,
-    pub windows: Rc<Mutex<Collection<i32, LauncherWindow>>>,
+    pub open_state: OpenState,
-    pub state: Arc<RwLock<State>>,
+    pub windows: Collection<usize, Window>,
-    pub button: Button,
+    pub name: String,
 }
 
-#[derive(Debug, Clone)]
+impl Item {
-pub struct LauncherWindow {
+    pub const fn new(app_id: String, open_state: OpenState, favorite: bool) -> Self {
-    pub con_id: i32,
+        Self {
-    pub name: Option<String>,
+            app_id,
-}
+            favorite,
-
+            open_state,
-#[derive(Debug, Clone, Eq, PartialEq)]
+            windows: Collection::new(),
-pub enum OpenState {
+            name: String::new(),
-    Closed,
-    Open,
-    Focused,
-    Urgent,
-}
-
-impl OpenState {
-    pub const fn from_node(node: &SwayNode) -> Self {
-        if node.focused {
-            Self::Urgent
-        } else if node.urgent {
-            Self::Focused
-        } else {
-            Self::Open
         }
     }
 
-    pub fn highest_of(a: &Self, b: &Self) -> Self {
+    /// Merges the provided node into this launcher item
-        if a == &Self::Urgent || b == &Self::Urgent {
+    pub fn merge_toplevel(&mut self, node: ToplevelInfo) -> Window {
-            Self::Urgent
+        let id = node.id;
-        } else if a == &Self::Focused || b == &Self::Focused {
+
-            Self::Focused
+        if self.windows.is_empty() {
-        } else if a == &Self::Open || b == &Self::Open {
+            self.name = node.title.clone();
-            Self::Open
+        }
-        } else {
+
-            Self::Closed
+        let window: Window = node.into();
+        self.windows.insert(id, window.clone());
+
+        self.recalculate_open_state();
+
+        window
+    }
+
+    pub fn unmerge_toplevel(&mut self, node: &ToplevelInfo) {
+        self.windows.remove(&node.id);
+        self.recalculate_open_state();
+    }
+
+    pub fn set_window_name(&mut self, window_id: usize, name: String) {
+        if let Some(window) = self.windows.get_mut(&window_id) {
+            if let OpenState::Open { focused: true, .. } = window.open_state {
+                self.name = name.clone();
+            }
+
+            window.name = name;
+        }
+    }
+
+    pub fn set_window_focused(&mut self, window_id: usize, focused: bool) {
+        if let Some(window) = self.windows.get_mut(&window_id) {
+            window.open_state =
+                OpenState::merge_states(&[&window.open_state, &OpenState::focused(focused)]);
+
+            self.recalculate_open_state();
+        }
+    }
+
+    /// Sets this item's open state
+    /// to the merged result of its windows' open states
+    fn recalculate_open_state(&mut self) {
+        let new_state = OpenState::merge_states(
+            &self
+                .windows
+                .iter()
+                .map(|win| &win.open_state)
+                .collect::<Vec<_>>(),
+        );
+        self.open_state = new_state;
+    }
+}
+
+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();
+
+        let mut windows = Collection::new();
+        windows.insert(toplevel.id, toplevel.into());
+
+        Self {
+            app_id,
+            favorite: false,
+            open_state,
+            windows,
+            name,
         }
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug)]
-pub struct State {
+pub struct Window {
-    pub is_xwayland: bool,
+    pub id: usize,
+    pub name: String,
     pub open_state: OpenState,
 }
 
-#[derive(Debug, Clone)]
+impl From<ToplevelInfo> for Window {
-pub struct ButtonConfig {
+    fn from(node: ToplevelInfo) -> Self {
-    pub icon_theme: IconTheme,
+        let open_state = OpenState::from_toplevel(&node);
+
+        Self {
+            id: node.id,
+            name: node.title,
+            open_state,
+        }
+    }
+}
+
+pub struct MenuState {
+    pub num_windows: usize,
+}
+
+pub struct ItemButton {
+    pub button: Button,
+    pub persistent: bool,
     pub show_names: bool,
-    pub show_icons: bool,
+    pub menu_state: Rc<RwLock<MenuState>>,
-    pub popup: Popup,
-    pub tx: mpsc::Sender<FocusEvent>,
 }
 
-impl LauncherItem {
+impl ItemButton {
-    pub fn new(app_id: String, favorite: bool, config: &ButtonConfig) -> Self {
+    pub fn new(
-        let button = Button::new();
+        item: &Item,
-        button.style_context().add_class("item");
+        show_names: bool,
+        show_icons: bool,
+        orientation: Orientation,
+        icon_theme: &IconTheme,
+        tx: &Sender<ModuleUpdateEvent<LauncherUpdate>>,
+        controller_tx: &Sender<ItemEvent>,
+    ) -> Self {
+        let mut button = Button::builder();
 
-        let state = State {
+        if show_names {
-            open_state: OpenState::Closed,
+            button = button.label(&item.name);
-            is_xwayland: false,
-        };
-
-        let item = Self {
-            app_id,
-            favorite,
-            windows: Rc::new(Mutex::new(Collection::new())),
-            state: Arc::new(RwLock::new(state)),
-            button,
-        };
-
-        item.configure_button(config);
-        item
         }
 
-    pub fn from_node(node: &SwayNode, config: &ButtonConfig) -> Self {
+        if show_icons {
-        let button = Button::new();
+            let icon = get_icon(icon_theme, &item.app_id, 32);
-        button.style_context().add_class("item");
-
-        let windows = Collection::from((
-            node.id,
-            LauncherWindow {
-                con_id: node.id,
-                name: node.name.clone(),
-            },
-        ));
-
-        let state = State {
-            open_state: OpenState::from_node(node),
-            is_xwayland: node.is_xwayland(),
-        };
-
-        let item = Self {
-            app_id: node.get_id().to_string(),
-            favorite: false,
-            windows: Rc::new(Mutex::new(windows)),
-            state: Arc::new(RwLock::new(state)),
-            button,
-        };
-
-        item.configure_button(config);
-        item
-    }
-
-    fn configure_button(&self, config: &ButtonConfig) {
-        let button = &self.button;
-
-        let windows = self.windows.lock().expect("Failed to get lock on windows");
-
-        let name = if windows.len() == 1 {
-            windows
-                .first()
-                .expect("Failed to get first window")
-                .name
-                .as_ref()
-        } else {
-            Some(&self.app_id)
-        };
-
-        if let Some(name) = name {
-            self.set_title(name, config);
-        }
-
-        if config.show_icons {
-            let icon = get_icon(&config.icon_theme, &self.app_id, 32);
             if icon.is_some() {
                 let image = Image::from_pixbuf(icon.as_ref());
-                button.set_image(Some(&image));
+                button = button.image(&image).always_show_image(true);
-                button.set_always_show_image(true);
             }
         }
 
-        let app_id = self.app_id.clone();
+        let button = button.build();
-        let state = Arc::clone(&self.state);
-        let tx_click = config.tx.clone();
 
-        let (focus_tx, mut focus_rx) = mpsc::channel(32);
+        let style_context = button.style_context();
+        style_context.add_class("item");
+
+        if item.favorite {
+            style_context.add_class("favorite");
+        }
+        if item.open_state.is_open() {
+            style_context.add_class("open");
+        }
+        if item.open_state.is_focused() {
+            style_context.add_class("focused");
+        }
 
-        button.connect_clicked(move |_| {
-            let state = state.read().expect("Failed to get read lock on state");
-            if state.open_state == OpenState::Open {
-                focus_tx.try_send(()).expect("Failed to send focus event");
-            } else {
-                // attempt to find desktop file and launch
-                match find_desktop_file(&app_id) {
-                    Some(file) => {
-                        if let Err(err) = Command::new("gtk-launch")
-                            .arg(
-                                file.file_name()
-                                    .expect("File segment missing from path to desktop file"),
-                            )
-                            .stdout(Stdio::null())
-                            .stderr(Stdio::null())
-                            .spawn()
         {
-                            error!(
+            let app_id = item.app_id.clone();
-                                "{:?}",
+            let tx = controller_tx.clone();
-                                Report::new(err)
+            button.connect_clicked(move |button| {
-                                    .wrap_err("Failed to run gtk-launch command.")
+                // lazy check :|
-                                    .suggestion("Perhaps the desktop file is invalid?")
+                let style_context = button.style_context();
-                            );
+                if style_context.has_class("open") {
-                        }
+                    tx.try_send(ItemEvent::FocusItem(app_id.clone()))
-                    }
+                        .expect("Failed to send item focus event");
-                    None => error!("Could not find desktop file for {}", app_id),
-                }
-            }
-        });
-
-        let app_id = self.app_id.clone();
-        let state = Arc::clone(&self.state);
-
-        spawn(async move {
-            while focus_rx.recv().await == Some(()) {
-                let state = state.read().expect("Failed to get read lock on state");
-                if state.is_xwayland {
-                    tx_click
-                        .try_send(FocusEvent::Class(app_id.clone()))
-                        .expect("Failed to send focus event");
                 } else {
-                    tx_click
+                    tx.try_send(ItemEvent::OpenItem(app_id.clone()))
-                        .try_send(FocusEvent::AppId(app_id.clone()))
+                        .expect("Failed to send item open event");
-                        .expect("Failed to send focus event");
-                }
                 }
             });
+        }
 
-        let popup = config.popup.clone();
+        let menu_state = Rc::new(RwLock::new(MenuState {
-        let popup2 = config.popup.clone();
+            num_windows: item.windows.len(),
-        let windows = Rc::clone(&self.windows);
+        }));
-        let tx_hover = config.tx.clone();
+
+        {
+            let app_id = item.app_id.clone();
+            let tx = tx.clone();
+            let menu_state = menu_state.clone();
 
             button.connect_enter_notify_event(move |button, _| {
-            let windows = windows.lock().expect("Failed to get lock on windows");
+                let menu_state = menu_state
-            if windows.len() > 1 {
+                    .read()
-                popup.set_windows(windows.as_slice(), &tx_hover);
+                    .expect("Failed to get read lock on item menu state");
-                popup.show(button);
+
+                if menu_state.num_windows > 1 {
+                    tx.try_send(ModuleUpdateEvent::Update(LauncherUpdate::Hover(
+                        app_id.clone(),
+                    )))
+                    .expect("Failed to send item open popup event");
+
+                    tx.try_send(ModuleUpdateEvent::OpenPopup(Popup::button_pos(
+                        button,
+                        orientation,
+                    )))
+                    .expect("Failed to send item open popup event");
+                } else {
+                    tx.try_send(ModuleUpdateEvent::ClosePopup)
+                        .expect("Failed to send item close popup event");
                 }
 
                 Inhibit(false)
             });
-
-        {}
-
-        button.connect_leave_notify_event(move |_, e| {
-            let (_, y) = e.position();
-            // hover boundary
-            if y > 2.0 {
-                popup2.hide();
         }
 
-            Inhibit(false)
-        });
-
-        let style = button.style_context();
-
-        style.add_class("launcher-item");
-        self.update_button_classes(&self.state.read().expect("Failed to get read lock on state"));
-
         button.show_all();
+
+        Self {
+            button,
+            persistent: item.favorite,
+            show_names,
+            menu_state,
+        }
     }
 
-    pub fn set_title(&self, title: &str, config: &ButtonConfig) {
+    pub fn set_open(&self, open: bool) {
-        if config.show_names {
+        self.update_class("open", open);
-            self.button.set_label(title);
+
+        if !open {
+            self.set_focused(false);
+        }
+    }
+
+    pub fn set_focused(&self, focused: bool) {
+        self.update_class("focused", focused);
+    }
+
+    /// Adds or removes a class to the button based on `toggle`.
+    fn update_class(&self, class: &str, toggle: bool) {
+        let style_context = self.button.style_context();
+
+        if toggle {
+            style_context.add_class(class);
         } else {
-            self.button.set_tooltip_text(Some(title));
+            style_context.remove_class(class);
-        };
-    }
-
-    /// Updates the classnames on the GTK button
-    /// based on its current state.
-    ///
-    /// State must be passed as an arg here rather than
-    /// using `self.state` to avoid a weird `RwLock` issue.
-    pub fn update_button_classes(&self, state: &State) {
-        let style = self.button.style_context();
-
-        if self.favorite {
-            style.add_class("favorite");
-        } else {
-            style.remove_class("favorite");
-        }
-
-        if state.open_state == OpenState::Open {
-            style.add_class("open");
-        } else {
-            style.remove_class("open");
-        }
-
-        if state.open_state == OpenState::Focused {
-            style.add_class("focused");
-        } else {
-            style.remove_class("focused");
-        }
-
-        if state.open_state == OpenState::Urgent {
-            style.add_class("urgent");
-        } else {
-            style.remove_class("urgent");
         }
     }
 }

src/modules/launcher/mod.rs

@@ -1,275 +1,523 @@
 mod item;
-mod popup;
+mod open_state;
 
+use self::item::{Item, ItemButton, Window};
+use self::open_state::OpenState;
 use crate::collection::Collection;
-use crate::modules::launcher::item::{ButtonConfig, LauncherItem, LauncherWindow, OpenState};
+use crate::icon::find_desktop_file;
-use crate::modules::launcher::popup::Popup;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::modules::{Module, ModuleInfo};
+use crate::wayland;
-use crate::sway::{SwayClient, SwayNode, WindowEvent};
+use crate::wayland::ToplevelChange;
-use color_eyre::{Report, Result};
+use color_eyre::{Help, Report};
+use glib::Continue;
 use gtk::prelude::*;
-use gtk::{IconTheme, Orientation};
+use gtk::{Button, IconTheme, Orientation};
-use ksway::IpcEvent;
 use serde::Deserialize;
-use std::rc::Rc;
+use std::process::{Command, Stdio};
+use std::sync::{Arc, Mutex};
 use tokio::spawn;
 use tokio::sync::mpsc;
-use tokio::task::spawn_blocking;
+use tokio::sync::mpsc::{Receiver, Sender};
-use tracing::error;
+use tracing::{debug, error, trace};
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct LauncherModule {
+    /// List of app IDs (or classes) to always show regardless of open state,
+    /// in the order specified.
     favorites: Option<Vec<String>>,
+    /// Whether to show application names on the bar.
     #[serde(default = "crate::config::default_false")]
     show_names: bool,
+    /// Whether to show application icons on the bar.
     #[serde(default = "crate::config::default_true")]
     show_icons: bool,
 
+    /// Name of the GTK icon theme to use.
     icon_theme: Option<String>,
 }
 
+#[derive(Debug, Clone)]
+pub enum LauncherUpdate {
+    /// Adds item
+    AddItem(Item),
+    /// Adds window to item with `app_id`
+    AddWindow(String, Window),
+    /// Removes item with `app_id`
+    RemoveItem(String),
+    /// Removes window from item with `app_id`.
+    RemoveWindow(String, usize),
+    /// Sets title for `app_id`
+    Title(String, usize, String),
+    /// Marks the item with `app_id` as focused or not focused
+    Focus(String, bool),
+    /// Declares the item with `app_id` has been hovered over
+    Hover(String),
+}
+
 #[derive(Debug)]
-pub enum FocusEvent {
+pub enum ItemEvent {
-    AppId(String),
+    FocusItem(String),
-    Class(String),
+    FocusWindow(usize),
-    ConId(i32),
+    OpenItem(String),
 }
 
-type AppId = String;
+enum ItemOrWindow {
-
+    Item(Item),
-struct Launcher {
+    Window(Window),
-    items: Collection<AppId, LauncherItem>,
-    container: gtk::Box,
-    button_config: ButtonConfig,
 }
 
-impl Launcher {
+enum ItemOrWindowId {
-    fn new(favorites: Vec<String>, container: gtk::Box, button_config: ButtonConfig) -> Self {
+    Item,
-        let items = favorites
+    Window,
-            .into_iter()
-            .map(|app_id| {
-                (
-                    app_id.clone(),
-                    LauncherItem::new(app_id, true, &button_config),
-                )
-            })
-            .collect::<Collection<_, _>>();
-
-        for item in &items {
-            container.add(&item.button);
-        }
-
-        Self {
-            items,
-            container,
-            button_config,
-        }
-    }
-
-    /// Adds a new window to the launcher.
-    /// This gets added to an existing group
-    /// if an instance of the program is already open.
-    fn add_window(&mut self, window: SwayNode) {
-        let id = window.get_id().to_string();
-
-        if let Some(item) = self.items.get_mut(&id) {
-            let mut state = item
-                .state
-                .write()
-                .expect("Failed to get write lock on state");
-            let new_open_state = OpenState::from_node(&window);
-            state.open_state = OpenState::highest_of(&state.open_state, &new_open_state);
-            state.is_xwayland = window.is_xwayland();
-
-            item.update_button_classes(&state);
-
-            let mut windows = item.windows.lock().expect("Failed to get lock on windows");
-
-            windows.insert(
-                window.id,
-                LauncherWindow {
-                    con_id: window.id,
-                    name: window.name,
-                },
-            );
-        } else {
-            let item = LauncherItem::from_node(&window, &self.button_config);
-
-            self.container.add(&item.button);
-            self.items.insert(id, item);
-        }
-    }
-
-    /// Removes a window from the launcher.
-    /// This removes it from the group if multiple instances were open.
-    /// The button will remain on the launcher if it is favourited.
-    fn remove_window(&mut self, window: &SwayNode) {
-        let id = window.get_id().to_string();
-
-        let item = self.items.get_mut(&id);
-
-        let remove = if let Some(item) = item {
-            let windows = Rc::clone(&item.windows);
-            let mut windows = windows.lock().expect("Failed to get lock on windows");
-
-            windows.remove(&window.id);
-
-            if windows.is_empty() {
-                let mut state = item.state.write().expect("Failed to get lock on windows");
-                state.open_state = OpenState::Closed;
-                item.update_button_classes(&state);
-
-                if item.favorite {
-                    false
-                } else {
-                    self.container.remove(&item.button);
-                    true
-                }
-            } else {
-                false
-            }
-        } else {
-            false
-        };
-
-        if remove {
-            self.items.remove(&id);
-        }
-    }
-
-    fn set_window_focused(&mut self, window: &SwayNode) {
-        let id = window.get_id().to_string();
-
-        let currently_focused = self.items.iter_mut().find(|item| {
-            item.state
-                .read()
-                .expect("Failed to get read lock on state")
-                .open_state
-                == OpenState::Focused
-        });
-
-        if let Some(currently_focused) = currently_focused {
-            let mut state = currently_focused
-                .state
-                .write()
-                .expect("Failed to get write lock on state");
-            state.open_state = OpenState::Open;
-            currently_focused.update_button_classes(&state);
-        }
-
-        let item = self.items.get_mut(&id);
-        if let Some(item) = item {
-            let mut state = item
-                .state
-                .write()
-                .expect("Failed to get write lock on state");
-            state.open_state = OpenState::Focused;
-            item.update_button_classes(&state);
-        }
-    }
-
-    fn set_window_title(&mut self, window: SwayNode) {
-        let id = window.get_id().to_string();
-        let item = self.items.get_mut(&id);
-
-        if let (Some(item), Some(name)) = (item, window.name) {
-            let mut windows = item.windows.lock().expect("Failed to get lock on windows");
-            if windows.len() == 1 {
-                item.set_title(&name, &self.button_config);
-            } else if let Some(window) = windows.get_mut(&window.id) {
-                window.name = Some(name);
-            } else {
-                // This should never happen
-                // But makes more sense to wipe title than keep old one in case of error
-                item.set_title("", &self.button_config);
-            }
-        }
-    }
-
-    fn set_window_urgent(&mut self, window: &SwayNode) {
-        let id = window.get_id().to_string();
-        let item = self.items.get_mut(&id);
-
-        if let Some(item) = item {
-            let mut state = item
-                .state
-                .write()
-                .expect("Failed to get write lock on state");
-            state.open_state =
-                OpenState::highest_of(&state.open_state, &OpenState::from_node(window));
-            item.update_button_classes(&state);
-        }
-    }
 }
 
 impl Module<gtk::Box> for LauncherModule {
-    fn into_widget(self, info: &ModuleInfo) -> Result<gtk::Box> {
+    type SendMessage = LauncherUpdate;
-        let icon_theme = IconTheme::new();
+    type ReceiveMessage = ItemEvent;
 
-        if let Some(theme) = self.icon_theme {
+    fn spawn_controller(
-            icon_theme.set_custom_theme(Some(&theme));
+        &self,
-        }
+        _info: &ModuleInfo,
-
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
-        let mut sway = SwayClient::connect()?;
+        mut rx: Receiver<Self::ReceiveMessage>,
-
+    ) -> crate::Result<()> {
-        let popup = Popup::new(
+        let items = match &self.favorites {
-            "popup-launcher",
+            Some(favorites) => favorites
-            info.app,
+                .iter()
-            info.monitor,
+                .map(|app_id| {
-            Orientation::Vertical,
+                    (
-            info.bar_position,
+                        app_id.to_string(),
-        );
+                        Item::new(app_id.to_string(), OpenState::Closed, true),
-        let container = gtk::Box::new(Orientation::Horizontal, 0);
+                    )
-
+                })
-        let (ui_tx, mut ui_rx) = mpsc::channel(32);
+                .collect::<Collection<_, _>>(),
-
+            None => Collection::new(),
-        let button_config = ButtonConfig {
-            icon_theme,
-            show_names: self.show_names,
-            show_icons: self.show_icons,
-            popup,
-            tx: ui_tx,
         };
 
-        let mut launcher = Launcher::new(
+        let items = Arc::new(Mutex::new(items));
-            self.favorites.unwrap_or_default(),
-            container.clone(),
-            button_config,
-        );
-
-        let open_windows = sway.get_open_windows()?;
-
-        for window in open_windows {
-            launcher.add_window(window);
-        }
-
-        let srx = sway.subscribe(vec![IpcEvent::Window])?;
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-
-        spawn_blocking(move || loop {
-            while let Ok((_, payload)) = srx.try_recv() {
-                match serde_json::from_slice::<WindowEvent>(&payload) {
-                    Ok(payload) => {
-                        tx.send(payload)
-                            .expect("Failed to send window event payload");
-                    }
-                    Err(err) => error!("{:?}", err),
-                }
-            }
-
-            if let Err(err) = sway.poll() {
-                error!("{:?}", err);
-            }
-        });
 
         {
+            let items = Arc::clone(&items);
+            let tx = tx.clone();
+            spawn(async move {
+                let wl = wayland::get_client().await;
+                let open_windows = wl
+                    .toplevels
+                    .read()
+                    .expect("Failed to get read lock on toplevels");
+
+                let mut items = items.lock().expect("Failed to get lock on items");
+
+                for (window, _) in open_windows.clone() {
+                    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 = items.iter();
+                for item in items {
+                    tx.try_send(ModuleUpdateEvent::Update(LauncherUpdate::AddItem(
+                        item.clone(),
+                    )))?;
+                }
+
+                Ok::<(), Report>(())
+            });
+        }
+
+        let items2 = Arc::clone(&items);
+        spawn(async move {
+            let items = items2;
+
+            let mut wlrx = {
+                let wl = wayland::get_client().await;
+                wl.subscribe_toplevels()
+            };
+
+            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();
+
+                let items = || items.lock().expect("Failed to get lock on items");
+
+                match event.change {
+                    ToplevelChange::New => {
+                        let new_item = {
+                            let mut items = items();
+                            let item = items.get_mut(&app_id);
+                            match item {
+                                None => {
+                                    let item: Item = window.into();
+                                    items.insert(app_id.clone(), item.clone());
+
+                                    ItemOrWindow::Item(item)
+                                }
+                                Some(item) => {
+                                    let window = item.merge_toplevel(window);
+                                    ItemOrWindow::Window(window)
+                                }
+                            }
+                        };
+
+                        match new_item {
+                            ItemOrWindow::Item(item) => {
+                                send_update(LauncherUpdate::AddItem(item)).await
+                            }
+                            ItemOrWindow::Window(window) => {
+                                send_update(LauncherUpdate::AddWindow(app_id, window)).await
+                            }
+                        }?;
+                    }
+                    ToplevelChange::Close => {
+                        let remove_item = {
+                            let mut items = items();
+                            let item = items.get_mut(&app_id);
+                            match item {
+                                Some(item) => {
+                                    item.unmerge_toplevel(&window);
+
+                                    if item.windows.is_empty() {
+                                        items.remove(&app_id);
+                                        Some(ItemOrWindowId::Item)
+                                    } else {
+                                        Some(ItemOrWindowId::Window)
+                                    }
+                                }
+                                None => None,
+                            }
+                        };
+
+                        match remove_item {
+                            Some(ItemOrWindowId::Item) => {
+                                send_update(LauncherUpdate::RemoveItem(app_id)).await?;
+                            }
+                            Some(ItemOrWindowId::Window) => {
+                                send_update(LauncherUpdate::RemoveWindow(app_id, window.id))
+                                    .await?;
+                            }
+                            None => {}
+                        };
+                    }
+                    ToplevelChange::Focus(focused) => {
+                        let update_title = if focused {
+                            if let Some(item) = 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());
+                                    true
+                                } else {
+                                    false
+                                }
+                            } else {
+                                false
+                            }
+                        } else {
+                            false
+                        };
+
+                        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) = 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>>>(())
+        });
+
+        // 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),
+                        |file| {
+                            if let Err(err) = Command::new("gtk-launch")
+                                .arg(
+                                    file.file_name()
+                                        .expect("File segment missing from path to desktop file"),
+                                )
+                                .stdout(Stdio::null())
+                                .stderr(Stdio::null())
+                                .spawn()
+                            {
+                                error!(
+                                    "{:?}",
+                                    Report::new(err)
+                                        .wrap_err("Failed to run gtk-launch command.")
+                                        .suggestion("Perhaps the desktop file is invalid?")
+                                );
+                            }
+                        },
+                    );
+                } else {
+                    let wl = wayland::get_client().await;
+                    let items = items.lock().expect("Failed to get lock on items");
+
+                    let id = match event {
+                        ItemEvent::FocusItem(app_id) => items
+                            .get(&app_id)
+                            .and_then(|item| item.windows.first().map(|win| win.id)),
+                        ItemEvent::FocusWindow(id) => Some(id),
+                        ItemEvent::OpenItem(_) => unreachable!(),
+                    };
+
+                    if let Some(id) = id {
+                        let toplevels = wl
+                            .toplevels
+                            .read()
+                            .expect("Failed to get read lock on toplevels");
+                        let seat = wl.seats.first().expect("Failed to get Wayland seat");
+                        if let Some((_top, handle)) = toplevels.get(&id) {
+                            handle.activate(seat);
+                        };
+                    }
+                }
+            }
+
+            Ok::<(), swayipc_async::Error>(())
+        });
+
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> crate::Result<ModuleWidget<gtk::Box>> {
+        let icon_theme = IconTheme::new();
+        if let Some(ref theme) = self.icon_theme {
+            icon_theme.set_custom_theme(Some(theme));
+        }
+
+        let container = gtk::Box::new(info.bar_position.get_orientation(), 0);
+
+        {
+            let container = container.clone();
+
+            let show_names = self.show_names;
+            let show_icons = self.show_icons;
+            let orientation = info.bar_position.get_orientation();
+
+            let mut buttons = Collection::<String, ItemButton>::new();
+
+            let controller_tx2 = context.controller_tx.clone();
+            context.widget_rx.attach(None, move |event| {
+                match event {
+                    LauncherUpdate::AddItem(item) => {
+                        debug!("Adding item with id {}", item.app_id);
+
+                        if let Some(button) = buttons.get(&item.app_id) {
+                            button.set_open(true);
+                        } else {
+                            let button = ItemButton::new(
+                                &item,
+                                show_names,
+                                show_icons,
+                                orientation,
+                                &icon_theme,
+                                &context.tx,
+                                &controller_tx2,
+                            );
+
+                            container.add(&button.button);
+                            buttons.insert(item.app_id, button);
+                        }
+                    }
+                    LauncherUpdate::AddWindow(app_id, _) => {
+                        if let Some(button) = buttons.get(&app_id) {
+                            button.set_open(true);
+
+                            let mut menu_state = button
+                                .menu_state
+                                .write()
+                                .expect("Failed to get write lock on item menu state");
+                            menu_state.num_windows += 1;
+                        }
+                    }
+                    LauncherUpdate::RemoveItem(app_id) => {
+                        debug!("Removing item with id {}", app_id);
+
+                        if let Some(button) = buttons.get(&app_id) {
+                            if button.persistent {
+                                button.set_open(false);
+                                if button.show_names {
+                                    button.button.set_label(&app_id);
+                                }
+                            } else {
+                                container.remove(&button.button);
+                                buttons.remove(&app_id);
+                            }
+                        }
+                    }
+                    LauncherUpdate::RemoveWindow(app_id, _) => {
+                        if let Some(button) = buttons.get(&app_id) {
+                            let mut menu_state = button
+                                .menu_state
+                                .write()
+                                .expect("Failed to get write lock on item menu state");
+                            menu_state.num_windows -= 1;
+                        }
+                    }
+                    LauncherUpdate::Focus(app_id, focus) => {
+                        debug!("Changing focus to {} on item with id {}", focus, app_id);
+
+                        if let Some(button) = buttons.get(&app_id) {
+                            button.set_focused(focus);
+                        }
+                    }
+                    LauncherUpdate::Title(app_id, _, name) => {
+                        debug!("Updating title for item with id {}: {:?}", app_id, name);
+
+                        if show_names {
+                            if let Some(button) = buttons.get(&app_id) {
+                                button.button.set_label(&name);
+                            }
+                        }
+                    }
+                    LauncherUpdate::Hover(_) => {}
+                };
+
+                Continue(true)
+            });
+        }
+
+        let popup = self.into_popup(context.controller_tx, context.popup_rx);
+        Ok(ModuleWidget {
+            widget: container,
+            popup,
+        })
+    }
+
+    fn into_popup(
+        self,
+        controller_tx: Sender<Self::ReceiveMessage>,
+        rx: glib::Receiver<Self::SendMessage>,
+    ) -> Option<gtk::Box> {
+        const MAX_WIDTH: i32 = 250;
+
+        let container = gtk::Box::builder()
+            .orientation(Orientation::Vertical)
+            .name("popup-launcher")
+            .build();
+
+        let placeholder = Button::with_label("PLACEHOLDER");
+        placeholder.set_width_request(MAX_WIDTH);
+        container.add(&placeholder);
+
+        let mut buttons = Collection::<String, Collection<usize, Button>>::new();
+
+        {
+            let container = container.clone();
             rx.attach(None, move |event| {
-                match event.change.as_str() {
+                match event {
-                    "new" => launcher.add_window(event.container),
+                    LauncherUpdate::AddItem(item) => {
-                    "close" => launcher.remove_window(&event.container),
+                        let app_id = item.app_id.clone();
-                    "focus" => launcher.set_window_focused(&event.container),
+
-                    "title" => launcher.set_window_title(event.container),
+                        let window_buttons = item
-                    "urgent" => launcher.set_window_urgent(&event.container),
+                            .windows
+                            .into_iter()
+                            .map(|win| {
+                                let button = Button::builder()
+                                    .label(&clamp(&win.name))
+                                    .height_request(40)
+                                    .build();
+
+                                {
+                                    let tx = controller_tx.clone();
+                                    button.connect_clicked(move |button| {
+                                        tx.try_send(ItemEvent::FocusWindow(win.id))
+                                            .expect("Failed to send window click event");
+
+                                        if let Some(win) = button.window() {
+                                            win.hide();
+                                        }
+                                    });
+                                }
+
+                                (win.id, button)
+                            })
+                            .collect();
+
+                        buttons.insert(app_id, window_buttons);
+                    }
+                    LauncherUpdate::AddWindow(app_id, win) => {
+                        if let Some(buttons) = buttons.get_mut(&app_id) {
+                            let button = Button::builder()
+                                .height_request(40)
+                                .label(&clamp(&win.name))
+                                .build();
+
+                            {
+                                let tx = controller_tx.clone();
+                                button.connect_clicked(move |button| {
+                                    tx.try_send(ItemEvent::FocusWindow(win.id))
+                                        .expect("Failed to send window click event");
+
+                                    if let Some(win) = button.window() {
+                                        win.hide();
+                                    }
+                                });
+                            }
+
+                            buttons.insert(win.id, button);
+                        }
+                    }
+                    LauncherUpdate::RemoveWindow(app_id, win_id) => {
+                        if let Some(buttons) = buttons.get_mut(&app_id) {
+                            buttons.remove(&win_id);
+                        }
+                    }
+                    LauncherUpdate::Title(app_id, win_id, title) => {
+                        if let Some(buttons) = buttons.get_mut(&app_id) {
+                            if let Some(button) = buttons.get(&win_id) {
+                                button.set_label(&title);
+                            }
+                        }
+                    }
+                    LauncherUpdate::Hover(app_id) => {
+                        // empty current buttons
+                        for child in container.children() {
+                            container.remove(&child);
+                        }
+
+                        // add app's buttons
+                        if let Some(buttons) = buttons.get(&app_id) {
+                            for button in buttons {
+                                button.style_context().add_class("popup-item");
+                                container.add(button);
+                            }
+
+                            container.show_all();
+                            container.set_width_request(MAX_WIDTH);
+                        }
+                    }
                     _ => {}
                 }
 
@@ -277,21 +525,21 @@ impl Module<gtk::Box> for LauncherModule {
             });
         }
 
-        spawn(async move {
+        Some(container)
-            let mut sway = SwayClient::connect()?;
+    }
-            while let Some(event) = ui_rx.recv().await {
+}
-                let selector = match event {
+
-                    FocusEvent::AppId(app_id) => format!("[app_id={}]", app_id),
+/// Clamps a string at 24 characters.
-                    FocusEvent::Class(class) => format!("[class={}]", class),
+///
-                    FocusEvent::ConId(id) => format!("[con_id={}]", id),
+/// This is a hacky number derived from
-                };
+/// "what fits inside the 250px popup"
-
+/// and probably won't hold up with wide fonts.
-                sway.run(format!("{} focus", selector))?;
+fn clamp(str: &str) -> String {
-            }
+    const MAX_CHARS: usize = 24;
-
+
-            Ok::<(), Report>(())
+    if str.len() > MAX_CHARS {
-        });
+        str.chars().take(MAX_CHARS - 3).collect::<String>() + "..."
-
+    } else {
-        Ok(container)
+        str.to_string()
     }
 }

src/modules/launcher/open_state.rs

@@ -0,0 +1,48 @@
+use crate::wayland::ToplevelInfo;
+
+/// Open state for a launcher item, or item window.
+#[derive(Debug, Clone, Eq, PartialEq, Copy)]
+pub enum OpenState {
+    Closed,
+    Open { focused: bool },
+}
+
+impl OpenState {
+    /// Creates from `SwayNode`
+    pub const fn from_toplevel(toplevel: &ToplevelInfo) -> Self {
+        Self::Open {
+            focused: toplevel.active,
+        }
+    }
+
+    /// Creates open with focused
+    pub const fn focused(focused: bool) -> Self {
+        Self::Open { focused }
+    }
+
+    /// Checks if open
+    pub fn is_open(self) -> bool {
+        self != Self::Closed
+    }
+
+    /// Checks if open with focus
+    pub const fn is_focused(self) -> bool {
+        matches!(self, Self::Open { focused: true })
+    }
+
+    /// Merges states together to produce a single state.
+    /// This is effectively an OR operation,
+    /// so sets state to open and flags to true if any state is open
+    /// or any instance of the flag is true.
+    pub fn merge_states(states: &[&Self]) -> Self {
+        states.iter().fold(Self::Closed, |merged, current| {
+            if merged.is_open() || current.is_open() {
+                Self::Open {
+                    focused: merged.is_focused() || current.is_focused(),
+                }
+            } else {
+                Self::Closed
+            }
+        })
+    }
+}

src/modules/launcher/popup.rs

@@ -1,36 +0,0 @@
-use crate::modules::launcher::item::LauncherWindow;
-use crate::modules::launcher::FocusEvent;
-pub use crate::popup::Popup;
-use gtk::prelude::*;
-use gtk::Button;
-use tokio::sync::mpsc;
-
-impl Popup {
-    pub fn set_windows(&self, windows: &[LauncherWindow], tx: &mpsc::Sender<FocusEvent>) {
-        // clear
-        for child in self.container.children() {
-            self.container.remove(&child);
-        }
-
-        for window in windows {
-            let mut button_builder = Button::builder().height_request(40);
-
-            if let Some(name) = &window.name {
-                button_builder = button_builder.label(name);
-            }
-
-            let button = button_builder.build();
-
-            let con_id = window.con_id;
-            let window = self.window.clone();
-            let tx = tx.clone();
-            button.connect_clicked(move |_| {
-                tx.try_send(FocusEvent::ConId(con_id))
-                    .expect("Failed to send focus event");
-                window.hide();
-            });
-
-            self.container.add(&button);
-        }
-    }
-}

src/modules/mod.rs

@@ -14,12 +14,13 @@ pub mod tray;
 pub mod workspaces;
 
 use crate::config::BarPosition;
+use crate::popup::ButtonGeometry;
 use color_eyre::Result;
-/// Shamelessly stolen from here:
+use derive_builder::Builder;
-/// <https://github.com/zeroeightysix/rustbar/blob/master/src/modules/module.rs>
 use glib::IsA;
 use gtk::gdk::Monitor;
 use gtk::{Application, Widget};
+use tokio::sync::mpsc;
 
 #[derive(Clone)]
 pub enum ModuleLocation {
@@ -28,19 +29,70 @@ pub enum ModuleLocation {
     Right,
 }
 
+#[derive(Builder)]
 pub struct ModuleInfo<'a> {
     pub app: &'a Application,
     pub location: ModuleLocation,
-    pub bar_position: &'a BarPosition,
+    pub bar_position: BarPosition,
     pub monitor: &'a Monitor,
     pub output_name: &'a str,
+    pub module_name: &'a str,
+}
+
+#[derive(Debug)]
+pub enum ModuleUpdateEvent<T> {
+    /// Sends an update to the module UI
+    Update(T),
+    /// Toggles the open state of the popup.
+    TogglePopup(ButtonGeometry),
+    /// Force sets the popup open.
+    /// Takes the button X position and width.
+    OpenPopup(ButtonGeometry),
+    /// Force sets the popup closed.
+    ClosePopup,
+}
+
+pub struct WidgetContext<TSend, TReceive> {
+    pub id: usize,
+    pub tx: mpsc::Sender<ModuleUpdateEvent<TSend>>,
+    pub controller_tx: mpsc::Sender<TReceive>,
+    pub widget_rx: glib::Receiver<TSend>,
+    pub popup_rx: glib::Receiver<TSend>,
+}
+
+pub struct ModuleWidget<W: IsA<Widget>> {
+    pub widget: W,
+    pub popup: Option<gtk::Box>,
 }
 
 pub trait Module<W>
 where
     W: IsA<Widget>,
 {
-    /// Consumes the module config
+    type SendMessage;
-    /// and produces a GTK widget of type `W`
+    type ReceiveMessage;
-    fn into_widget(self, info: &ModuleInfo) -> Result<W>;
+
+    fn spawn_controller(
+        &self,
+        info: &ModuleInfo,
+        tx: mpsc::Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        rx: mpsc::Receiver<Self::ReceiveMessage>,
+    ) -> Result<()>;
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<W>>;
+
+    fn into_popup(
+        self,
+        _tx: mpsc::Sender<Self::ReceiveMessage>,
+        _rx: glib::Receiver<Self::SendMessage>,
+    ) -> Option<gtk::Box>
+    where
+        Self: Sized,
+    {
+        None
+    }
 }

src/modules/mpd/client.rs

@@ -1,59 +1,149 @@
-use mpd_client::commands::responses::Status;
+use lazy_static::lazy_static;
-use mpd_client::raw::MpdProtocolError;
+use mpd_client::client::{CommandError, Connection, ConnectionEvent, Subsystem};
-use mpd_client::{Client, Connection};
+use mpd_client::commands::Command;
+use mpd_client::protocol::MpdProtocolError;
+use mpd_client::responses::Status;
+use mpd_client::Client;
+use std::collections::HashMap;
+use std::fmt::{Display, Formatter};
+use std::os::unix::fs::FileTypeExt;
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::time::Duration;
 use tokio::net::{TcpStream, UnixStream};
 use tokio::spawn;
+use tokio::sync::broadcast::{channel, error::SendError, Receiver, Sender};
+use tokio::sync::Mutex;
 use tokio::time::sleep;
+use tracing::debug;
 
-pub async fn wait_for_connection(
+lazy_static! {
-    hosts: Vec<String>,
+    static ref CONNECTIONS: Arc<Mutex<HashMap<String, Arc<MpdClient>>>> =
-    interval: Duration,
+        Arc::new(Mutex::new(HashMap::new()));
-    max_retries: Option<usize>,
-) -> Option<Client> {
-    let mut retries = 0;
-
-    spawn(async move {
-        let max_retries = max_retries.unwrap_or(usize::MAX);
-        loop {
-            if retries == max_retries {
-                break None;
 }
 
-            if let Some(conn) = try_get_mpd_conn(&hosts).await {
+pub struct MpdClient {
-                break Some(conn.0);
+    client: Client,
+    tx: Sender<()>,
+    _rx: Receiver<()>,
+}
+
+#[derive(Debug)]
+pub enum MpdConnectionError {
+    MaxRetries,
+    ProtocolError(MpdProtocolError),
+}
+
+impl Display for MpdConnectionError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::MaxRetries => write!(f, "Reached max retries"),
+            Self::ProtocolError(e) => write!(f, "{:?}", e),
+        }
+    }
+}
+
+impl std::error::Error for MpdConnectionError {}
+
+impl MpdClient {
+    async fn new(host: &str) -> Result<Self, MpdConnectionError> {
+        debug!("Creating new MPD connection to {}", host);
+
+        let (client, mut state_changes) =
+            wait_for_connection(host, Duration::from_secs(5), None).await?;
+
+        let (tx, rx) = channel(16);
+        let tx2 = tx.clone();
+
+        spawn(async move {
+            while let Some(change) = state_changes.next().await {
+                debug!("Received state change: {:?}", change);
+
+                if let ConnectionEvent::SubsystemChange(Subsystem::Player | Subsystem::Queue) =
+                    change
+                {
+                    tx2.send(())?;
+                }
+            }
+
+            Ok::<(), SendError<()>>(())
+        });
+
+        Ok(Self {
+            client,
+            tx,
+            _rx: rx,
+        })
+    }
+
+    pub fn subscribe(&self) -> Receiver<()> {
+        self.tx.subscribe()
+    }
+
+    pub async fn command<C: Command>(&self, command: C) -> Result<C::Response, CommandError> {
+        self.client.command(command).await
+    }
+}
+
+pub async fn get_client(host: &str) -> Result<Arc<MpdClient>, MpdConnectionError> {
+    let mut connections = CONNECTIONS.lock().await;
+    match connections.get(host) {
+        None => {
+            let client = MpdClient::new(host).await?;
+            let client = Arc::new(client);
+            connections.insert(host.to_string(), Arc::clone(&client));
+            Ok(client)
+        }
+        Some(client) => Ok(Arc::clone(client)),
+    }
+}
+
+async fn wait_for_connection(
+    host: &str,
+    interval: Duration,
+    max_retries: Option<usize>,
+) -> Result<Connection, MpdConnectionError> {
+    let mut retries = 0;
+    let max_retries = max_retries.unwrap_or(usize::MAX);
+
+    loop {
+        if retries == max_retries {
+            break Err(MpdConnectionError::MaxRetries);
         }
 
         retries += 1;
+
+        match try_get_mpd_conn(host).await {
+            Ok(conn) => break Ok(conn),
+            Err(err) => {
+                if retries == max_retries {
+                    break Err(MpdConnectionError::ProtocolError(err));
+                }
+            }
+        }
+
         sleep(interval).await;
     }
-    })
-    .await
-    .expect("Error occurred while handling tasks")
 }
 
 /// Cycles through each MPD host and
 /// returns the first one which connects,
 /// or none if there are none
-async fn try_get_mpd_conn(hosts: &[String]) -> Option<Connection> {
+async fn try_get_mpd_conn(host: &str) -> Result<Connection, MpdProtocolError> {
-    for host in hosts {
+    if is_unix_socket(host) {
-        let connection = if is_unix_socket(host) {
         connect_unix(host).await
     } else {
         connect_tcp(host).await
-        };
-
-        if let Ok(connection) = connection {
-            return Some(connection);
     }
 }
 
-    None
-}
-
 fn is_unix_socket(host: &str) -> bool {
-    PathBuf::from(host).is_file()
+    let path = PathBuf::from(host);
+    path.exists()
+        && match path.metadata() {
+            Ok(metadata) => metadata.file_type().is_socket(),
+            Err(_) => false,
+        }
 }
 
 async fn connect_unix(host: &str) -> Result<Connection, MpdProtocolError> {

src/modules/mpd/mod.rs

@@ -1,37 +1,66 @@
 mod client;
-mod popup;
 
-use self::popup::Popup;
+use crate::modules::mpd::client::MpdConnectionError;
-use crate::modules::mpd::client::{get_duration, get_elapsed, wait_for_connection};
+use crate::modules::mpd::client::{get_client, get_duration, get_elapsed};
-use crate::modules::mpd::popup::{MpdPopup, PopupEvent};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::modules::{Module, ModuleInfo};
+use crate::popup::Popup;
 use color_eyre::Result;
 use dirs::{audio_dir, home_dir};
 use glib::Continue;
+use gtk::gdk_pixbuf::Pixbuf;
 use gtk::prelude::*;
-use gtk::{Button, Orientation};
+use gtk::{Button, Image, Label, Orientation};
-use mpd_client::commands::responses::{PlayState, Song, Status};
+use mpd_client::commands;
-use mpd_client::{commands, Tag};
+use mpd_client::responses::{PlayState, Song, Status};
+use mpd_client::tag::Tag;
 use regex::Regex;
 use serde::Deserialize;
 use std::path::PathBuf;
-use std::time::Duration;
 use tokio::spawn;
 use tokio::sync::mpsc;
-use tokio::time::sleep;
+use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::error;
 
+#[derive(Debug)]
+pub enum PlayerCommand {
+    Previous,
+    Toggle,
+    Next,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct Icons {
+    /// Icon to display when playing.
+    #[serde(default = "default_icon_play")]
+    play: Option<String>,
+    /// Icon to display when paused.
+    #[serde(default = "default_icon_pause")]
+    pause: Option<String>,
+}
+
+impl Default for Icons {
+    fn default() -> Self {
+        Self {
+            pause: default_icon_pause(),
+            play: default_icon_play(),
+        }
+    }
+}
+
 #[derive(Debug, Deserialize, Clone)]
 pub struct MpdModule {
+    /// TCP or Unix socket address.
     #[serde(default = "default_socket")]
     host: String,
+    /// Format of current song info to display on the bar.
     #[serde(default = "default_format")]
     format: String,
-    #[serde(default = "default_icon_play")]
-    icon_play: Option<String>,
-    #[serde(default = "default_icon_pause")]
-    icon_pause: Option<String>,
 
+    /// Player state icons
+    #[serde(default)]
+    icons: Icons,
+
+    /// Path to root of music directory.
     #[serde(default = "default_music_dir")]
     music_dir: PathBuf,
 }
@@ -83,76 +112,72 @@ fn get_tokens(re: &Regex, format_string: &str) -> Vec<String> {
         .collect::<Vec<_>>()
 }
 
-enum Event {
+#[derive(Clone, Debug)]
-    Open,
+pub struct SongUpdate {
-    Update(Box<Option<(Song, Status, String)>>),
+    song: Song,
+    status: Status,
+    display_string: String,
 }
 
 impl Module<Button> for MpdModule {
-    fn into_widget(self, info: &ModuleInfo) -> Result<Button> {
+    type SendMessage = Option<SongUpdate>;
+    type ReceiveMessage = PlayerCommand;
+
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        mut rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        let host1 = self.host.clone();
+        let host2 = self.host.clone();
+        let format = self.format.clone();
+        let icons = self.icons.clone();
+
         let re = Regex::new(r"\{([\w-]+)}")?;
         let tokens = get_tokens(&re, self.format.as_str());
 
-        let button = Button::new();
+        // poll mpd server
-
-        let (ui_tx, mut ui_rx) = mpsc::channel(32);
-
-        let popup = Popup::new(
-            "popup-mpd",
-            info.app,
-            info.monitor,
-            Orientation::Horizontal,
-            info.bar_position,
-        );
-        let mpd_popup = MpdPopup::new(popup, ui_tx);
-
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-        let click_tx = tx.clone();
-
-        let music_dir = self.music_dir.clone();
-
-        button.connect_clicked(move |_| {
-            click_tx
-                .send(Event::Open)
-                .expect("Failed to send popup open event");
-        });
-
-        let host = self.host.clone();
-        let host2 = self.host.clone();
         spawn(async move {
-            let client = wait_for_connection(vec![host], Duration::from_secs(1), None)
+            let client = get_client(&host1).await.expect("Failed to connect to MPD");
-                .await
+            let mut mpd_rx = client.subscribe();
-                .expect("Unexpected error when trying to connect to MPD server");
 
             loop {
                 let current_song = client.command(commands::CurrentSong).await;
                 let status = client.command(commands::Status).await;
 
                 if let (Ok(Some(song)), Ok(status)) = (current_song, status) {
-                    let string = self
+                    let display_string =
-                        .replace_tokens(self.format.as_str(), &tokens, &song.song, &status)
+                        replace_tokens(format.as_str(), &tokens, &song.song, &status, &icons);
-                        .await;
 
-                    tx.send(Event::Update(Box::new(Some((song.song, status, string)))))
+                    let update = SongUpdate {
-                        .expect("Failed to send update event");
+                        song: song.song,
+                        status,
+                        display_string,
+                    };
+
+                    tx.send(ModuleUpdateEvent::Update(Some(update))).await?;
                 } else {
-                    tx.send(Event::Update(Box::new(None)))
+                    tx.send(ModuleUpdateEvent::Update(None)).await?;
-                        .expect("Failed to send update event");
                 }
 
-                sleep(Duration::from_secs(1)).await;
+                // wait for player state change
+                if mpd_rx.recv().await.is_err() {
+                    break;
                 }
+            }
+
+            Ok::<(), mpsc::error::SendError<ModuleUpdateEvent<Self::SendMessage>>>(())
         });
 
+        // listen to ui events
         spawn(async move {
-            let client = wait_for_connection(vec![host2], Duration::from_secs(1), None)
+            let client = get_client(&host2).await?;
-                .await
-                .expect("Unexpected error when trying to connect to MPD server");
 
-            while let Some(event) = ui_rx.recv().await {
+            while let Some(event) = rx.recv().await {
                 let res = match event {
-                    PopupEvent::Previous => client.command(commands::Previous).await,
+                    PlayerCommand::Previous => client.command(commands::Previous).await,
-                    PopupEvent::Toggle => match client.command(commands::Status).await {
+                    PlayerCommand::Toggle => match client.command(commands::Status).await {
                         Ok(status) => match status.state {
                             PlayState::Playing => client.command(commands::SetPause(true)).await,
                             PlayState::Paused => client.command(commands::SetPause(false)).await,
@@ -160,56 +185,214 @@ impl Module<Button> for MpdModule {
                         },
                         Err(err) => Err(err),
                     },
-                    PopupEvent::Next => client.command(commands::Next).await,
+                    PlayerCommand::Next => client.command(commands::Next).await,
                 };
 
                 if let Err(err) = res {
                     error!("Failed to send command to MPD server: {:?}", err);
                 }
             }
+
+            Ok::<(), MpdConnectionError>(())
+        });
+
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<Button>> {
+        let button = Button::new();
+        let label = Label::new(None);
+        label.set_angle(info.bar_position.get_angle());
+        button.add(&label);
+
+        let orientation = info.bar_position.get_orientation();
+
+        button.connect_clicked(move |button| {
+            context
+                .tx
+                .try_send(ModuleUpdateEvent::TogglePopup(Popup::button_pos(
+                    button,
+                    orientation,
+                )))
+                .expect("Failed to send MPD popup open event");
         });
 
         {
             let button = button.clone();
 
-            rx.attach(None, move |event| {
+            context.widget_rx.attach(None, move |mut event| {
-                match event {
+                if let Some(event) = event.take() {
-                    Event::Open => {
+                    label.set_label(&event.display_string);
-                        mpd_popup.popup.show(&button);
-                    }
-                    Event::Update(mut msg) => {
-                        if let Some((song, status, string)) = msg.take() {
-                            mpd_popup.update(&song, &status, music_dir.as_path());
-
-                            button.set_label(&string);
                     button.show();
                 } else {
                     button.hide();
                 }
-                    }
-                }
 
                 Continue(true)
             });
         };
 
-        Ok(button)
+        let popup = self.into_popup(context.controller_tx, context.popup_rx);
+
+        Ok(ModuleWidget {
+            widget: button,
+            popup,
+        })
+    }
+
+    fn into_popup(
+        self,
+        tx: Sender<Self::ReceiveMessage>,
+        rx: glib::Receiver<Self::SendMessage>,
+    ) -> Option<gtk::Box> {
+        let container = gtk::Box::builder()
+            .orientation(Orientation::Horizontal)
+            .spacing(10)
+            .name("popup-mpd")
+            .build();
+
+        let album_image = Image::builder()
+            .width_request(128)
+            .height_request(128)
+            .name("album-art")
+            .build();
+
+        let info_box = gtk::Box::new(Orientation::Vertical, 10);
+        let title_label = IconLabel::new("\u{f886}", None);
+        let album_label = IconLabel::new("\u{f524}", None);
+        let artist_label = IconLabel::new("\u{fd01}", None);
+
+        title_label.container.set_widget_name("title");
+        album_label.container.set_widget_name("album");
+        artist_label.container.set_widget_name("label");
+
+        info_box.add(&title_label.container);
+        info_box.add(&album_label.container);
+        info_box.add(&artist_label.container);
+
+        let controls_box = gtk::Box::builder().name("controls").build();
+        let btn_prev = Button::builder().label("\u{f9ad}").name("btn-prev").build();
+        let btn_play_pause = Button::builder().label("").name("btn-play-pause").build();
+        let btn_next = Button::builder().label("\u{f9ac}").name("btn-next").build();
+
+        controls_box.add(&btn_prev);
+        controls_box.add(&btn_play_pause);
+        controls_box.add(&btn_next);
+
+        info_box.add(&controls_box);
+
+        container.add(&album_image);
+        container.add(&info_box);
+
+        let tx_prev = tx.clone();
+        btn_prev.connect_clicked(move |_| {
+            tx_prev
+                .try_send(PlayerCommand::Previous)
+                .expect("Failed to send prev track message");
+        });
+
+        let tx_toggle = tx.clone();
+        btn_play_pause.connect_clicked(move |_| {
+            tx_toggle
+                .try_send(PlayerCommand::Toggle)
+                .expect("Failed to send play/pause track message");
+        });
+
+        let tx_next = tx;
+        btn_next.connect_clicked(move |_| {
+            tx_next
+                .try_send(PlayerCommand::Next)
+                .expect("Failed to send next track message");
+        });
+
+        container.show_all();
+
+        {
+            let music_dir = self.music_dir;
+
+            rx.attach(None, move |update| {
+                if let Some(update) = update {
+                    let prev_album = album_label.label.text();
+                    let curr_album = update.song.album().unwrap_or_default();
+
+                    // only update art when album changes
+                    if prev_album != curr_album {
+                        let cover_path = music_dir.join(
+                            update
+                                .song
+                                .file_path()
+                                .parent()
+                                .expect("Song path should not be root")
+                                .join("cover.jpg"),
+                        );
+
+                        if let Ok(pixbuf) = Pixbuf::from_file_at_scale(cover_path, 128, 128, true) {
+                            album_image.set_from_pixbuf(Some(&pixbuf));
+                        } else {
+                            album_image.set_from_pixbuf(None);
+                        }
+                    }
+
+                    title_label
+                        .label
+                        .set_text(update.song.title().unwrap_or_default());
+                    album_label.label.set_text(curr_album);
+                    artist_label
+                        .label
+                        .set_text(update.song.artists().first().unwrap_or(&String::new()));
+
+                    match update.status.state {
+                        PlayState::Stopped => {
+                            btn_play_pause.set_sensitive(false);
+                        }
+                        PlayState::Playing => {
+                            btn_play_pause.set_sensitive(true);
+                            btn_play_pause.set_label("");
+                        }
+                        PlayState::Paused => {
+                            btn_play_pause.set_sensitive(true);
+                            btn_play_pause.set_label("");
+                        }
+                    }
+
+                    let enable_prev = match update.status.current_song {
+                        Some((pos, _)) => pos.0 > 0,
+                        None => false,
+                    };
+
+                    let enable_next = match update.status.current_song {
+                        Some((pos, _)) => pos.0 < update.status.playlist_length,
+                        None => false,
+                    };
+
+                    btn_prev.set_sensitive(enable_prev);
+                    btn_next.set_sensitive(enable_next);
+                }
+
+                Continue(true)
+            });
+        }
+
+        Some(container)
     }
 }
 
-impl MpdModule {
 /// Replaces each of the formatting tokens in the formatting string
 /// with actual data pulled from MPD
-    async fn replace_tokens(
+fn replace_tokens(
-        &self,
     format_string: &str,
     tokens: &Vec<String>,
     song: &Song,
     status: &Status,
+    icons: &Icons,
 ) -> String {
     let mut compiled_string = format_string.to_string();
     for token in tokens {
-            let value = self.get_token_value(song, status, token).await;
+        let value = get_token_value(song, status, icons, token);
         compiled_string =
             compiled_string.replace(format!("{{{}}}", token).as_str(), value.as_str());
     }
@@ -218,13 +401,13 @@ impl MpdModule {
 
 /// Converts a string format token value
 /// into its respective MPD value.
-    pub async fn get_token_value(&self, song: &Song, status: &Status, token: &str) -> String {
+fn get_token_value(song: &Song, status: &Status, icons: &Icons, token: &str) -> String {
     let s = match token {
         "icon" => {
             let icon = match status.state {
                 PlayState::Stopped => None,
-                    PlayState::Playing => self.icon_play.as_ref(),
+                PlayState::Playing => icons.play.as_ref(),
-                    PlayState::Paused => self.icon_pause.as_ref(),
+                PlayState::Paused => icons.pause.as_ref(),
             };
             icon.map(String::as_str)
         }
@@ -242,4 +425,26 @@ impl MpdModule {
     };
     s.unwrap_or_default().to_string()
 }
+
+#[derive(Clone)]
+struct IconLabel {
+    label: Label,
+    container: gtk::Box,
+}
+
+impl IconLabel {
+    fn new(icon: &str, label: Option<&str>) -> Self {
+        let container = gtk::Box::new(Orientation::Horizontal, 5);
+
+        let icon = Label::new(Some(icon));
+        let label = Label::new(label);
+
+        icon.style_context().add_class("icon");
+        label.style_context().add_class("label");
+
+        container.add(&icon);
+        container.add(&label);
+
+        Self { label, container }
+    }
 }

src/modules/mpd/popup.rs

@@ -1,175 +0,0 @@
-pub use crate::popup::Popup;
-use gtk::gdk_pixbuf::Pixbuf;
-use gtk::prelude::*;
-use gtk::{Button, Image, Label, Orientation};
-use mpd_client::commands::responses::{PlayState, Song, Status};
-use std::path::Path;
-use tokio::sync::mpsc;
-
-#[derive(Clone)]
-struct IconLabel {
-    label: Label,
-    container: gtk::Box,
-}
-
-impl IconLabel {
-    fn new(icon: &str, label: Option<&str>) -> Self {
-        let container = gtk::Box::new(Orientation::Horizontal, 5);
-
-        let icon = Label::new(Some(icon));
-        let label = Label::new(label);
-
-        icon.style_context().add_class("icon");
-        label.style_context().add_class("label");
-
-        container.add(&icon);
-        container.add(&label);
-
-        Self { label, container }
-    }
-}
-
-#[derive(Clone)]
-pub struct MpdPopup {
-    pub popup: Popup,
-
-    cover: Image,
-
-    title: IconLabel,
-    album: IconLabel,
-    artist: IconLabel,
-
-    btn_prev: Button,
-    btn_play_pause: Button,
-    btn_next: Button,
-}
-
-#[derive(Debug)]
-pub enum PopupEvent {
-    Previous,
-    Toggle,
-    Next,
-}
-
-impl MpdPopup {
-    pub fn new(popup: Popup, tx: mpsc::Sender<PopupEvent>) -> Self {
-        let album_image = Image::builder()
-            .width_request(128)
-            .height_request(128)
-            .name("album-art")
-            .build();
-
-        let info_box = gtk::Box::new(Orientation::Vertical, 10);
-
-        let title_label = IconLabel::new("\u{f886}", None);
-        let album_label = IconLabel::new("\u{f524}", None);
-        let artist_label = IconLabel::new("\u{fd01}", None);
-
-        title_label.container.set_widget_name("title");
-        album_label.container.set_widget_name("album");
-        artist_label.container.set_widget_name("label");
-
-        info_box.add(&title_label.container);
-        info_box.add(&album_label.container);
-        info_box.add(&artist_label.container);
-
-        let controls_box = gtk::Box::builder().name("controls").build();
-
-        let btn_prev = Button::builder().label("\u{f9ad}").name("btn-prev").build();
-        let btn_play_pause = Button::builder().label("").name("btn-play-pause").build();
-        let btn_next = Button::builder().label("\u{f9ac}").name("btn-next").build();
-
-        controls_box.add(&btn_prev);
-        controls_box.add(&btn_play_pause);
-        controls_box.add(&btn_next);
-
-        info_box.add(&controls_box);
-
-        popup.container.add(&album_image);
-        popup.container.add(&info_box);
-
-        let tx_prev = tx.clone();
-        btn_prev.connect_clicked(move |_| {
-            tx_prev
-                .try_send(PopupEvent::Previous)
-                .expect("Failed to send prev track message");
-        });
-
-        let tx_toggle = tx.clone();
-        btn_play_pause.connect_clicked(move |_| {
-            tx_toggle
-                .try_send(PopupEvent::Toggle)
-                .expect("Failed to send play/pause track message");
-        });
-
-        let tx_next = tx;
-        btn_next.connect_clicked(move |_| {
-            tx_next
-                .try_send(PopupEvent::Next)
-                .expect("Failed to send next track message");
-        });
-
-        Self {
-            popup,
-            cover: album_image,
-            artist: artist_label,
-            album: album_label,
-            title: title_label,
-            btn_prev,
-            btn_play_pause,
-            btn_next,
-        }
-    }
-
-    pub fn update(&self, song: &Song, status: &Status, path: &Path) {
-        let prev_album = self.album.label.text();
-        let curr_album = song.album().unwrap_or_default();
-
-        // only update art when album changes
-        if prev_album != curr_album {
-            let cover_path = path.join(
-                song.file_path()
-                    .parent()
-                    .expect("Song path should not be root")
-                    .join("cover.jpg"),
-            );
-
-            if let Ok(pixbuf) = Pixbuf::from_file_at_scale(cover_path, 128, 128, true) {
-                self.cover.set_from_pixbuf(Some(&pixbuf));
-            }
-        }
-
-        self.title.label.set_text(song.title().unwrap_or_default());
-        self.album.label.set_text(song.album().unwrap_or_default());
-        self.artist
-            .label
-            .set_text(song.artists().first().unwrap_or(&String::new()));
-
-        match status.state {
-            PlayState::Stopped => {
-                self.btn_play_pause.set_sensitive(false);
-            }
-            PlayState::Playing => {
-                self.btn_play_pause.set_sensitive(true);
-                self.btn_play_pause.set_label("");
-            }
-            PlayState::Paused => {
-                self.btn_play_pause.set_sensitive(true);
-                self.btn_play_pause.set_label("");
-            }
-        }
-
-        let enable_prev = match status.current_song {
-            Some((pos, _)) => pos.0 > 0,
-            None => false,
-        };
-
-        let enable_next = match status.current_song {
-            Some((pos, _)) => pos.0 < status.playlist_length,
-            None => false,
-        };
-
-        self.btn_prev.set_sensitive(enable_prev);
-        self.btn_next.set_sensitive(enable_next);
-    }
-}

src/modules/script.rs

@@ -1,16 +1,19 @@
-use crate::modules::{Module, ModuleInfo};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use color_eyre::{eyre::Report, eyre::Result, eyre::WrapErr, Section};
 use gtk::prelude::*;
 use gtk::Label;
 use serde::Deserialize;
 use std::process::Command;
 use tokio::spawn;
+use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::time::sleep;
 use tracing::{error, instrument};
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct ScriptModule {
+    /// Path to script to execute.
     path: String,
+    /// Time in milliseconds between executions.
     #[serde(default = "default_interval")]
     interval: u64,
 }
@@ -21,39 +24,62 @@ const fn default_interval() -> u64 {
 }
 
 impl Module<Label> for ScriptModule {
-    fn into_widget(self, _info: &ModuleInfo) -> Result<Label> {
+    type SendMessage = String;
-        let label = Label::builder().use_markup(true).build();
+    type ReceiveMessage = ();
 
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        _rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        let interval = self.interval;
+        let path = self.path.clone();
         spawn(async move {
             loop {
-                match self.run_script() {
+                match run_script(&path) {
-                    Ok(stdout) => tx.send(stdout).expect("Failed to send stdout"),
+                    Ok(stdout) => tx
+                        .send(ModuleUpdateEvent::Update(stdout))
+                        .await
+                        .expect("Failed to send stdout"),
                     Err(err) => error!("{:?}", err),
                 }
 
-                sleep(tokio::time::Duration::from_millis(self.interval)).await;
+                sleep(tokio::time::Duration::from_millis(interval)).await;
             }
         });
 
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<Label>> {
+        let label = Label::builder().use_markup(true).build();
+        label.set_angle(info.bar_position.get_angle());
+
         {
             let label = label.clone();
-            rx.attach(None, move |s| {
+            context.widget_rx.attach(None, move |s| {
                 label.set_label(s.as_str());
                 Continue(true)
             });
         }
 
-        Ok(label)
+        Ok(ModuleWidget {
+            widget: label,
+            popup: None,
+        })
     }
 }
 
-impl ScriptModule {
 #[instrument]
-    fn run_script(&self) -> Result<String> {
+fn run_script(path: &str) -> Result<String> {
     let output = Command::new("sh")
         .arg("-c")
-            .arg(&self.path)
+        .arg(path)
         .output()
         .wrap_err("Failed to get script output")?;
 
@@ -74,4 +100,3 @@ impl ScriptModule {
             .suggestion("Check the script for errors"))
     }
 }
-}

src/modules/sysinfo.rs

@@ -1,34 +1,31 @@
-use crate::modules::{Module, ModuleInfo};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use color_eyre::Result;
 use gtk::prelude::*;
-use gtk::{Label, Orientation};
+use gtk::Label;
 use regex::{Captures, Regex};
 use serde::Deserialize;
 use std::collections::HashMap;
 use sysinfo::{CpuExt, System, SystemExt};
 use tokio::spawn;
+use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::time::sleep;
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct SysInfoModule {
+    /// List of formatting strings.
     format: Vec<String>,
 }
 
 impl Module<gtk::Box> for SysInfoModule {
-    fn into_widget(self, _info: &ModuleInfo) -> Result<gtk::Box> {
+    type SendMessage = HashMap<String, String>;
-        let re = Regex::new(r"\{([\w-]+)}")?;
+    type ReceiveMessage = ();
 
-        let container = gtk::Box::new(Orientation::Horizontal, 10);
+    fn spawn_controller(
-
+        &self,
-        let mut labels = Vec::new();
+        _info: &ModuleInfo,
-
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
-        for format in &self.format {
+        _rx: Receiver<Self::ReceiveMessage>,
-            let label = Label::builder().label(format).name("item").build();
+    ) -> Result<()> {
-            container.add(&label);
-            labels.push(label);
-        }
-
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
         spawn(async move {
             let mut sys = System::new_all();
 
@@ -44,19 +41,47 @@ impl Module<gtk::Box> for SysInfoModule {
 
                 // TODO: Add remaining format info
 
-                format_info.insert("memory-percent", format!("{:0>2.0}", memory_percent));
+                format_info.insert(
-                format_info.insert("cpu-percent", format!("{:0>2.0}", cpu_percent));
+                    String::from("memory-percent"),
+                    format!("{:0>2.0}", memory_percent),
+                );
+                format_info.insert(
+                    String::from("cpu-percent"),
+                    format!("{:0>2.0}", cpu_percent),
+                );
 
-                tx.send(format_info)
+                tx.send(ModuleUpdateEvent::Update(format_info))
+                    .await
                     .expect("Failed to send system info map");
 
                 sleep(tokio::time::Duration::from_secs(1)).await;
             }
         });
 
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<gtk::Box>> {
+        let re = Regex::new(r"\{([\w-]+)}")?;
+
+        let container = gtk::Box::new(info.bar_position.get_orientation(), 10);
+
+        let mut labels = Vec::new();
+
+        for format in &self.format {
+            let label = Label::builder().label(format).name("item").build();
+            label.set_angle(info.bar_position.get_angle());
+            container.add(&label);
+            labels.push(label);
+        }
+
         {
             let formats = self.format;
-            rx.attach(None, move |info| {
+            context.widget_rx.attach(None, move |info| {
                 for (format, label) in formats.iter().zip(labels.clone()) {
                     let format_compiled = re.replace(format, |caps: &Captures| {
                         info.get(&caps[1])
@@ -71,6 +96,9 @@ impl Module<gtk::Box> for SysInfoModule {
             });
         }
 
-        Ok(container)
+        Ok(ModuleWidget {
+            widget: container,
+            popup: None,
+        })
     }
 }

src/modules/tray/client.rs

@@ -0,0 +1,74 @@
+use async_once::AsyncOnce;
+use lazy_static::lazy_static;
+use stray::message::{NotifierItemCommand, NotifierItemMessage};
+use stray::StatusNotifierWatcher;
+use tokio::spawn;
+use tokio::sync::{broadcast, mpsc};
+use tracing::debug;
+
+pub struct TrayEventReceiver {
+    tx: mpsc::Sender<NotifierItemCommand>,
+    b_tx: broadcast::Sender<NotifierItemMessage>,
+    _b_rx: broadcast::Receiver<NotifierItemMessage>,
+}
+
+impl TrayEventReceiver {
+    async fn new() -> stray::error::Result<Self> {
+        let (tx, rx) = mpsc::channel(16);
+        let (b_tx, b_rx) = broadcast::channel(16);
+
+        let tray = StatusNotifierWatcher::new(rx).await?;
+        let mut host = tray.create_notifier_host("ironbar").await?;
+
+        let b_tx2 = b_tx.clone();
+        spawn(async move {
+            while let Ok(message) = host.recv().await {
+                b_tx2.send(message)?;
+            }
+
+            Ok::<(), broadcast::error::SendError<NotifierItemMessage>>(())
+        });
+
+        Ok(Self {
+            tx,
+            b_tx,
+            _b_rx: b_rx,
+        })
+    }
+
+    pub fn subscribe(
+        &self,
+    ) -> (
+        mpsc::Sender<NotifierItemCommand>,
+        broadcast::Receiver<NotifierItemMessage>,
+    ) {
+        (self.tx.clone(), self.b_tx.subscribe())
+    }
+}
+
+lazy_static! {
+    static ref CLIENT: AsyncOnce<TrayEventReceiver> = AsyncOnce::new(async {
+        const MAX_RETRIES: i32 = 10;
+
+        // sometimes this can fail
+        let mut retries = 0;
+
+        let value = loop {
+            retries += 1;
+
+            let tray = TrayEventReceiver::new().await;
+
+            if tray.is_ok() || retries == MAX_RETRIES {
+                break tray;
+            }
+
+            debug!("Failed to create StatusNotifierWatcher (attempt {retries})");
+        };
+
+        value.expect("Failed to create StatusNotifierWatcher")
+    });
+}
+
+pub async fn get_tray_event_client() -> &'static TrayEventReceiver {
+    CLIENT.get().await
+}

src/modules/tray/mod.rs

@@ -1,26 +1,23 @@
-use crate::modules::{Module, ModuleInfo};
+mod client;
+
+use crate::await_sync;
+use crate::modules::tray::client::get_tray_event_client;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use color_eyre::Result;
-use futures_util::StreamExt;
 use gtk::prelude::*;
 use gtk::{IconLookupFlags, IconTheme, Image, Menu, MenuBar, MenuItem, SeparatorMenuItem};
 use serde::Deserialize;
 use std::collections::HashMap;
-use stray::message::menu::{MenuItem as MenuItemInfo, MenuType, TrayMenu};
+use stray::message::menu::{MenuItem as MenuItemInfo, MenuType};
 use stray::message::tray::StatusNotifierItem;
 use stray::message::{NotifierItemCommand, NotifierItemMessage};
-use stray::SystemTray;
 use tokio::spawn;
 use tokio::sync::mpsc;
+use tokio::sync::mpsc::{Receiver, Sender};
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct TrayModule;
 
-#[derive(Debug)]
-enum TrayUpdate {
-    Update(String, Box<StatusNotifierItem>, Option<TrayMenu>),
-    Remove(String),
-}
-
 /// Gets a GTK `Image` component
 /// for the status notifier item's icon.
 fn get_icon(item: &StatusNotifierItem) -> Option<Image> {
@@ -39,7 +36,7 @@ fn get_icon(item: &StatusNotifierItem) -> Option<Image> {
 /// for the provided submenu array.
 fn get_menu_items(
     menu: &[MenuItemInfo],
-    tx: &mpsc::Sender<NotifierItemCommand>,
+    tx: &Sender<NotifierItemCommand>,
     id: &str,
     path: &str,
 ) -> Vec<MenuItem> {
@@ -90,72 +87,88 @@ fn get_menu_items(
 }
 
 impl Module<MenuBar> for TrayModule {
-    fn into_widget(self, _info: &ModuleInfo) -> Result<MenuBar> {
+    type SendMessage = NotifierItemMessage;
-        let container = MenuBar::new();
+    type ReceiveMessage = NotifierItemCommand;
 
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
+    fn spawn_controller(
-        let (ui_tx, ui_rx) = mpsc::channel(32);
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        mut rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        let client = await_sync(async { get_tray_event_client().await });
+        let (tray_tx, mut tray_rx) = client.subscribe();
 
+        // listen to tray updates
         spawn(async move {
-            // FIXME: Can only spawn one of these at a time - means cannot have tray on multiple bars
+            while let Ok(message) = tray_rx.recv().await {
-            let mut tray = SystemTray::new(ui_rx).await;
+                tx.send(ModuleUpdateEvent::Update(message)).await?;
+            }
 
-            // listen for tray updates & send message to update UI
+            Ok::<(), mpsc::error::SendError<ModuleUpdateEvent<Self::SendMessage>>>(())
-            while let Some(message) = tray.next().await {
-                match message {
-                    NotifierItemMessage::Update {
-                        address: id,
-                        item,
-                        menu,
-                    } => {
-                        tx.send(TrayUpdate::Update(id, Box::new(item), menu))
-                            .expect("Failed to send tray update event");
-                    }
-                    NotifierItemMessage::Remove { address: id } => {
-                        tx.send(TrayUpdate::Remove(id))
-                            .expect("Failed to send tray remove event");
-                    }
-                }
-            }
         });
 
+        // send tray commands
+        spawn(async move {
+            while let Some(cmd) = rx.recv().await {
+                tray_tx.send(cmd).await?;
+            }
+
+            Ok::<(), mpsc::error::SendError<NotifierItemCommand>>(())
+        });
+
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        _info: &ModuleInfo,
+    ) -> Result<ModuleWidget<MenuBar>> {
+        let container = MenuBar::new();
+
         {
             let container = container.clone();
             let mut widgets = HashMap::new();
 
             // listen for UI updates
-            rx.attach(None, move |update| {
+            context.widget_rx.attach(None, move |update| {
                 match update {
-                    TrayUpdate::Update(id, item, menu) => {
+                    NotifierItemMessage::Update {
-                        let menu_item = widgets.remove(id.as_str()).unwrap_or_else(|| {
+                        item,
+                        address,
+                        menu,
+                    } => {
+                        let menu_item = widgets.remove(address.as_str()).unwrap_or_else(|| {
                             let menu_item = MenuItem::new();
                             menu_item.style_context().add_class("item");
                             if let Some(image) = get_icon(&item) {
-                                image.set_widget_name(id.as_str());
+                                image.set_widget_name(address.as_str());
                                 menu_item.add(&image);
                             }
-
                             container.add(&menu_item);
                             menu_item.show_all();
-
                             menu_item
                         });
-
                         if let (Some(menu_opts), Some(menu_path)) = (menu, item.menu) {
                             let submenus = menu_opts.submenus;
                             if !submenus.is_empty() {
                                 let menu = Menu::new();
-                                get_menu_items(&submenus, &ui_tx.clone(), &id, &menu_path)
+                                get_menu_items(
+                                    &submenus,
+                                    &context.controller_tx.clone(),
+                                    &address,
+                                    &menu_path,
+                                )
                                 .iter()
                                 .for_each(|item| menu.add(item));
                                 menu_item.set_submenu(Some(&menu));
                             }
                         }
-
+                        widgets.insert(address, menu_item);
-                        widgets.insert(id, menu_item);
                     }
-                    TrayUpdate::Remove(id) => {
+                    NotifierItemMessage::Remove { address } => {
-                        if let Some(widget) = widgets.get(&id) {
+                        if let Some(widget) = widgets.get(&address) {
                             container.remove(widget);
                         }
                     }
@@ -165,6 +178,9 @@ impl Module<MenuBar> for TrayModule {
             });
         };
 
-        Ok(container)
+        Ok(ModuleWidget {
+            widget: container,
+            popup: None,
+        })
     }
 }

src/modules/workspaces.rs

@@ -1,40 +1,53 @@
-use crate::modules::{Module, ModuleInfo};
+use crate::await_sync;
-use crate::sway::{SwayClient, Workspace, WorkspaceEvent};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::sway::{get_client, get_sub_client};
 use color_eyre::{Report, Result};
 use gtk::prelude::*;
-use gtk::{Button, Orientation};
+use gtk::Button;
-use ksway::{IpcCommand, IpcEvent};
 use serde::Deserialize;
 use std::collections::HashMap;
+use swayipc_async::{Workspace, WorkspaceChange, WorkspaceEvent};
 use tokio::spawn;
-use tokio::sync::mpsc;
+use tokio::sync::mpsc::{Receiver, Sender};
-use tokio::task::spawn_blocking;
+use tracing::trace;
-use tracing::error;
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct WorkspacesModule {
+    /// Map of actual workspace names to custom names.
     name_map: Option<HashMap<String, String>>,
 
+    /// Whether to display buttons for all monitors.
     #[serde(default = "crate::config::default_false")]
     all_monitors: bool,
 }
 
-impl Workspace {
+#[derive(Clone, Debug)]
-    fn as_button(&self, name_map: &HashMap<String, String>, tx: &mpsc::Sender<String>) -> Button {
+pub enum WorkspaceUpdate {
+    Init(Vec<Workspace>),
+    Update(Box<WorkspaceEvent>),
+}
+
+/// Creates a button from a workspace
+fn create_button(
+    name: &str,
+    focused: bool,
+    name_map: &HashMap<String, String>,
+    tx: &Sender<String>,
+) -> Button {
     let button = Button::builder()
-            .label(name_map.get(self.name.as_str()).unwrap_or(&self.name))
+        .label(name_map.get(name).map_or(name, String::as_str))
         .build();
 
     let style_context = button.style_context();
     style_context.add_class("item");
 
-        if self.focused {
+    if focused {
         style_context.add_class("focused");
     }
 
     {
         let tx = tx.clone();
-            let name = self.name.clone();
+        let name = name.to_string();
         button.connect_clicked(move |_item| {
             tx.try_send(name.clone())
                 .expect("Failed to send workspace click event");
@@ -43,21 +56,29 @@ impl Workspace {
 
     button
 }
-}
 
 impl Module<gtk::Box> for WorkspacesModule {
-    fn into_widget(self, info: &ModuleInfo) -> Result<gtk::Box> {
+    type SendMessage = WorkspaceUpdate;
-        let mut sway = SwayClient::connect()?;
+    type ReceiveMessage = String;
-
-        let container = gtk::Box::new(Orientation::Horizontal, 0);
 
+    fn spawn_controller(
+        &self,
+        info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        mut rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
         let workspaces = {
-            let raw = sway.ipc(IpcCommand::GetWorkspaces)?;
+            trace!("Getting current workspaces");
-            let workspaces = serde_json::from_slice::<Vec<Workspace>>(&raw)?;
+            let workspaces = await_sync(async {
+                let sway = get_client().await;
+                let mut sway = sway.lock().await;
+                sway.get_workspaces().await
+            })?;
 
             if self.all_monitors {
                 workspaces
             } else {
+                trace!("Filtering workspaces to current monitor only");
                 workspaces
                     .into_iter()
                     .filter(|workspace| workspace.output == info.output_name)
@@ -65,84 +86,154 @@ impl Module<gtk::Box> for WorkspacesModule {
             }
         };
 
-        let name_map = self.name_map.unwrap_or_default();
+        tx.try_send(ModuleUpdateEvent::Update(WorkspaceUpdate::Init(workspaces)))
-
+            .expect("Failed to send initial workspace list");
-        let mut button_map: HashMap<String, Button> = HashMap::new();
-
-        let (ui_tx, mut ui_rx) = mpsc::channel(32);
-
-        for workspace in workspaces {
-            let item = workspace.as_button(&name_map, &ui_tx);
-            container.add(&item);
-            button_map.insert(workspace.name, item);
-        }
-
-        let srx = sway.subscribe(vec![IpcEvent::Workspace])?;
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-
-        spawn_blocking(move || loop {
-            while let Ok((_, payload)) = srx.try_recv() {
-                match serde_json::from_slice::<WorkspaceEvent>(&payload) {
-                    Ok(payload) => tx.send(payload).expect("Failed to send workspace event"),
-                    Err(err) => error!("{:?}", err),
-                }
-            }
-
-            if let Err(err) = sway.poll() {
-                error!("{:?}", err);
-            }
-        });
-
-        {
-            let menubar = container.clone();
-            let output_name = info.output_name.to_string();
-            rx.attach(None, move |event| {
-                match event.change.as_str() {
-                    "focus" => {
-                        let old = event.old.and_then(|old| button_map.get(&old.name));
-                        if let Some(old) = old {
-                            old.style_context().remove_class("focused");
-                        }
-
-                        let new = event.current.and_then(|new| button_map.get(&new.name));
-                        if let Some(new) = new {
-                            new.style_context().add_class("focused");
-                        }
-                    }
-                    "init" => {
-                        if let Some(workspace) = event.current {
-                            if self.all_monitors || workspace.output == output_name {
-                                let item = workspace.as_button(&name_map, &ui_tx);
-
-                                item.show();
-                                menubar.add(&item);
-                                button_map.insert(workspace.name, item);
-                            }
-                        }
-                    }
-                    "empty" => {
-                        if let Some(workspace) = event.current {
-                            if let Some(item) = button_map.get(&workspace.name) {
-                                menubar.remove(item);
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-
-                Continue(true)
-            });
-        }
 
+        // Subscribe & send events
         spawn(async move {
-            let mut sway = SwayClient::connect()?;
+            let mut srx = {
-            while let Some(name) = ui_rx.recv().await {
+                let sway = get_sub_client();
-                sway.run(format!("workspace {}", name))?;
+                sway.subscribe_workspace()
+            };
+
+            trace!("Set up Sway workspace subscription");
+
+            while let Ok(payload) = srx.recv().await {
+                tx.send(ModuleUpdateEvent::Update(WorkspaceUpdate::Update(payload)))
+                    .await
+                    .expect("Failed to send workspace update");
+            }
+        });
+
+        // Change workspace focus
+        spawn(async move {
+            trace!("Setting up UI event handler");
+            let sway = get_client().await;
+            while let Some(name) = rx.recv().await {
+                let mut sway = sway.lock().await;
+                sway.run_command(format!("workspace {}", name)).await?;
             }
 
             Ok::<(), Report>(())
         });
 
-        Ok(container)
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<gtk::Box>> {
+        let container = gtk::Box::new(info.bar_position.get_orientation(), 0);
+
+        let name_map = self.name_map.unwrap_or_default();
+
+        let mut button_map: HashMap<String, Button> = HashMap::new();
+
+        {
+            let container = container.clone();
+            let output_name = info.output_name.to_string();
+
+            context.widget_rx.attach(None, move |event| {
+                match event {
+                    WorkspaceUpdate::Init(workspaces) => {
+                        trace!("Creating workspace buttons");
+                        for workspace in workspaces {
+                            let item = create_button(
+                                &workspace.name,
+                                workspace.focused,
+                                &name_map,
+                                &context.controller_tx,
+                            );
+                            container.add(&item);
+                            button_map.insert(workspace.name, item);
+                        }
+                        container.show_all();
+                    }
+                    WorkspaceUpdate::Update(event) if event.change == WorkspaceChange::Focus => {
+                        let old = event
+                            .old
+                            .and_then(|old| old.name)
+                            .and_then(|name| button_map.get(&name));
+                        if let Some(old) = old {
+                            old.style_context().remove_class("focused");
+                        }
+
+                        let new = event
+                            .current
+                            .and_then(|old| old.name)
+                            .and_then(|new| button_map.get(&new));
+                        if let Some(new) = new {
+                            new.style_context().add_class("focused");
+                        }
+                    }
+                    WorkspaceUpdate::Update(event) if event.change == WorkspaceChange::Init => {
+                        if let Some(workspace) = event.current {
+                            if self.all_monitors
+                                || workspace.output.unwrap_or_default() == output_name
+                            {
+                                let name = workspace.name.unwrap_or_default();
+                                let item = create_button(
+                                    &name,
+                                    workspace.focused,
+                                    &name_map,
+                                    &context.controller_tx,
+                                );
+
+                                item.show();
+                                container.add(&item);
+
+                                if !name.is_empty() {
+                                    button_map.insert(name, item);
+                                }
+                            }
+                        }
+                    }
+                    WorkspaceUpdate::Update(event) if event.change == WorkspaceChange::Move => {
+                        if let Some(workspace) = event.current {
+                            if !self.all_monitors {
+                                if workspace.output.unwrap_or_default() == output_name {
+                                    let name = workspace.name.unwrap_or_default();
+                                    let item = create_button(
+                                        &name,
+                                        workspace.focused,
+                                        &name_map,
+                                        &context.controller_tx,
+                                    );
+
+                                    item.show();
+                                    container.add(&item);
+
+                                    if !name.is_empty() {
+                                        button_map.insert(name, item);
+                                    }
+                                } else if let Some(item) =
+                                    button_map.get(&workspace.name.unwrap_or_default())
+                                {
+                                    container.remove(item);
+                                }
+                            }
+                        }
+                    }
+                    WorkspaceUpdate::Update(event) if event.change == WorkspaceChange::Empty => {
+                        if let Some(workspace) = event.current {
+                            if let Some(item) = button_map.get(&workspace.name.unwrap_or_default())
+                            {
+                                container.remove(item);
+                            }
+                        }
+                    }
+                    WorkspaceUpdate::Update(_) => {}
+                };
+
+                Continue(true)
+            });
+        }
+
+        Ok(ModuleWidget {
+            widget: container,
+            popup: None,
+        })
     }
 }

src/popup.rs

@@ -1,24 +1,31 @@
+use std::collections::HashMap;
+
 use crate::config::BarPosition;
+use crate::modules::ModuleInfo;
 use gtk::gdk::Monitor;
 use gtk::prelude::*;
-use gtk::{Application, ApplicationWindow, Button, Orientation};
+use gtk::{ApplicationWindow, Button, Orientation};
+use tracing::debug;
 
 #[derive(Debug, Clone)]
 pub struct Popup {
     pub window: ApplicationWindow,
-    pub container: gtk::Box,
+    pub cache: HashMap<usize, gtk::Box>,
     monitor: Monitor,
+    pos: BarPosition,
 }
 
 impl Popup {
-    pub fn new(
+    /// Creates a new popup window.
-        name: &str,
+    /// This includes setting up gtk-layer-shell
-        app: &Application,
+    /// and an empty `gtk::Box` container.
-        monitor: &Monitor,
+    pub fn new(module_info: &ModuleInfo) -> Self {
-        orientation: Orientation,
+        let pos = module_info.bar_position;
-        bar_position: &BarPosition,
+        let orientation = pos.get_orientation();
-    ) -> Self {
+
-        let win = ApplicationWindow::builder().application(app).build();
+        let win = ApplicationWindow::builder()
+            .application(module_info.app)
+            .build();
 
         gtk_layer_shell::init_for_window(&win);
         gtk_layer_shell::set_layer(&win, gtk_layer_shell::Layer::Overlay);
@@ -26,57 +33,69 @@ impl Popup {
         gtk_layer_shell::set_margin(
             &win,
             gtk_layer_shell::Edge::Top,
-            if bar_position == &BarPosition::Top {
+            if pos == BarPosition::Top { 5 } else { 0 },
-                5
-            } else {
-                0
-            },
         );
         gtk_layer_shell::set_margin(
             &win,
             gtk_layer_shell::Edge::Bottom,
-            if bar_position == &BarPosition::Bottom {
+            if pos == BarPosition::Bottom { 5 } else { 0 },
-                5
+        );
-            } else {
+        gtk_layer_shell::set_margin(
-                0
+            &win,
-            },
+            gtk_layer_shell::Edge::Left,
+            if pos == BarPosition::Left { 5 } else { 0 },
+        );
+        gtk_layer_shell::set_margin(
+            &win,
+            gtk_layer_shell::Edge::Right,
+            if pos == BarPosition::Right { 5 } else { 0 },
         );
-        gtk_layer_shell::set_margin(&win, gtk_layer_shell::Edge::Left, 0);
-        gtk_layer_shell::set_margin(&win, gtk_layer_shell::Edge::Right, 0);
 
         gtk_layer_shell::set_anchor(
             &win,
             gtk_layer_shell::Edge::Top,
-            bar_position == &BarPosition::Top,
+            pos == BarPosition::Top || orientation == Orientation::Vertical,
         );
         gtk_layer_shell::set_anchor(
             &win,
             gtk_layer_shell::Edge::Bottom,
-            bar_position == &BarPosition::Bottom,
+            pos == BarPosition::Bottom,
+        );
+        gtk_layer_shell::set_anchor(
+            &win,
+            gtk_layer_shell::Edge::Left,
+            pos == BarPosition::Left || orientation == Orientation::Horizontal,
+        );
+        gtk_layer_shell::set_anchor(
+            &win,
+            gtk_layer_shell::Edge::Right,
+            pos == BarPosition::Right,
         );
-        gtk_layer_shell::set_anchor(&win, gtk_layer_shell::Edge::Left, true);
-        gtk_layer_shell::set_anchor(&win, gtk_layer_shell::Edge::Right, false);
 
-        let content = gtk::Box::builder()
+        win.connect_leave_notify_event(move |win, ev| {
-            .orientation(orientation)
-            .spacing(0)
-            .hexpand(false)
-            .name(name)
-            .build();
-
-        content.style_context().add_class("popup");
-
-        win.add(&content);
-
-        win.connect_leave_notify_event(|win, ev| {
             const THRESHOLD: f64 = 3.0;
 
-            let (w, _h) = win.size();
+            let (w, h) = win.size();
             let (x, y) = ev.position();
 
             // some child widgets trigger this event
             // so check we're actually outside the window
-            if x < THRESHOLD || y < THRESHOLD || x > f64::from(w) - THRESHOLD {
+            let hide = match pos {
+                BarPosition::Top => {
+                    x < THRESHOLD || y > f64::from(h) - THRESHOLD || x > f64::from(w) - THRESHOLD
+                }
+                BarPosition::Bottom => {
+                    x < THRESHOLD || y < THRESHOLD || x > f64::from(w) - THRESHOLD
+                }
+                BarPosition::Left => {
+                    y < THRESHOLD || x > f64::from(w) - THRESHOLD || y > f64::from(h) - THRESHOLD
+                }
+                BarPosition::Right => {
+                    y < THRESHOLD || x < THRESHOLD || y > f64::from(h) - THRESHOLD
+                }
+            };
+
+            if hide {
                 win.hide();
             }
 
@@ -85,15 +104,37 @@ impl Popup {
 
         Self {
             window: win,
-            container: content,
+            cache: HashMap::new(),
-            monitor: monitor.clone(),
+            monitor: module_info.monitor.clone(),
+            pos,
         }
     }
 
-    /// Shows the popover
+    pub fn register_content(&mut self, key: usize, content: gtk::Box) {
-    pub fn show(&self, button: &Button) {
+        debug!("Registered popup content for #{}", key);
+        self.cache.insert(key, content);
+    }
+
+    pub fn show_content(&self, key: usize) {
+        self.clear_window();
+
+        if let Some(content) = self.cache.get(&key) {
+            content.style_context().add_class("popup");
+            self.window.add(content);
+        }
+    }
+
+    fn clear_window(&self) {
+        let children = self.window.children();
+        for child in children {
+            self.window.remove(&child);
+        }
+    }
+
+    /// Shows the popup
+    pub fn show(&self, geometry: ButtonGeometry) {
         self.window.show_all();
-        self.set_pos(button);
+        self.set_pos(geometry);
     }
 
     /// Hides the popover
@@ -101,27 +142,89 @@ impl Popup {
         self.window.hide();
     }
 
-    /// Sets the popover's X position relative to the left border of the screen
+    /// Checks if the popup is currently visible
-    fn set_pos(&self, button: &Button) {
+    pub fn is_visible(&self) -> bool {
-        let widget_width = button.allocation().width();
+        self.window.is_visible()
-        let screen_width = self.monitor.workarea().width();
+    }
-        let popup_width = self.window.allocated_width();
 
-        let top_level = button.toplevel().expect("Failed to get top-level widget");
+    /// Sets the popup's X/Y position relative to the left or border of the screen
-        let (widget_x, _) = button
+    /// (depending on orientation).
-            .translate_coordinates(&top_level, 0, 0)
+    fn set_pos(&self, geometry: ButtonGeometry) {
-            .unwrap_or((0, 0));
+        let orientation = self.pos.get_orientation();
 
-        let widget_center = f64::from(widget_x) + f64::from(widget_width) / 2.0;
+        let mon_workarea = self.monitor.workarea();
+        let screen_size = if orientation == Orientation::Horizontal {
+            mon_workarea.width()
+        } else {
+            mon_workarea.height()
+        };
 
-        let mut offset = (widget_center - (f64::from(popup_width) / 2.0)).round();
+        let (popup_width, popup_height) = self.window.size();
+        let popup_size = if orientation == Orientation::Horizontal {
+            popup_width
+        } else {
+            popup_height
+        };
+
+        let widget_center = f64::from(geometry.position) + f64::from(geometry.size) / 2.0;
+
+        let bar_offset = (f64::from(screen_size) - f64::from(geometry.bar_size)) / 2.0;
+
+        let mut offset = bar_offset + (widget_center - (f64::from(popup_size) / 2.0)).round();
 
         if offset < 5.0 {
             offset = 5.0;
-        } else if offset > f64::from(screen_width - popup_width) - 5.0 {
+        } else if offset > f64::from(screen_size - popup_size) - 5.0 {
-            offset = f64::from(screen_width - popup_width) - 5.0;
+            offset = f64::from(screen_size - popup_size) - 5.0;
         }
 
-        gtk_layer_shell::set_margin(&self.window, gtk_layer_shell::Edge::Left, offset as i32);
+        let edge = if orientation == Orientation::Horizontal {
+            gtk_layer_shell::Edge::Left
+        } else {
+            gtk_layer_shell::Edge::Top
+        };
+
+        gtk_layer_shell::set_margin(&self.window, edge, offset as i32);
+    }
+
+    /// Gets the absolute X position of the button
+    /// and its width / height (depending on orientation).
+    pub fn button_pos(button: &Button, orientation: Orientation) -> ButtonGeometry {
+        let button_size = if orientation == Orientation::Horizontal {
+            button.allocation().width()
+        } else {
+            button.allocation().height()
+        };
+
+        let top_level = button.toplevel().expect("Failed to get top-level widget");
+
+        let bar_size = if orientation == Orientation::Horizontal {
+            top_level.allocation().width()
+        } else {
+            top_level.allocation().height()
+        };
+
+        let (button_x, button_y) = button
+            .translate_coordinates(&top_level, 0, 0)
+            .unwrap_or((0, 0));
+
+        let button_pos = if orientation == Orientation::Horizontal {
+            button_x
+        } else {
+            button_y
+        };
+
+        ButtonGeometry {
+            position: button_pos,
+            size: button_size,
+            bar_size,
         }
     }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct ButtonGeometry {
+    position: i32,
+    size: i32,
+    bar_size: i32,
+}

src/style.rs

@@ -2,13 +2,16 @@ use color_eyre::{Help, Report};
 use glib::Continue;
 use gtk::prelude::CssProviderExt;
 use gtk::{gdk, gio, CssProvider, StyleContext};
-use notify::{DebouncedEvent, RecursiveMode, Watcher};
+use notify::{Event, RecursiveMode, Result, Watcher};
 use std::path::PathBuf;
-use std::sync::mpsc;
-use std::time::Duration;
 use tokio::spawn;
 use tracing::{error, info};
 
+/// Attempts to load CSS file at the given path
+/// and attach if to the current GTK application.
+///
+/// Installs a file watcher and reloads CSS when
+/// write changes are detected on the file.
 pub fn load_css(style_path: PathBuf) {
     let provider = CssProvider::new();
 
@@ -23,21 +26,22 @@ pub fn load_css(style_path: PathBuf) {
     let screen = gdk::Screen::default().expect("Failed to get default GTK screen");
     StyleContext::add_provider_for_screen(&screen, &provider, 800);
 
-    let (watcher_tx, watcher_rx) = mpsc::channel::<DebouncedEvent>();
     let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
 
     spawn(async move {
-        match notify::watcher(watcher_tx, Duration::from_millis(500)) {
+        match notify::recommended_watcher(move |res: Result<Event>| match res {
+            Ok(event) => {
+                if let Some(path) = event.paths.first() {
+                    tx.send(path.clone())
+                        .expect("Failed to send style changed message");
+                }
+            }
+            Err(e) => error!("Error occurred when watching stylesheet: {:?}", e),
+        }) {
             Ok(mut watcher) => {
                 watcher
                     .watch(&style_path, RecursiveMode::NonRecursive)
                     .expect("Unexpected error when attempting to watch CSS");
-
-                loop {
-                    if let Ok(DebouncedEvent::Write(path)) = watcher_rx.recv() {
-                        tx.send(path).expect("Failed to send style changed message");
-                    }
-                }
             }
             Err(err) => error!(
                 "{:?}",

src/sway.rs

@@ -0,0 +1,74 @@
+use async_once::AsyncOnce;
+use color_eyre::Report;
+use futures_util::StreamExt;
+use lazy_static::lazy_static;
+use std::sync::Arc;
+use swayipc_async::{Connection, Event, EventType, WorkspaceEvent};
+use tokio::spawn;
+use tokio::sync::broadcast::{channel, Receiver, Sender};
+use tokio::sync::Mutex;
+use tracing::{info, trace};
+
+pub struct SwayEventClient {
+    workspace_tx: Sender<Box<WorkspaceEvent>>,
+    _workspace_rx: Receiver<Box<WorkspaceEvent>>,
+}
+
+impl SwayEventClient {
+    fn new() -> Self {
+        let (workspace_tx, workspace_rx) = channel(16);
+
+        let workspace_tx2 = workspace_tx.clone();
+
+        spawn(async move {
+            let workspace_tx = workspace_tx2;
+
+            let client = Connection::new().await?;
+            info!("Sway IPC subscription client connected");
+
+            let event_types = [EventType::Workspace];
+
+            let mut events = client.subscribe(event_types).await?;
+
+            while let Some(event) = events.next().await {
+                trace!("event: {:?}", event);
+                if let Event::Workspace(ev) = event? {
+                    workspace_tx.send(ev)?;
+                };
+            }
+
+            Ok::<(), Report>(())
+        });
+
+        Self {
+            workspace_tx,
+            _workspace_rx: workspace_rx,
+        }
+    }
+
+    /// Gets an event receiver for workspace events
+    pub fn subscribe_workspace(&self) -> Receiver<Box<WorkspaceEvent>> {
+        self.workspace_tx.subscribe()
+    }
+}
+
+lazy_static! {
+    static ref CLIENT: AsyncOnce<Arc<Mutex<Connection>>> = AsyncOnce::new(async {
+        let client = Connection::new()
+            .await
+            .expect("Failed to connect to Sway socket");
+        Arc::new(Mutex::new(client))
+    });
+    static ref SUB_CLIENT: SwayEventClient = SwayEventClient::new();
+}
+
+/// Gets the sway IPC client
+pub async fn get_client() -> Arc<Mutex<Connection>> {
+    let client = CLIENT.get().await;
+    Arc::clone(client)
+}
+
+/// Gets the sway IPC event subscription client
+pub fn get_sub_client() -> &'static SwayEventClient {
+    &SUB_CLIENT
+}

src/sway/mod.rs

@@ -1,109 +0,0 @@
-use color_eyre::{Report, Result};
-use ksway::{Error, IpcCommand, IpcEvent};
-use serde::Deserialize;
-
-pub mod node;
-
-#[derive(Deserialize, Debug)]
-pub struct WorkspaceEvent {
-    pub change: String,
-    pub old: Option<Workspace>,
-    pub current: Option<Workspace>,
-}
-
-#[derive(Deserialize, Debug)]
-pub struct Workspace {
-    pub name: String,
-    pub focused: bool,
-    // pub num: i32,
-    pub output: String,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct WindowEvent {
-    pub change: String,
-    pub container: SwayNode,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct SwayNode {
-    #[serde(rename = "type")]
-    pub node_type: String,
-    pub id: i32,
-    pub name: Option<String>,
-    pub app_id: Option<String>,
-    pub focused: bool,
-    pub urgent: bool,
-    pub nodes: Vec<SwayNode>,
-    pub floating_nodes: Vec<SwayNode>,
-    pub shell: Option<String>,
-    pub window_properties: Option<WindowProperties>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct WindowProperties {
-    pub class: Option<String>,
-}
-
-#[derive(Deserialize)]
-pub struct SwayOutput {
-    pub name: String,
-}
-
-pub struct SwayClient {
-    client: ksway::Client,
-}
-
-impl SwayClient {
-    pub(crate) fn run(&mut self, cmd: String) -> Result<Vec<u8>> {
-        match self.client.run(cmd) {
-            Ok(res) => Ok(res),
-            Err(err) => Err(get_client_error(err)),
-        }
-    }
-}
-
-impl SwayClient {
-    pub fn connect() -> Result<Self> {
-        let client = match ksway::Client::connect() {
-            Ok(client) => Ok(client),
-            Err(err) => Err(get_client_error(err)),
-        }?;
-
-        Ok(Self { client })
-    }
-
-    pub fn ipc(&mut self, command: IpcCommand) -> Result<Vec<u8>> {
-        match self.client.ipc(command) {
-            Ok(res) => Ok(res),
-            Err(err) => Err(get_client_error(err)),
-        }
-    }
-
-    pub fn subscribe(
-        &mut self,
-        event_types: Vec<IpcEvent>,
-    ) -> Result<crossbeam_channel::Receiver<(IpcEvent, Vec<u8>)>> {
-        match self.client.subscribe(event_types) {
-            Ok(res) => Ok(res),
-            Err(err) => Err(get_client_error(err)),
-        }
-    }
-
-    pub fn poll(&mut self) -> Result<()> {
-        match self.client.poll() {
-            Ok(()) => Ok(()),
-            Err(err) => Err(get_client_error(err)),
-        }
-    }
-}
-
-/// Gets an error report from a `ksway` error enum variant
-pub fn get_client_error(error: Error) -> Report {
-    match error {
-        Error::SockPathNotFound => Report::msg("Sway socket path not found"),
-        Error::SubscriptionError => Report::msg("Sway IPC subscription error"),
-        Error::AlreadySubscribed => Report::msg("Already subscribed to Sway IPC server"),
-        Error::Io(err) => Report::new(err),
-    }
-}

src/sway/node.rs

@@ -1,49 +0,0 @@
-use crate::sway::{SwayClient, SwayNode};
-use color_eyre::Result;
-use ksway::IpcCommand;
-
-impl SwayNode {
-    pub fn get_id(&self) -> &str {
-        self.app_id.as_ref().map_or_else(
-            || {
-                self.window_properties
-                    .as_ref()
-                    .expect("Cannot find node window properties")
-                    .class
-                    .as_ref()
-                    .expect("Cannot find node name")
-            },
-            |app_id| app_id,
-        )
-    }
-
-    pub fn is_xwayland(&self) -> bool {
-        self.shell == Some(String::from("xwayland"))
-    }
-}
-
-fn check_node(node: SwayNode, window_nodes: &mut Vec<SwayNode>) {
-    if node.name.is_some() && (node.node_type == "con" || node.node_type == "floating_con") {
-        window_nodes.push(node);
-    } else {
-        node.nodes.into_iter().for_each(|node| {
-            check_node(node, window_nodes);
-        });
-
-        node.floating_nodes.into_iter().for_each(|node| {
-            check_node(node, window_nodes);
-        });
-    }
-}
-
-impl SwayClient {
-    pub fn get_open_windows(&mut self) -> Result<Vec<SwayNode>> {
-        let root_node = self.ipc(IpcCommand::GetTree)?;
-        let root_node = serde_json::from_slice(&root_node)?;
-
-        let mut window_nodes = vec![];
-        check_node(root_node, &mut window_nodes);
-
-        Ok(window_nodes)
-    }
-}

src/wayland/client.rs

@@ -0,0 +1,125 @@
+use super::{Env, ToplevelHandler};
+use crate::collection::Collection;
+use crate::wayland::toplevel::{ToplevelEvent, ToplevelInfo};
+use crate::wayland::toplevel_manager::listen_for_toplevels;
+use crate::wayland::ToplevelChange;
+use smithay_client_toolkit::environment::Environment;
+use smithay_client_toolkit::output::{with_output_info, OutputInfo};
+use smithay_client_toolkit::reexports::calloop;
+use smithay_client_toolkit::{new_default_environment, WaylandSource};
+use std::sync::{Arc, RwLock};
+use std::time::Duration;
+use tokio::sync::{broadcast, oneshot};
+use tokio::task::spawn_blocking;
+use tracing::trace;
+use wayland_client::protocol::wl_seat::WlSeat;
+use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::{
+    zwlr_foreign_toplevel_handle_v1::ZwlrForeignToplevelHandleV1,
+    zwlr_foreign_toplevel_manager_v1::ZwlrForeignToplevelManagerV1,
+};
+
+pub struct WaylandClient {
+    pub outputs: Vec<OutputInfo>,
+    pub seats: Vec<WlSeat>,
+    pub toplevels: Arc<RwLock<Collection<usize, (ToplevelInfo, ZwlrForeignToplevelHandleV1)>>>,
+    toplevel_tx: broadcast::Sender<ToplevelEvent>,
+    _toplevel_rx: broadcast::Receiver<ToplevelEvent>,
+}
+
+impl WaylandClient {
+    pub(super) async fn new() -> Self {
+        let (output_tx, output_rx) = oneshot::channel();
+        let (seat_tx, seat_rx) = oneshot::channel();
+
+        let (toplevel_tx, toplevel_rx) = broadcast::channel(32);
+
+        let toplevel_tx2 = toplevel_tx.clone();
+
+        let toplevels = Arc::new(RwLock::new(Collection::new()));
+        let toplevels2 = toplevels.clone();
+
+        // `queue` is not send so we need to handle everything inside the task
+        spawn_blocking(move || {
+            let (env, _display, queue) =
+                new_default_environment!(Env, fields = [toplevel: ToplevelHandler::init()])
+                    .expect("Failed to connect to Wayland compositor");
+
+            let outputs = Self::get_outputs(&env);
+            output_tx
+                .send(outputs)
+                .expect("Failed to send outputs out of task");
+
+            let seats = env.get_all_seats();
+            seat_tx
+                .send(
+                    seats
+                        .into_iter()
+                        .map(|seat| seat.detach())
+                        .collect::<Vec<WlSeat>>(),
+                )
+                .expect("Failed to send seats out of task");
+
+            let _toplevel_manager = env.require_global::<ZwlrForeignToplevelManagerV1>();
+
+            let _listener = listen_for_toplevels(env, move |handle, event, _ddata| {
+                trace!("Received toplevel event: {:?}", event);
+
+                if event.change == ToplevelChange::Close {
+                    toplevels2
+                        .write()
+                        .expect("Failed to get write lock on toplevels")
+                        .remove(&event.toplevel.id);
+                } else {
+                    toplevels2
+                        .write()
+                        .expect("Failed to get write lock on toplevels")
+                        .insert(event.toplevel.id, (event.toplevel.clone(), handle));
+                }
+
+                toplevel_tx2
+                    .send(event)
+                    .expect("Failed to send toplevel event");
+            });
+
+            let mut event_loop =
+                calloop::EventLoop::<()>::try_new().expect("Failed to create new event loop");
+            WaylandSource::new(queue)
+                .quick_insert(event_loop.handle())
+                .expect("Failed to insert event loop into wayland event queue");
+
+            loop {
+                // TODO: Avoid need for duration here - can we force some event when sending requests?
+                event_loop
+                    .dispatch(Duration::from_millis(50), &mut ())
+                    .expect("Failed to dispatch pending wayland events");
+            }
+        });
+
+        let outputs = output_rx
+            .await
+            .expect("Failed to receive outputs from task");
+
+        let seats = seat_rx.await.expect("Failed to receive seats from task");
+
+        Self {
+            outputs,
+            seats,
+            toplevels,
+            toplevel_tx,
+            _toplevel_rx: toplevel_rx,
+        }
+    }
+
+    pub fn subscribe_toplevels(&self) -> broadcast::Receiver<ToplevelEvent> {
+        self.toplevel_tx.subscribe()
+    }
+
+    fn get_outputs(env: &Environment<Env>) -> Vec<OutputInfo> {
+        let outputs = env.get_all_outputs();
+
+        outputs
+            .iter()
+            .filter_map(|output| with_output_info(output, Clone::clone))
+            .collect()
+    }
+}

src/wayland/mod.rs

@@ -0,0 +1,54 @@
+mod client;
+mod toplevel;
+mod toplevel_manager;
+
+extern crate smithay_client_toolkit as sctk;
+
+use self::toplevel_manager::ToplevelHandler;
+pub use crate::wayland::toplevel::{ToplevelChange, ToplevelEvent, ToplevelInfo};
+use crate::wayland::toplevel_manager::{ToplevelHandling, ToplevelStatusListener};
+use async_once::AsyncOnce;
+use lazy_static::lazy_static;
+use wayland_client::{Attached, DispatchData, Interface};
+use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::{
+    zwlr_foreign_toplevel_handle_v1::ZwlrForeignToplevelHandleV1,
+    zwlr_foreign_toplevel_manager_v1::ZwlrForeignToplevelManagerV1,
+};
+
+pub use client::WaylandClient;
+
+/// A utility for lazy-loading globals.
+/// Taken from `smithay_client_toolkit` where it's not exposed
+#[derive(Debug)]
+enum LazyGlobal<I: Interface> {
+    Unknown,
+    Seen { id: u32, version: u32 },
+    Bound(Attached<I>),
+}
+
+sctk::default_environment!(Env,
+    fields = [
+        toplevel: ToplevelHandler
+    ],
+    singles = [
+        ZwlrForeignToplevelManagerV1 => toplevel
+    ],
+);
+
+impl ToplevelHandling for Env {
+    fn listen<F>(&mut self, f: F) -> ToplevelStatusListener
+    where
+        F: FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static,
+    {
+        self.toplevel.listen(f)
+    }
+}
+
+lazy_static! {
+    static ref CLIENT: AsyncOnce<WaylandClient> =
+        AsyncOnce::new(async { WaylandClient::new().await });
+}
+
+pub async fn get_client() -> &'static WaylandClient {
+    CLIENT.get().await
+}

src/wayland/toplevel.rs

@@ -0,0 +1,151 @@
+use std::collections::HashSet;
+use std::sync::{Arc, RwLock};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use tracing::trace;
+use wayland_client::{DispatchData, Main};
+use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::zwlr_foreign_toplevel_handle_v1::{Event, ZwlrForeignToplevelHandleV1};
+
+const STATE_ACTIVE: u32 = 2;
+const STATE_FULLSCREEN: u32 = 3;
+
+static COUNTER: AtomicUsize = AtomicUsize::new(1);
+fn get_id() -> usize {
+    COUNTER.fetch_add(1, Ordering::Relaxed)
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ToplevelInfo {
+    pub id: usize,
+    pub app_id: String,
+    pub title: String,
+    pub active: bool,
+    pub fullscreen: bool,
+
+    ready: bool,
+}
+
+impl ToplevelInfo {
+    fn new() -> Self {
+        let id = get_id();
+        Self {
+            id,
+            ..Default::default()
+        }
+    }
+}
+
+pub struct Toplevel;
+
+#[derive(Debug, Clone)]
+pub struct ToplevelEvent {
+    pub toplevel: ToplevelInfo,
+    pub change: ToplevelChange,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ToplevelChange {
+    New,
+    Close,
+    Title(String),
+    Focus(bool),
+    Fullscreen(bool),
+}
+
+fn toplevel_implem<F>(event: Event, info: &mut ToplevelInfo, implem: &mut F, ddata: DispatchData)
+where
+    F: FnMut(ToplevelEvent, DispatchData),
+{
+    trace!("event: {event:?} (info: {info:?})");
+
+    let change = match event {
+        Event::AppId { app_id } => {
+            info.app_id = app_id;
+            None
+        }
+        Event::Title { title } => {
+            info.title = title.clone();
+
+            if info.ready {
+                Some(ToplevelChange::Title(title))
+            } else {
+                None
+            }
+        }
+        Event::State { state } => {
+            // state is received as a `Vec<u8>` where every 4 bytes make up a `u32`
+            // the u32 then represents a value in the `State` enum.
+            assert_eq!(state.len() % 4, 0);
+
+            let state = (0..state.len() / 4)
+                .map(|i| {
+                    let slice: [u8; 4] = state[i * 4..i * 4 + 4]
+                        .try_into()
+                        .expect("Received invalid state length");
+                    u32::from_le_bytes(slice)
+                })
+                .collect::<HashSet<_>>();
+
+            let new_active = state.contains(&STATE_ACTIVE);
+            let new_fullscreen = state.contains(&STATE_FULLSCREEN);
+
+            let change = if info.ready && new_active != info.active {
+                Some(ToplevelChange::Focus(new_active))
+            } else if info.ready && new_fullscreen != info.fullscreen {
+                Some(ToplevelChange::Fullscreen(new_fullscreen))
+            } else {
+                None
+            };
+
+            info.active = new_active;
+            info.fullscreen = new_fullscreen;
+
+            change
+        }
+        Event::Closed => {
+            if info.ready {
+                Some(ToplevelChange::Close)
+            } else {
+                None
+            }
+        }
+        Event::OutputEnter { output: _ } => None,
+        Event::OutputLeave { output: _ } => None,
+        Event::Parent { parent: _ } => None,
+        Event::Done => {
+            if info.ready || info.app_id.is_empty() {
+                None
+            } else {
+                info.ready = true;
+                Some(ToplevelChange::New)
+            }
+        }
+        _ => unreachable!(),
+    };
+
+    if let Some(change) = change {
+        let event = ToplevelEvent {
+            change,
+            toplevel: info.clone(),
+        };
+
+        implem(event, ddata);
+    }
+}
+
+impl Toplevel {
+    pub fn init<F>(handle: &Main<ZwlrForeignToplevelHandleV1>, mut callback: F) -> Self
+    where
+        F: FnMut(ToplevelEvent, DispatchData) + 'static,
+    {
+        let inner = Arc::new(RwLock::new(ToplevelInfo::new()));
+
+        handle.quick_assign(move |_handle, event, ddata| {
+            let mut inner = inner
+                .write()
+                .expect("Failed to get write lock on toplevel inner state");
+            toplevel_implem(event, &mut inner, &mut callback, ddata);
+        });
+
+        Self
+    }
+}

src/wayland/toplevel_manager.rs

@@ -0,0 +1,164 @@
+use crate::wayland::toplevel::{Toplevel, ToplevelEvent};
+use crate::wayland::LazyGlobal;
+use smithay_client_toolkit::environment::{Environment, GlobalHandler};
+use std::cell::RefCell;
+use std::rc;
+use std::rc::Rc;
+use tracing::warn;
+use wayland_client::protocol::wl_registry::WlRegistry;
+use wayland_client::{Attached, DispatchData};
+use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::{
+    zwlr_foreign_toplevel_handle_v1::ZwlrForeignToplevelHandleV1,
+    zwlr_foreign_toplevel_manager_v1::{self, ZwlrForeignToplevelManagerV1},
+};
+
+struct ToplevelHandlerInner {
+    manager: LazyGlobal<ZwlrForeignToplevelManagerV1>,
+    registry: Option<Attached<WlRegistry>>,
+    toplevels: Vec<Toplevel>,
+}
+
+impl ToplevelHandlerInner {
+    const fn new() -> Self {
+        let toplevels = vec![];
+
+        Self {
+            registry: None,
+            manager: LazyGlobal::Unknown,
+            toplevels,
+        }
+    }
+}
+
+pub struct ToplevelHandler {
+    inner: Rc<RefCell<ToplevelHandlerInner>>,
+    status_listeners: Rc<RefCell<Vec<rc::Weak<RefCell<ToplevelStatusCallback>>>>>,
+}
+
+impl ToplevelHandler {
+    pub fn init() -> Self {
+        let inner = Rc::new(RefCell::new(ToplevelHandlerInner::new()));
+
+        Self {
+            inner,
+            status_listeners: Rc::new(RefCell::new(Vec::new())),
+        }
+    }
+}
+
+impl GlobalHandler<ZwlrForeignToplevelManagerV1> for ToplevelHandler {
+    fn created(
+        &mut self,
+        registry: Attached<WlRegistry>,
+        id: u32,
+        version: u32,
+        _ddata: DispatchData,
+    ) {
+        let mut inner = RefCell::borrow_mut(&self.inner);
+        if inner.registry.is_none() {
+            inner.registry = Some(registry);
+        }
+        if let LazyGlobal::Unknown = inner.manager {
+            inner.manager = LazyGlobal::Seen { id, version }
+        } else {
+            warn!(
+                "Compositor advertised zwlr_foreign_toplevel_manager_v1 multiple times, ignoring."
+            );
+        }
+    }
+
+    fn get(&self) -> Option<Attached<ZwlrForeignToplevelManagerV1>> {
+        let mut inner = RefCell::borrow_mut(&self.inner);
+
+        match inner.manager {
+            LazyGlobal::Bound(ref mgr) => Some(mgr.clone()),
+            LazyGlobal::Unknown => None,
+            LazyGlobal::Seen { id, version } => {
+                let registry = inner.registry.as_ref().expect("Failed to get registry");
+                // current max protocol version = 3
+                let version = std::cmp::min(version, 3);
+                let manager = registry.bind::<ZwlrForeignToplevelManagerV1>(version, id);
+
+                {
+                    let inner = self.inner.clone();
+                    let status_listeners = self.status_listeners.clone();
+
+                    manager.quick_assign(move |_, event, _ddata| {
+                        let mut inner = RefCell::borrow_mut(&inner);
+                        let status_listeners = status_listeners.clone();
+
+                        match event {
+                            zwlr_foreign_toplevel_manager_v1::Event::Toplevel {
+                                toplevel: handle,
+                            } => {
+                                let toplevel =
+                                    Toplevel::init(&handle.clone(), move |event, ddata| {
+                                        notify_status_listeners(
+                                            &handle,
+                                            &event,
+                                            ddata,
+                                            &status_listeners,
+                                        );
+                                    });
+
+                                inner.toplevels.push(toplevel);
+                            }
+                            zwlr_foreign_toplevel_manager_v1::Event::Finished => {}
+                            _ => unreachable!(),
+                        }
+                    });
+                }
+
+                inner.manager = LazyGlobal::Bound((*manager).clone());
+                Some((*manager).clone())
+            }
+        }
+    }
+}
+
+type ToplevelStatusCallback =
+    dyn FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static;
+
+/// Notifies the callbacks of an event on the toplevel
+fn notify_status_listeners(
+    toplevel: &ZwlrForeignToplevelHandleV1,
+    event: &ToplevelEvent,
+    mut ddata: DispatchData,
+    listeners: &RefCell<Vec<rc::Weak<RefCell<ToplevelStatusCallback>>>>,
+) {
+    listeners.borrow_mut().retain(|lst| {
+        rc::Weak::upgrade(lst).map_or(false, |cb| {
+            (cb.borrow_mut())(toplevel.clone(), event.clone(), ddata.reborrow());
+            true
+        })
+    });
+}
+
+pub struct ToplevelStatusListener {
+    _cb: Rc<RefCell<ToplevelStatusCallback>>,
+}
+
+pub trait ToplevelHandling {
+    fn listen<F>(&mut self, f: F) -> ToplevelStatusListener
+    where
+        F: FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static;
+}
+
+impl ToplevelHandling for ToplevelHandler {
+    fn listen<F>(&mut self, f: F) -> ToplevelStatusListener
+    where
+        F: FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static,
+    {
+        let rc = Rc::new(RefCell::new(f)) as Rc<_>;
+        self.status_listeners.borrow_mut().push(Rc::downgrade(&rc));
+        ToplevelStatusListener { _cb: rc }
+    }
+}
+
+pub fn listen_for_toplevels<E, F>(env: Environment<E>, f: F) -> ToplevelStatusListener
+where
+    E: ToplevelHandling,
+    F: FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static,
+{
+    env.with_inner(move |inner| ToplevelHandling::listen(inner, f))
+}