fix: not resolving flatpak application icons

2023-06-29 19:55:24 +01:00
61 changed files with 1138 additions and 2477 deletions
--- a/.envrc
+++ b/.envrc
@@ -1 +0,0 @@
-use flake
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -73,6 +73,4 @@ jobs:
          name: jakestanger
          signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'

-      - uses: DeterminateSystems/magic-nix-cache-action@main
-
      - run: nix build --print-build-logs
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,8 +5,6 @@ edition = "2021"
 license = "MIT"
 description = "Customisable GTK Layer Shell wlroots/sway bar"
 repository = "https://github.com/jakestanger/ironbar"
-categories = ["gui"]
-keywords = ["gtk", "bar", "wayland", "wlroots", "gtk-layer-shell"]

 [features]
 default = [
@@ -52,7 +50,7 @@ music = ["regex"]

 sys_info = ["sysinfo", "regex"]

-tray = ["system-tray"]
+tray = ["stray"]

 upower = ["upower_dbus", "zbus", "futures-lite"]

@@ -66,7 +64,7 @@ workspaces = ["futures-util"]
 gtk = "0.17.0"
 gtk-layer-shell = "0.6.0"
 glib = "0.17.10"
-tokio = { version = "1.31.0", features = [
+tokio = { version = "1.28.2", features = [
  "macros",
  "rt-multi-thread",
  "time",
@@ -79,20 +77,20 @@ tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 tracing-error = "0.2.0"
 tracing-appender = "0.2.2"
-strip-ansi-escapes = "0.2.0"
+strip-ansi-escapes = "0.1.1"
 color-eyre = "0.6.2"
-serde = { version = "1.0.183", features = ["derive"] }
+serde = { version = "1.0.164", features = ["derive"] }
 indexmap = "2.0.0"
 dirs = "5.0.1"
 walkdir = "2.3.2"
 notify = { version = "6.0.1", default-features = false }
 wayland-client = "0.30.2"
-wayland-protocols = { version = "0.30.1", features = ["unstable", "client"] }
+wayland-protocols = { version = "0.30.0", features = ["unstable", "client"] }
 wayland-protocols-wlr = { version = "0.1.0", features = ["client"] }
 smithay-client-toolkit = { version = "0.17.0", default-features = false, features = [
  "calloop",
 ] }
-universal-config = { version = "0.4.2", default_features = false }
+universal-config = { version = "0.4.0", default_features = false }
 ctrlc = "3.4.0"

 lazy_static = "1.4.0"
@@ -100,10 +98,10 @@ async_once = "0.2.6"
 cfg-if = "1.0.0"

 # cli
-clap = { version = "4.3.21", optional = true, features = ["derive"] }
+clap = { version = "4.2.7", optional = true, features = ["derive"] }

 # ipc
-serde_json = { version = "1.0.104", optional = true }
+serde_json = { version = "1.0.96", optional = true }

 # http
 reqwest = { version = "0.11.18", optional = true }
@@ -112,29 +110,32 @@ reqwest = { version = "0.11.18", optional = true }
 nix = { version = "0.26.2", optional = true, features = ["event"] }

 # clock
-chrono = { version = "0.4.26", optional = true, features = ["unstable-locales"] }
+chrono = { version = "0.4.26", optional = true }

 # music
-mpd_client = { version = "1.2.0", optional = true }
+mpd_client = { version = "1.0.0", optional = true }
 mpris = { version = "2.0.1", optional = true }

 # sys_info
-sysinfo = { version = "0.29.8", optional = true }
+sysinfo = { version = "0.29.2", optional = true }

 # tray
-system-tray = { version = "0.1.4", optional = true }
+stray = { version = "0.1.3", optional = true }

 # upower
 upower_dbus = { version = "0.3.2", optional = true }
 futures-lite = { version = "1.12.0", optional = true }
-zbus = { version = "3.14.1", optional = true }
+zbus = { version = "3.13.1", optional = true }

 # workspaces
 swayipc-async = { version = "2.0.1", optional = true }
-hyprland = { version = "0.3.8", features = ["silent"], optional = true }
+hyprland = { version = "=0.3.1", optional = true }
 futures-util = { version = "0.3.21", optional = true }

 # shared
 regex = { version = "1.8.4", default-features = false, features = [
  "std",
-], optional = true } # music, sys_info
+], optional = true } # music, sys_info
+
+[patch.crates-io]
+stray = { git = "https://github.com/jakestanger/stray", branch = "fix/connection-errors" }
--- a/docs/Configuration
+++ b/docs/Configuration
@@ -267,22 +267,21 @@ Check [here](config) for an example config file for a fully configured bar in ea

 The following table lists each of the top-level bar config options:

-| Name               | Type                                   | Default   | Description                                                                                                     |
-|--------------------|----------------------------------------|-----------|-----------------------------------------------------------------------------------------------------------------|
-| `name`             | `string`                               | `bar-<n>` | A unique identifier for the bar, used for controlling it over IPC. If not set, uses a generated integer suffix. |
-| `position`         | `top` or `bottom` or `left` or `right` | `bottom`  | The bar's position on screen.                                                                                   |
-| `anchor_to_edges`  | `boolean`                              | `false`   | Whether to anchor the bar to the edges of the screen. Setting to false centres the bar.                         |
-| `height`           | `integer`                              | `42`      | The bar's height in pixels.                                                                                     |
-| `popup_gap`        | `integer`                              | `5`       | The gap between the bar and popup window.                                                                       |
-| `margin.top`       | `integer`                              | `0`       | The margin on the top of the bar                                                                                |
-| `margin.bottom`    | `integer`                              | `0`       | The margin on the bottom of the bar                                                                             |
-| `margin.left`      | `integer`                              | `0`       | The margin on the left of the bar                                                                               |
-| `margin.right`     | `integer`                              | `0`       | The margin on the right of the bar                                                                              |
-| `icon_theme`       | `string`                               | `null`    | Name of the GTK icon theme to use. Leave blank to use default.                                                  |
-| `ironvar_defaults` | `Map<string, string>`                  | `{}`      | Map of [ironvar](ironvars) keys against their default values.                                                   |
-| `start`            | `Module[]`                             | `[]`      | Array of left or top modules.                                                                                   |
-| `center`           | `Module[]`                             | `[]`      | Array of center modules.                                                                                        |
-| `end`              | `Module[]`                             | `[]`      | Array of right or bottom modules.                                                                               |
+| Name               | Type                                   | Default   | Description                                                                             |
+|--------------------|----------------------------------------|-----------|-----------------------------------------------------------------------------------------|
+| `position`         | `top` or `bottom` or `left` or `right` | `bottom`  | The bar's position on screen.                                                           |
+| `anchor_to_edges`  | `boolean`                              | `false`   | Whether to anchor the bar to the edges of the screen. Setting to false centres the bar. |
+| `height`           | `integer`                              | `42`      | The bar's height in pixels.                                                             |
+| `popup_gap`        | `integer`                              | `5`       | The gap between the bar and popup window.                                               |
+| `margin.top`       | `integer`                              | `0`       | The margin on the top of the bar                                                        |
+| `margin.bottom`    | `integer`                              | `0`       | The margin on the bottom of the bar                                                     |
+| `margin.left`      | `integer`                              | `0`       | The margin on the left of the bar                                                       |
+| `margin.right`     | `integer`                              | `0`       | The margin on the right of the bar                                                      |
+| `icon_theme`       | `string`                               | `null`    | Name of the GTK icon theme to use. Leave blank to use default.                          |
+| `ironvar_defaults` | `Map<string, string>`                  | `{}`      | Map of [ironvar](ironvars) keys against their default values.                           |
+| `start`            | `Module[]`                             | `[]`      | Array of left or top modules.                                                           |
+| `center`           | `Module[]`                             | `[]`      | Array of center modules.                                                                |
+| `end`              | `Module[]`                             | `[]`      | Array of right or bottom modules.                                                       |

 ### 3.2 Module-level options

--- a/docs/Controlling
+++ b/docs/Controlling
@@ -31,12 +31,6 @@ Commands and responses are sent as JSON objects, denoted by their `type` key.
 The message buffer is currently limited to `1024` bytes. 
 Particularly large messages will be truncated or cause an error.

-The full spec can be found below.
-
-## Libraries
-
- [Luajit](https://github.com/A-Cloud-Ninja/ironbar-ipc-luajit) - Maintained by [@A-Cloud-Ninja](https://github.com/A-Cloud-Ninja)
-
 ## Commands

 ### `ping`
@@ -63,20 +57,6 @@ Responds with `ok`.
 }
 ```

-### `reload`
-
-Restarts the bars, reloading the config in the process.
-
-The IPC server and main GTK application are untouched.
-
-Responds with `ok`.
-
-```json
-{
-  "type": "reload"
-}
-```
-
 ### `get`

 Gets an [ironvar](ironvars) value.
@@ -117,76 +97,6 @@ Responds with `ok` if the stylesheet exists, otherwise `error`.
 }
 ```

-### `set_visible`
-
-Sets a bar's visibility.
-
-Responds with `ok` if the bar exists, otherwise `error`.
-
-```json
-{
-  "type": "set_visible",
-  "bar_name": "bar-123",
-  "visible": true
-}
-```
-
-### `get_visible`
-
-Gets a bar's visibility.
-
-Responds with `ok_value` and the visibility (`true`/`false`) if the bar exists, otherwise `error`.
-
-```json
-{
-  "type": "get_visible",
-  "bar_name": "bar-123"
-}
-```
-
-### `toggle_popup`
-
-Toggles the open/closed state for a module's popup.
-Since each bar only has a single popup, any open popup on the bar is closed.
-
-Responds with `ok` if the popup exists, otherwise `error`.
-
-```json
-{
-  "type": "toggle_popup",
-  "bar_name": "bar-123",
-  "name": "clock"
-}
-```
-
-### `open_popup`
-
-Sets a module's popup open, regardless of its current state.
-Since each bar only has a single popup, any open popup on the bar is closed.
-
-Responds with `ok` if the popup exists, otherwise `error`.
-
-```json
-{
-  "type": "open_popup",
-  "bar_name": "bar-123",
-  "name": "clock"
-}
-```
-
-### `close_popup`
-
-Sets the popup on a bar closed, regardless of which module it is open for.
-
-Responds with `ok` if the popup exists, otherwise `error`.
-
-```json
-{
-  "type": "close_popup",
-  "bar_name": "bar-123"
-}
-```
-
 ## Responses

 ### `ok`
--- a/docs/modules/Clock.md
+++ b/docs/modules/Clock.md
@@ -8,13 +8,9 @@ Clicking on the widget opens a popup with the time and a calendar.

 > Type: `clock`

-| Name           | Type     | Default                            | Description                                                                         |
-|----------------|----------|------------------------------------|-------------------------------------------------------------------------------------|
-| `format`       | `string` | `%d/%m/%Y %H:%M`                   | Date/time format string.                                                            |
-| `format_popup` | `string` | `%H:%M:%S`                         | Date/time format string to display in the popup header.                             |
-| `locale`       | `string` | `$LC_TIME` or `$LANG` or `'POSIX'` | Locale to use (eg `en_GB`). Defaults to the system language (reading from env var). |
-
-> Detail on available tokens can be found here: <https://docs.rs/chrono/latest/chrono/format/strftime/index.html>
+| Name     | Type     | Default          | Description                                                                                                                              |
+|----------|----------|------------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| `format` | `string` | `%d/%m/%Y %H:%M` | Date/time format string. Detail on available tokens can be found here: <https://docs.rs/chrono/latest/chrono/format/strftime/index.html> |

 <details>
 <summary>JSON</summary>
--- a/docs/modules/Music.md
+++ b/docs/modules/Music.md
@@ -128,6 +128,8 @@ and will be replaced with values from the currently playing track:
 | `{track}`    | Track number                         |
 | `{disc}`     | Disc number                          |
 | `{genre}`    | Genre                                |
+| `{duration}` | Duration in `mm:ss`                  |
+| `{elapsed}`  | Time elapsed in `mm:ss`              |

 ## Styling

@@ -164,10 +166,7 @@ and will be replaced with values from the currently playing track:
 | `.popup-music .controls .btn-pause`         | Pause button inside popup box                         |
 | `.popup-music .controls .btn-next`          | Next button inside popup box                          |
 | `.popup-music .volume`                      | Volume container inside popup box                     |
-| `.popup-music .volume .slider`              | Slider inside volume container                        |
-| `.popup-music .volume .icon`                | Icon inside volume container                          |
-| `.popup-music .progress`                    | Progress (seek) bar container                         |
-| `.popup-music .progress .slider`            | Slider inside progress container                      |
-| `.popup-music .progress .label`             | Duration label inside progress container              |
+| `.popup-music .volume .slider`              | Volume slider popup box                               |
+| `.popup-music .volume .icon`                | Volume icon label inside popup box                    |

 For more information on styling, please see the [styling guide](styling-guide).
--- a/docs/modules/Workspaces.md
+++ b/docs/modules/Workspaces.md
@@ -8,14 +8,12 @@ Shows all current workspaces. Clicking a workspace changes focus to it.

 > Type: `workspaces`

-| Name           | Type                                  | Default        | Description                                                                                                                                                               |
-|----------------|---------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `name_map`     | `Map<string, string or image>`        | `{}`           | A map of actual workspace names to their display labels/images. Workspaces use their actual name if not present in the map. See [here](images) for information on images. |
-| `favorites`    | `Map<string, string[]>` or `string[]` | `[]`           | Workspaces to always show. This can be for all monitors, or a map to set per monitor.                                                                                     |
-| `hidden`       | `string[]`                            | `[]`           | A list of workspace names to never show                                                                                                                                   |
-| `icon_size`    | `integer`                             | `32`           | Size to render icon at (image icons only).                                                                                                                                |
-| `all_monitors` | `boolean`                             | `false`        | Whether to display workspaces from all monitors. When `false`, only shows workspaces on the current monitor.                                                              |
-| `sort`         | `'added'` or `'alphanumeric'`         | `alphanumeric` | The method used for sorting workspaces. `added` always appends to the end, `alphanumeric` sorts by number/name.                                                           |
+| Name           | Type                           | Default        | Description                                                                                                                                                               |
+|----------------|--------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `name_map`     | `Map<string, string or image>` | `{}`           | A map of actual workspace names to their display labels/images. Workspaces use their actual name if not present in the map. See [here](images) for information on images. |
+| `icon_size`    | `integer`                      | `32`           | Size to render icon at (image icons only).                                                                                                                                |
+| `all_monitors` | `boolean`                      | `false`        | Whether to display workspaces from all monitors. When `false`, only shows workspaces on the current monitor.                                                              |
+| `sort`         | `'added'` or `'alphanumeric'`  | `alphanumeric` | The method used for sorting workspaces. `added` always appends to the end, `alphanumeric` sorts by number/name.                                                           |

 <details>
 <summary>JSON</summary>
@@ -30,7 +28,6 @@ Shows all current workspaces. Clicking a workspace changes focus to it.
        "2": "",
        "3": ""
      },
-      "favorites": ["1", "2", "3"],
      "all_monitors": false
    }
  ]
@@ -46,7 +43,6 @@ Shows all current workspaces. Clicking a workspace changes focus to it.
 [[end]]
 type = "workspaces"
 all_monitors = false
-favorites = ["1", "2", "3"]

 [[end.name_map]]
 1 = ""
@@ -67,10 +63,6 @@ end:
      1: ""
      2: ""
      3: ""
-    favorites:
-      - "1"
-      - "2"
-      - "3"
    all_monitors: false
 ```

@@ -87,7 +79,6 @@ end:
            name_map.1 = ""
            name_map.2 = ""
            name_map.3 = ""
-            favorites = [ "1" "2" "3" ]
            all_monitors = false
        }
    ]
@@ -107,4 +98,4 @@ end:
 | `.workspaces .item .text-icon` | Workspace button icon (textual only) |
 | `.workspaces .item .image`     | Workspace button icon (image only)   |

-For more information on styling, please see the [styling guide](styling-guide).
+For more information on styling, please see the [styling guide](styling-guide).
--- a/examples/style.css
+++ b/examples/style.css
@@ -120,11 +120,7 @@ button:hover {
    margin-right: 1em;
 }

-.popup-music .icon-box {
-    margin-right: 0.4em;
-}
-
-.popup-music .title .icon, .popup-music .title .label {
+.popup-music .title .icon *, .popup-music .title .label {
    font-size: 1.7em;
 }

@@ -132,17 +128,15 @@ button:hover {
    color: @color_border;
 }

-.popup-music .volume .slider slider {
+.popup-music .volume scale slider {
    border-radius: 100%;
 }

-.popup-music .volume .icon {
-    margin-left: 4px;
+/* volume icon */
+.popup-music .volume > box:last-child label {
+    margin-left: 6px;
 }

-.popup-music .progress .slider slider {
-    border-radius: 100%;
-}

 /* -- script -- */

--- a/flake.lock
+++ b/flake.lock
@@ -1,66 +1,9 @@
 {
  "nodes": {
-    "crane": {
-      "inputs": {
-        "flake-compat": "flake-compat",
-        "flake-utils": "flake-utils",
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "rust-overlay": "rust-overlay"
-      },
-      "locked": {
-        "lastModified": 1688772518,
-        "narHash": "sha256-ol7gZxwvgLnxNSZwFTDJJ49xVY5teaSvF7lzlo3YQfM=",
-        "owner": "ipetkov",
-        "repo": "crane",
-        "rev": "8b08e96c9af8c6e3a2b69af5a7fa168750fcf88e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "ipetkov",
-        "repo": "crane",
-        "type": "github"
-      }
-    },
-    "flake-compat": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1673956053,
-        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
-        "owner": "edolstra",
-        "repo": "flake-compat",
-        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "edolstra",
-        "repo": "flake-compat",
-        "type": "github"
-      }
-    },
    "flake-utils": {
      "inputs": {
        "systems": "systems"
      },
-      "locked": {
-        "lastModified": 1687709756,
-        "narHash": "sha256-Y5wKlQSkgEK2weWdOu4J3riRd+kV/VCgHsqLNTTWQ/0=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "dbabf0ca0c0c4bce6ea5eaf65af5cb694d2082c7",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "flake-utils_2": {
-      "inputs": {
-        "systems": "systems_2"
-      },
      "locked": {
        "lastModified": 1681202837,
        "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=",
@@ -75,45 +18,13 @@
        "type": "github"
      }
    },
-    "naersk": {
-      "inputs": {
-        "nixpkgs": "nixpkgs"
-      },
-      "locked": {
-        "lastModified": 1690373729,
-        "narHash": "sha256-e136hTT7LqQ2QjOTZQMW+jnsevWwBpMj78u6FRUsH9I=",
-        "owner": "nix-community",
-        "repo": "naersk",
-        "rev": "d9a33d69a9c421d64c8d925428864e93be895dcc",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "naersk",
-        "type": "github"
-      }
-    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1690833316,
-        "narHash": "sha256-+YU+/pTJmVKNW12R07/SJiTn7PQk90xwCI4D2PfLRPs=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "9418167277f665de6f4a29f414d438cf39c55b9e",
-        "type": "github"
-      },
-      "original": {
-        "id": "nixpkgs",
-        "type": "indirect"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1690789960,
-        "narHash": "sha256-3K+2HuyGTiJUSZNJxXXvc0qj4xFx1FHC/ItYtEa7/Xs=",
+        "lastModified": 1686960236,
+        "narHash": "sha256-AYCC9rXNLpUWzD9hm+askOfpliLEC9kwAo7ITJc4HIw=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "fb942492b7accdee4e6d17f5447091c65897dde4",
+        "rev": "04af42f3b31dba0ef742d254456dc4c14eedac86",
        "type": "github"
      },
      "original": {
@@ -125,50 +36,23 @@
    },
    "root": {
      "inputs": {
-        "crane": "crane",
-        "naersk": "naersk",
-        "nixpkgs": "nixpkgs_2",
-        "rust-overlay": "rust-overlay_2"
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
      }
    },
    "rust-overlay": {
      "inputs": {
-        "flake-utils": [
-          "crane",
-          "flake-utils"
-        ],
-        "nixpkgs": [
-          "crane",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1688351637,
-        "narHash": "sha256-CLTufJ29VxNOIZ8UTg0lepsn3X03AmopmaLTTeHDCL4=",
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "rev": "f9b92316727af9e6c7fee4a761242f7f46880329",
-        "type": "github"
-      },
-      "original": {
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "type": "github"
-      }
-    },
-    "rust-overlay_2": {
-      "inputs": {
-        "flake-utils": "flake-utils_2",
+        "flake-utils": "flake-utils",
        "nixpkgs": [
          "nixpkgs"
        ]
      },
      "locked": {
-        "lastModified": 1690683485,
-        "narHash": "sha256-Sp/QpbMg86v12xhCsa6q0yTH8LYaJIcxzbf9LO1zFzM=",
+        "lastModified": 1686968542,
+        "narHash": "sha256-Gjlj7UeHqMFRAYyefeoLnSjLo8V+0XheIamojNEyTbE=",
        "owner": "oxalica",
        "repo": "rust-overlay",
-        "rev": "05d480a7aef1aae1bfb67a39134dcf48c5322528",
+        "rev": "01d84cd842e48e89be67e4c2d9dc46aa7709adc5",
        "type": "github"
      },
      "original": {
@@ -191,21 +75,6 @@
        "repo": "default",
        "type": "github"
      }
-    },
-    "systems_2": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
    }
  },
  "root": "root",
--- a/flake.nix
+++ b/flake.nix
@@ -6,18 +6,11 @@
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
-    crane = {
-      url = "github:ipetkov/crane";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-    naersk.url = "github:nix-community/naersk";
  };
  outputs = {
    self,
    nixpkgs,
    rust-overlay,
-    crane,
-    naersk,
    ...
  }: let
    inherit (nixpkgs) lib;
@@ -34,18 +27,10 @@
          rust-overlay.overlays.default
        ];
      };
-    mkRustToolchain = pkgs:
-      pkgs.rust-bin.stable.latest.default.override {
-        extensions = ["rust-src"];
-      };
+    mkRustToolchain = pkgs: pkgs.rust-bin.stable.latest.default;
  in {
    overlays.default = final: prev: let
      rust = mkRustToolchain final;
-      craneLib = (crane.mkLib final).overrideToolchain rust;
-      naersk' = prev.callPackage naersk {
-        cargo = rust;
-        rustc = rust;
-      };

      rustPlatform = prev.makeRustPlatform {
        cargo = rust;
@@ -57,33 +42,11 @@
        (builtins.substring 4 2 longDate)
        (builtins.substring 6 2 longDate)
      ]);
-      builder = "naersk";
    in {
-      ironbar = let
+      ironbar = prev.callPackage ./nix/default.nix {
        version = props.package.version + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
-      in
-        if builder == "crane"
-        then
-          prev.callPackage ./nix/default.nix {
-            inherit version;
-            inherit rustPlatform;
-            builderName = builder;
-            builder = craneLib;
-          }
-        else if builder == "naersk"
-        then
-          prev.callPackage ./nix/default.nix {
-            inherit version;
-            inherit rustPlatform;
-            builderName = builder;
-            builder = naersk';
-          }
-        else
-          prev.callPackage ./nix/default.nix {
-            inherit version;
-            inherit rustPlatform;
-            builderName = builder;
-          };
+        inherit rustPlatform;
+      };
    };
    packages = genSystems (
      system: let
@@ -119,14 +82,6 @@
          gtk-layer-shell
          pkg-config
          openssl
-          gdk-pixbuf
-          glib
-          glib-networking
-          shared-mime-info
-          gnome.adwaita-icon-theme
-          hicolor-icon-theme
-          gsettings-desktop-schemas
-          libxkbcommon
        ];

        RUST_SRC_PATH = "${rust}/lib/rustlib/src/rust/library";
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -19,77 +19,49 @@
  lib,
  version ? "git",
  features ? [],
-  builderName ? "nix",
-  builder ? {},
-}: let
-  basePkg = rec {
-    inherit version;
-    pname = "ironbar";
-    src = builtins.path {
-      name = "ironbar";
-      path = lib.cleanSource ../.;
-    };
-    nativeBuildInputs = [pkg-config wrapGAppsHook gobject-introspection];
-    buildInputs = [gtk3 gdk-pixbuf glib gtk-layer-shell glib-networking shared-mime-info gnome.adwaita-icon-theme hicolor-icon-theme gsettings-desktop-schemas libxkbcommon openssl];
-    propagatedBuildInputs = [
-      gtk3
-    ];
-    preFixup = ''
-      gappsWrapperArgs+=(
-        # Thumbnailers
-        --prefix XDG_DATA_DIRS : "${gdk-pixbuf}/share"
-        --prefix XDG_DATA_DIRS : "${librsvg}/share"
-        --prefix XDG_DATA_DIRS : "${webp-pixbuf-loader}/share"
-        --prefix XDG_DATA_DIRS : "${shared-mime-info}/share"
-      )
-    '';
-    passthru = {
-      updateScript = gnome.updateScript {
-        packageName = pname;
-        attrPath = "gnome.${pname}";
-      };
-    };
-    meta = with lib; {
-      homepage = "https://github.com/JakeStanger/ironbar";
-      description = "Customisable gtk-layer-shell wlroots/sway bar written in rust.";
-      license = licenses.mit;
-      platforms = platforms.linux;
-      mainProgram = "ironbar";
+}:
+rustPlatform.buildRustPackage rec {
+  inherit version;
+  pname = "ironbar";
+  src = builtins.path {
+    name = "ironbar";
+    path = lib.cleanSource ../.;
+  };
+  buildNoDefaultFeatures =
+    if features == []
+    then false
+    else true;
+  buildFeatures = features;
+  cargoDeps = rustPlatform.importCargoLock {
+    lockFile = ../Cargo.lock;
+  };
+  cargoLock.lockFile = ../Cargo.lock;
+  cargoLock.outputHashes."stray-0.1.3" = "sha256-7mvsWZFmPWti9AiX67h6ZlWiVVRZRWIxq3pVaviOUtc=";
+  nativeBuildInputs = [pkg-config wrapGAppsHook gobject-introspection];
+  buildInputs = [gtk3 gdk-pixbuf glib gtk-layer-shell glib-networking shared-mime-info gnome.adwaita-icon-theme hicolor-icon-theme gsettings-desktop-schemas libxkbcommon openssl];
+  propagatedBuildInputs = [
+    gtk3
+  ];
+  preFixup = ''
+    gappsWrapperArgs+=(
+      # Thumbnailers
+      --prefix XDG_DATA_DIRS : "${gdk-pixbuf}/share"
+      --prefix XDG_DATA_DIRS : "${librsvg}/share"
+      --prefix XDG_DATA_DIRS : "${webp-pixbuf-loader}/share"
+      --prefix XDG_DATA_DIRS : "${shared-mime-info}/share"
+    )
+  '';
+  passthru = {
+    updateScript = gnome.updateScript {
+      packageName = pname;
+      attrPath = "gnome.${pname}";
    };
  };
-  flags = let
-    noDefault =
-      if features == []
-      then ""
-      else "--no-default-features";
-    featuresStr =
-      if features == []
-      then ""
-      else ''-F "${builtins.concatStringsSep "," features}"'';
-  in [noDefault featuresStr];
-in
-  if builderName == "naersk"
-  then
-    builder.buildPackage (basePkg
-      // {
-        cargoOptions = old: old ++ flags;
-      })
-  else if builderName == "crane"
-  then
-    builder.buildPackage (basePkg
-      // {
-        cargoExtraArgs = builtins.concatStringsSep " " flags;
-        doCheck = false;
-      })
-  else
-    rustPlatform.buildRustPackage (basePkg
-      // {
-        buildNoDefaultFeatures =
-          if features == []
-          then false
-          else true;
-        buildFeatures = features;
-        cargoDeps = rustPlatform.importCargoLock {lockFile = ../Cargo.lock;};
-        cargoLock.lockFile = ../Cargo.lock;
-        cargoLock.outputHashes."stray-0.1.3" = "sha256-7mvsWZFmPWti9AiX67h6ZlWiVVRZRWIxq3pVaviOUtc=";
-      })
+  meta = with lib; {
+    homepage = "https://github.com/JakeStanger/ironbar";
+    description = "Customisable gtk-layer-shell wlroots/sway bar written in rust.";
+    license = licenses.mit;
+    platforms = platforms.linux;
+    mainProgram = "ironbar";
+  };
+}
--- a/shell.nix
+++ b/shell.nix
@@ -1,17 +0,0 @@
-{ pkgs ? import <nixpkgs> {} }:
-
-pkgs.mkShell {
-  buildInputs = with pkgs; [
-    cargo
-    clippy
-    rustfmt
-    gtk3
-    gtk-layer-shell
-    gcc
-    openssl
-  ];
-
-  nativeBuildInputs = with pkgs; [
-    pkg-config
-  ];
-}
--- a/src/bar.rs
+++ b/src/bar.rs
@@ -4,13 +4,11 @@ use crate::modules::{
 };
 use crate::popup::Popup;
 use crate::unique_id::get_unique_usize;
-use crate::{arc_rw, Config, GlobalState};
+use crate::Config;
 use color_eyre::Result;
 use gtk::gdk::Monitor;
 use gtk::prelude::*;
 use gtk::{Application, ApplicationWindow, IconTheme, Orientation};
-use std::cell::RefCell;
-use std::rc::Rc;
 use std::sync::{Arc, RwLock};
 use tracing::{debug, info};

@@ -21,16 +19,8 @@ pub fn create_bar(
    monitor: &Monitor,
    monitor_name: &str,
    config: Config,
-    global_state: &Rc<RefCell<GlobalState>>,
 ) -> Result<()> {
    let win = ApplicationWindow::builder().application(app).build();
-    let bar_name = config
-        .name
-        .clone()
-        .unwrap_or_else(|| format!("bar-{}", get_unique_usize()));
-
-    win.set_widget_name(&bar_name);
-    info!("Creating bar {}", bar_name);

    setup_layer_shell(
        &win,
@@ -65,12 +55,7 @@ pub fn create_bar(
    content.set_center_widget(Some(&center));
    content.pack_end(&end, false, false, 0);

-    let load_result = load_modules(&start, &center, &end, app, config, monitor, monitor_name)?;
-    global_state
-        .borrow_mut()
-        .popups_mut()
-        .insert(bar_name.into(), load_result.popup);
-
+    load_modules(&start, &center, &end, app, config, monitor, monitor_name)?;
    win.add(&content);

    win.connect_destroy_event(|_, _| {
@@ -151,11 +136,6 @@ fn create_container(name: &str, orientation: Orientation) -> gtk::Box {
    container
 }

-#[derive(Debug)]
-struct BarLoadResult {
-    popup: Arc<RwLock<Popup>>,
-}
-
 /// Loads the configured modules onto a bar.
 fn load_modules(
    left: &gtk::Box,
@@ -165,7 +145,7 @@ fn load_modules(
    config: Config,
    monitor: &Monitor,
    output_name: &str,
-) -> Result<BarLoadResult> {
+) -> Result<()> {
    let icon_theme = IconTheme::new();
    if let Some(ref theme) = config.icon_theme {
        icon_theme.set_custom_theme(Some(theme));
@@ -186,7 +166,7 @@ fn load_modules(

    // popup ignores module location so can bodge this for now
    let popup = Popup::new(&info!(ModuleLocation::Left), config.popup_gap);
-    let popup = arc_rw!(popup);
+    let popup = Arc::new(RwLock::new(popup));

    if let Some(modules) = config.start {
        let info = info!(ModuleLocation::Left);
@@ -203,9 +183,7 @@ fn load_modules(
        add_modules(right, modules, &info, &popup)?;
    }

-    let result = BarLoadResult { popup };
-
-    Ok(result)
+    Ok(())
 }

 /// Adds modules into a provided GTK box,
@@ -220,14 +198,8 @@ fn add_modules(

    macro_rules! add_module {
        ($module:expr, $id:expr) => {{
-            let common = $module.common.take().expect("common config to exist");
-            let widget_parts = create_module(
-                *$module,
-                $id,
-                common.name.clone(),
-                &info,
-                &Arc::clone(&popup),
-            )?;
+            let common = $module.common.take().expect("Common config did not exist");
+            let widget_parts = create_module(*$module, $id, &info, &Arc::clone(&popup))?;
            set_widget_identifiers(&widget_parts, &common);

            let container = wrap_widget(&widget_parts.widget, common, orientation);
--- a/src/clients/clipboard.rs
+++ b/src/clients/clipboard.rs
@@ -1,5 +1,5 @@
 use super::wayland::{self, ClipboardItem};
-use crate::{arc_mut, lock, try_send};
+use crate::{lock, try_send};
 use indexmap::map::Iter;
 use indexmap::IndexMap;
 use lazy_static::lazy_static;
@@ -28,9 +28,9 @@ impl ClipboardClient {
    fn new() -> Self {
        trace!("Initializing clipboard client");

-        let senders = arc_mut!(Vec::<(EventSender, usize)>::new());
+        let senders = Arc::new(Mutex::new(Vec::<(EventSender, usize)>::new()));

-        let cache = arc_mut!(ClipboardCache::new());
+        let cache = Arc::new(Mutex::new(ClipboardCache::new()));

        {
            let senders = senders.clone();
--- a/src/clients/compositor/hyprland.rs
+++ b/src/clients/compositor/hyprland.rs
@@ -1,12 +1,13 @@
 use super::{Workspace, WorkspaceClient, WorkspaceUpdate};
-use crate::{arc_mut, lock, send};
+use crate::{lock, send};
 use color_eyre::Result;
 use hyprland::data::{Workspace as HWorkspace, Workspaces};
 use hyprland::dispatch::{Dispatch, DispatchType, WorkspaceIdentifierWithSpecial};
-use hyprland::event_listener::EventListener;
+use hyprland::event_listener::EventListenerMutable as EventListener;
 use hyprland::prelude::*;
 use hyprland::shared::WorkspaceType;
 use lazy_static::lazy_static;
+use std::sync::{Arc, Mutex};
 use tokio::sync::broadcast::{channel, Receiver, Sender};
 use tokio::task::spawn_blocking;
 use tracing::{debug, error, info};
@@ -35,18 +36,18 @@ impl EventClient {
            let mut event_listener = EventListener::new();

            // we need a lock to ensure events don't run at the same time
-            let lock = arc_mut!(());
+            let lock = Arc::new(Mutex::new(()));

            // cache the active workspace since Hyprland doesn't give us the prev active
            let active = Self::get_active_workspace().expect("Failed to get active workspace");
-            let active = arc_mut!(Some(active));
+            let active = Arc::new(Mutex::new(Some(active)));

            {
                let tx = tx.clone();
                let lock = lock.clone();
                let active = active.clone();

-                event_listener.add_workspace_added_handler(move |workspace_type| {
+                event_listener.add_workspace_added_handler(move |workspace_type, _state| {
                    let _lock = lock!(lock);
                    debug!("Added workspace: {workspace_type:?}");

@@ -69,7 +70,7 @@ impl EventClient {
                let lock = lock.clone();
                let active = active.clone();

-                event_listener.add_workspace_change_handler(move |workspace_type| {
+                event_listener.add_workspace_change_handler(move |workspace_type, _state| {
                    let _lock = lock!(lock);

                    let mut prev_workspace = lock!(active);
@@ -105,9 +106,9 @@ impl EventClient {
                let lock = lock.clone();
                let active = active.clone();

-                event_listener.add_active_monitor_change_handler(move |event_data| {
+                event_listener.add_active_monitor_change_handler(move |event_data, _state| {
                    let _lock = lock!(lock);
-                    let workspace_type = event_data.workspace;
+                    let workspace_type = event_data.1;

                    let mut prev_workspace = lock!(active);

@@ -134,9 +135,9 @@ impl EventClient {
                let tx = tx.clone();
                let lock = lock.clone();

-                event_listener.add_workspace_moved_handler(move |event_data| {
+                event_listener.add_workspace_moved_handler(move |event_data, _state| {
                    let _lock = lock!(lock);
-                    let workspace_type = event_data.workspace;
+                    let workspace_type = event_data.1;
                    debug!("Received workspace move: {workspace_type:?}");

                    let mut prev_workspace = lock!(active);
@@ -158,7 +159,7 @@ impl EventClient {
            }

            {
-                event_listener.add_workspace_destroy_handler(move |workspace_type| {
+                event_listener.add_workspace_destroy_handler(move |workspace_type, _state| {
                    let _lock = lock!(lock);
                    debug!("Received workspace destroy: {workspace_type:?}");

@@ -221,12 +222,9 @@ impl EventClient {

 impl WorkspaceClient for EventClient {
    fn focus(&self, id: String) -> Result<()> {
-        let identifier = match id.parse::<i32>() {
-            Ok(inum) => WorkspaceIdentifierWithSpecial::Id(inum),
-            Err(_) => WorkspaceIdentifierWithSpecial::Name(&id),
-        };
-
-        Dispatch::call(DispatchType::Workspace(identifier))?;
+        Dispatch::call(DispatchType::Workspace(
+            WorkspaceIdentifierWithSpecial::Name(&id),
+        ))?;
        Ok(())
    }

--- a/src/clients/music/mod.rs
+++ b/src/clients/music/mod.rs
@@ -9,17 +9,9 @@ pub mod mpd;
 #[cfg(feature = "music+mpris")]
 pub mod mpris;

-pub const TICK_INTERVAL_MS: u64 = 200;
-
 #[derive(Clone, Debug)]
 pub enum PlayerUpdate {
-    /// Triggered when the track or player state notably changes,
-    /// such as a new track playing, the player being paused, or a volume change.
    Update(Box<Option<Track>>, Status),
-    /// Triggered at regular intervals while a track is playing.
-    /// Used to keep track of the progress through the current track.
-    ProgressTick(ProgressTick),
-    /// Triggered when the client disconnects from the player.
    Disconnect,
 }

@@ -35,25 +27,21 @@ pub struct Track {
    pub cover_path: Option<String>,
 }

-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub enum PlayerState {
    Playing,
    Paused,
    Stopped,
 }

-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub struct Status {
    pub state: PlayerState,
-    pub volume_percent: Option<u8>,
-    pub playlist_position: u32,
-    pub playlist_length: u32,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct ProgressTick {
+    pub volume_percent: u8,
    pub duration: Option<Duration>,
    pub elapsed: Option<Duration>,
+    pub playlist_position: u32,
+    pub playlist_length: u32,
 }

 pub trait MusicClient {
@@ -63,7 +51,6 @@ pub trait MusicClient {
    fn prev(&self) -> Result<()>;

    fn set_volume_percent(&self, vol: u8) -> Result<()>;
-    fn seek(&self, duration: Duration) -> Result<()>;

    fn subscribe_change(&self) -> broadcast::Receiver<PlayerUpdate>;
 }
--- a/src/clients/music/mpd.rs
+++ b/src/clients/music/mpd.rs
@@ -1,11 +1,9 @@
-use super::{
-    MusicClient, PlayerState, PlayerUpdate, ProgressTick, Status, Track, TICK_INTERVAL_MS,
-};
-use crate::{await_sync, send};
+use super::{MusicClient, Status, Track};
+use crate::await_sync;
+use crate::clients::music::{PlayerState, PlayerUpdate};
 use color_eyre::Result;
 use lazy_static::lazy_static;
 use mpd_client::client::{Connection, ConnectionEvent, Subsystem};
-use mpd_client::commands::SeekMode;
 use mpd_client::protocol::MpdProtocolError;
 use mpd_client::responses::{PlayState, Song};
 use mpd_client::tag::Tag;
@@ -18,7 +16,7 @@ use std::sync::Arc;
 use std::time::Duration;
 use tokio::net::{TcpStream, UnixStream};
 use tokio::spawn;
-use tokio::sync::broadcast;
+use tokio::sync::broadcast::{channel, error::SendError, Receiver, Sender};
 use tokio::sync::Mutex;
 use tokio::time::sleep;
 use tracing::{debug, error, info};
@@ -31,8 +29,8 @@ lazy_static! {
 pub struct MpdClient {
    client: Client,
    music_dir: PathBuf,
-    tx: broadcast::Sender<PlayerUpdate>,
-    _rx: broadcast::Receiver<PlayerUpdate>,
+    tx: Sender<PlayerUpdate>,
+    _rx: Receiver<PlayerUpdate>,
 }

 #[derive(Debug)]
@@ -59,7 +57,7 @@ impl MpdClient {
        let (client, mut state_changes) =
            wait_for_connection(host, Duration::from_secs(5), None).await?;

-        let (tx, rx) = broadcast::channel(16);
+        let (tx, rx) = channel(16);

        {
            let music_dir = music_dir.clone();
@@ -80,19 +78,7 @@ impl MpdClient {
                    }
                }

-                Ok::<(), broadcast::error::SendError<(Option<Track>, Status)>>(())
-            });
-        }
-
-        {
-            let client = client.clone();
-            let tx = tx.clone();
-
-            spawn(async move {
-                loop {
-                    Self::send_tick_update(&client, &tx).await;
-                    sleep(Duration::from_millis(TICK_INTERVAL_MS)).await;
-                }
+                Ok::<(), SendError<(Option<Track>, Status)>>(())
            });
        }

@@ -106,9 +92,9 @@ impl MpdClient {

    async fn send_update(
        client: &Client,
-        tx: &broadcast::Sender<PlayerUpdate>,
+        tx: &Sender<PlayerUpdate>,
        music_dir: &Path,
-    ) -> Result<(), broadcast::error::SendError<PlayerUpdate>> {
+    ) -> Result<(), SendError<PlayerUpdate>> {
        let current_song = client.command(commands::CurrentSong).await;
        let status = client.command(commands::Status).await;

@@ -116,33 +102,17 @@ impl MpdClient {
            let track = current_song.map(|s| Self::convert_song(&s.song, music_dir));
            let status = Status::from(status);

-            let update = PlayerUpdate::Update(Box::new(track), status);
-            send!(tx, update);
+            tx.send(PlayerUpdate::Update(Box::new(track), status))?;
        }

        Ok(())
    }

-    async fn send_tick_update(client: &Client, tx: &broadcast::Sender<PlayerUpdate>) {
-        let status = client.command(commands::Status).await;
-
-        if let Ok(status) = status {
-            if status.state == PlayState::Playing {
-                let update = PlayerUpdate::ProgressTick(ProgressTick {
-                    duration: status.duration,
-                    elapsed: status.elapsed,
-                });
-
-                send!(tx, update);
-            }
-        }
-    }
-
    fn is_connected(&self) -> bool {
        !self.client.is_connection_closed()
    }

-    fn send_disconnect_update(&self) -> Result<(), broadcast::error::SendError<PlayerUpdate>> {
+    fn send_disconnect_update(&self) -> Result<(), SendError<PlayerUpdate>> {
        info!("Connection to MPD server lost");
        self.tx.send(PlayerUpdate::Disconnect)?;
        Ok(())
@@ -212,12 +182,7 @@ impl MusicClient for MpdClient {
        Ok(())
    }

-    fn seek(&self, duration: Duration) -> Result<()> {
-        async_command!(self.client, commands::Seek(SeekMode::Absolute(duration)));
-        Ok(())
-    }
-
-    fn subscribe_change(&self) -> broadcast::Receiver<PlayerUpdate> {
+    fn subscribe_change(&self) -> Receiver<PlayerUpdate> {
        let rx = self.tx.subscribe();
        await_sync(async {
            Self::send_update(&self.client, &self.tx, &self.music_dir)
@@ -326,7 +291,9 @@ impl From<mpd_client::responses::Status> for Status {
    fn from(status: mpd_client::responses::Status) -> Self {
        Self {
            state: PlayerState::from(status.state),
-            volume_percent: Some(status.volume),
+            volume_percent: status.volume,
+            duration: status.duration,
+            elapsed: status.elapsed,
            playlist_position: status.current_song.map_or(0, |(pos, _)| pos.0 as u32),
            playlist_length: status.playlist_length as u32,
        }
--- a/src/clients/music/mpris.rs
+++ b/src/clients/music/mpris.rs
@@ -1,15 +1,15 @@
-use super::{MusicClient, PlayerState, PlayerUpdate, Status, Track, TICK_INTERVAL_MS};
-use crate::clients::music::ProgressTick;
-use crate::{arc_mut, lock, send};
+use super::{MusicClient, PlayerUpdate, Status, Track};
+use crate::clients::music::PlayerState;
+use crate::{lock, send};
 use color_eyre::Result;
 use lazy_static::lazy_static;
 use mpris::{DBusError, Event, Metadata, PlaybackStatus, Player, PlayerFinder};
 use std::collections::HashSet;
+use std::string;
 use std::sync::{Arc, Mutex};
 use std::thread::sleep;
 use std::time::Duration;
-use std::{cmp, string};
-use tokio::sync::broadcast;
+use tokio::sync::broadcast::{channel, Receiver, Sender};
 use tokio::task::spawn_blocking;
 use tracing::{debug, error, trace};

@@ -19,18 +19,18 @@ lazy_static! {

 pub struct Client {
    current_player: Arc<Mutex<Option<String>>>,
-    tx: broadcast::Sender<PlayerUpdate>,
-    _rx: broadcast::Receiver<PlayerUpdate>,
+    tx: Sender<PlayerUpdate>,
+    _rx: Receiver<PlayerUpdate>,
 }

 impl Client {
    fn new() -> Self {
-        let (tx, rx) = broadcast::channel(32);
+        let (tx, rx) = channel(32);

-        let current_player = arc_mut!(None);
+        let current_player = Arc::new(Mutex::new(None));

        {
-            let players_list = arc_mut!(HashSet::new());
+            let players_list = Arc::new(Mutex::new(HashSet::new()));
            let current_player = current_player.clone();
            let tx = tx.clone();

@@ -84,20 +84,6 @@ impl Client {
            });
        }

-        {
-            let current_player = current_player.clone();
-            let tx = tx.clone();
-
-            spawn_blocking(move || {
-                let player_finder = PlayerFinder::new().expect("to get new player finder");
-
-                loop {
-                    Self::send_tick_update(&player_finder, &current_player, &tx);
-                    sleep(Duration::from_millis(TICK_INTERVAL_MS));
-                }
-            });
-        }
-
        Self {
            current_player,
            tx,
@@ -109,7 +95,7 @@ impl Client {
        player_id: String,
        players: Arc<Mutex<HashSet<String>>>,
        current_player: Arc<Mutex<Option<String>>>,
-        tx: broadcast::Sender<PlayerUpdate>,
+        tx: Sender<PlayerUpdate>,
    ) {
        spawn_blocking(move || {
            let player_finder = PlayerFinder::new()?;
@@ -152,7 +138,7 @@ impl Client {
        });
    }

-    fn send_update(player: &Player, tx: &broadcast::Sender<PlayerUpdate>) -> Result<()> {
+    fn send_update(player: &Player, tx: &Sender<PlayerUpdate>) -> Result<()> {
        debug!("Sending update using '{}'", player.identity());

        let metadata = player.get_metadata()?;
@@ -162,7 +148,10 @@ impl Client {

        let track_list = player.get_track_list();

-        let volume_percent = player.get_volume().map(|vol| (vol * 100.0) as u8).ok();
+        let volume_percent = player
+            .get_volume()
+            .map(|vol| (vol * 100.0) as u8)
+            .unwrap_or(0);

        let status = Status {
            // MRPIS doesn't seem to provide playlist info reliably,
@@ -170,6 +159,8 @@ impl Client {
            playlist_position: 1,
            playlist_length: track_list.map(|list| list.len() as u32).unwrap_or(u32::MAX),
            state: PlayerState::from(playback_status),
+            elapsed: player.get_position().ok(),
+            duration: metadata.length(),
            volume_percent,
        };

@@ -190,26 +181,6 @@ impl Client {
            player_finder.find_by_name(player_name).ok()
        })
    }
-
-    fn send_tick_update(
-        player_finder: &PlayerFinder,
-        current_player: &Mutex<Option<String>>,
-        tx: &broadcast::Sender<PlayerUpdate>,
-    ) {
-        if let Some(player) = lock!(current_player)
-            .as_ref()
-            .and_then(|name| player_finder.find_by_name(name).ok())
-        {
-            if let Ok(metadata) = player.get_metadata() {
-                let update = PlayerUpdate::ProgressTick(ProgressTick {
-                    elapsed: player.get_position().ok(),
-                    duration: metadata.length(),
-                });
-
-                send!(tx, update);
-            }
-        }
-    }
 }

 macro_rules! command {
@@ -252,23 +223,7 @@ impl MusicClient for Client {
        Ok(())
    }

-    fn seek(&self, duration: Duration) -> Result<()> {
-        if let Some(player) = Self::get_player(self) {
-            let pos = player.get_position().unwrap_or_default();
-
-            let duration = duration.as_micros() as i64;
-            let position = pos.as_micros() as i64;
-
-            let seek = cmp::max(duration, 0) - position;
-
-            player.seek(seek)?;
-        } else {
-            error!("Could not find player");
-        }
-        Ok(())
-    }
-
-    fn subscribe_change(&self) -> broadcast::Receiver<PlayerUpdate> {
+    fn subscribe_change(&self) -> Receiver<PlayerUpdate> {
        debug!("Creating new subscription");
        let rx = self.tx.subscribe();

@@ -281,7 +236,9 @@ impl MusicClient for Client {
                playlist_position: 0,
                playlist_length: 0,
                state: PlayerState::Stopped,
-                volume_percent: None,
+                elapsed: None,
+                duration: None,
+                volume_percent: 0,
            };
            send!(self.tx, PlayerUpdate::Update(Box::new(None), status));
        }
@@ -300,18 +257,9 @@ impl From<Metadata> for Track {
        const KEY_GENRE: &str = "xesam:genre";

        Self {
-            title: value
-                .title()
-                .map(std::string::ToString::to_string)
-                .and_then(replace_empty_none),
-            album: value
-                .album_name()
-                .map(std::string::ToString::to_string)
-                .and_then(replace_empty_none),
-            artist: value
-                .artists()
-                .map(|artists| artists.join(", "))
-                .and_then(replace_empty_none),
+            title: value.title().map(std::string::ToString::to_string),
+            album: value.album_name().map(std::string::ToString::to_string),
+            artist: value.artists().map(|artists| artists.join(", ")),
            date: value
                .get(KEY_DATE)
                .and_then(mpris::MetadataValue::as_string)
@@ -336,11 +284,3 @@ impl From<PlaybackStatus> for PlayerState {
        }
    }
 }
-
-fn replace_empty_none(string: String) -> Option<String> {
-    if string.is_empty() {
-        None
-    } else {
-        Some(string)
-    }
-}
--- a/src/clients/system_tray.rs
+++ b/src/clients/system_tray.rs
@@ -1,14 +1,14 @@
 use crate::unique_id::get_unique_usize;
-use crate::{arc_mut, lock, send};
+use crate::{lock, send};
 use async_once::AsyncOnce;
 use color_eyre::Report;
 use lazy_static::lazy_static;
 use std::collections::BTreeMap;
 use std::sync::{Arc, Mutex};
-use system_tray::message::menu::TrayMenu;
-use system_tray::message::tray::StatusNotifierItem;
-use system_tray::message::{NotifierItemCommand, NotifierItemMessage};
-use system_tray::StatusNotifierWatcher;
+use stray::message::menu::TrayMenu;
+use stray::message::tray::StatusNotifierItem;
+use stray::message::{NotifierItemCommand, NotifierItemMessage};
+use stray::StatusNotifierWatcher;
 use tokio::spawn;
 use tokio::sync::{broadcast, mpsc};
 use tracing::{debug, error, trace};
@@ -24,7 +24,7 @@ pub struct TrayEventReceiver {
 }

 impl TrayEventReceiver {
-    async fn new() -> system_tray::error::Result<Self> {
+    async fn new() -> stray::error::Result<Self> {
        let id = format!("ironbar-{}", get_unique_usize());

        let (tx, rx) = mpsc::channel(16);
@@ -33,7 +33,7 @@ impl TrayEventReceiver {
        let tray = StatusNotifierWatcher::new(rx).await?;
        let mut host = Box::pin(tray.create_notifier_host(&id)).await?;

-        let tray = arc_mut!(BTreeMap::new());
+        let tray = Arc::new(Mutex::new(BTreeMap::new()));

        {
            let b_tx = b_tx.clone();
--- a/src/clients/wayland/client.rs
+++ b/src/clients/wayland/client.rs
@@ -25,7 +25,7 @@ cfg_if! {
        use super::ClipboardItem;
        use super::wlr_data_control::manager::DataControlDeviceManagerState;
        use crate::lock;
-        use std::sync::Arc;
+        use std::sync::{Arc, Mutex};
    }
 }

@@ -138,7 +138,7 @@ impl WaylandClient {
                seats: vec![],
                handles: HashMap::new(),
                #[cfg(feature = "clipboard")]
-                clipboard: crate::arc_mut!(None),
+                clipboard: Arc::new(Mutex::new(None)),
                toplevel_tx,
                #[cfg(feature = "clipboard")]
                clipboard_tx,
--- a/src/clients/wayland/mod.rs
+++ b/src/clients/wayland/mod.rs
@@ -6,7 +6,7 @@ mod wl_seat;
 mod wlr_foreign_toplevel;

 use self::wlr_foreign_toplevel::manager::ToplevelManagerState;
-use crate::{arc_mut, delegate_foreign_toplevel_handle, delegate_foreign_toplevel_manager};
+use crate::{delegate_foreign_toplevel_handle, delegate_foreign_toplevel_manager};
 use cfg_if::cfg_if;
 use lazy_static::lazy_static;
 use smithay_client_toolkit::output::OutputState;
@@ -105,7 +105,7 @@ impl ProvidesRegistryState for Environment {
 }

 lazy_static! {
-    static ref CLIENT: Arc<Mutex<WaylandClient>> = arc_mut!(WaylandClient::new());
+    static ref CLIENT: Arc<Mutex<WaylandClient>> = Arc::new(Mutex::new(WaylandClient::new()));
 }

 pub fn get_client() -> Arc<Mutex<WaylandClient>> {
--- a/src/clients/wayland/wlr_data_control/mod.rs
+++ b/src/clients/wayland/wlr_data_control/mod.rs
@@ -239,7 +239,7 @@ impl DataControlOfferHandler for Environment {
        _offer: &mut DataControlDeviceOffer,
        _mime_type: String,
    ) {
-        trace!("Handler received offer");
+        debug!("Handler received offer");
    }
 }

@@ -315,6 +315,22 @@ impl DataControlSourceHandler for Environment {
                        }
                    }
                }
+
+                // for chunk in bytes.chunks(pipe_size as usize) {
+                //     trace!("Writing chunk");
+                //     file.write(chunk).expect("Failed to write chunk to buffer");
+                //     file.flush().expect("Failed to flush to file");
+                // }
+
+                // match file.write_vectored(&bytes.chunks(pipe_size as usize).map(IoSlice::new).collect::<Vec<_>>()) {
+                //     Ok(_) => debug!("Copied item"),
+                //     Err(err) => error!("{err:?}"),
+                // }
+
+                // match file.write_all(bytes) {
+                //     Ok(_) => debug!("Copied item"),
+                //     Err(err) => error!("{err:?}"),
+                // }
            } else {
                error!("Failed to find source");
            }
@@ -359,14 +375,11 @@ fn set_pipe_size(fd: RawFd, size: usize) -> io::Result<i32> {

    let new_size = if size > curr_size {
        trace!("Requesting pipe size increase to (at least): {size}");
-
        let res = fcntl(fd, F_SETPIPE_SZ(size as i32))?;
        trace!("New pipe size: {res}");
-
        if res < size as i32 {
            return Err(io::Error::last_os_error());
        }
-
        res
    } else {
        size as i32
--- a/src/clients/wayland/wlr_data_control/offer.rs
+++ b/src/clients/wayland/wlr_data_control/offer.rs
@@ -7,7 +7,7 @@ use smithay_client_toolkit::data_device_manager::ReadPipe;
 use std::ops::DerefMut;
 use std::os::fd::FromRawFd;
 use std::sync::{Arc, Mutex};
-use tracing::{trace, warn};
+use tracing::{debug, warn};
 use wayland_client::{Connection, Dispatch, Proxy, QueueHandle};
 use wayland_protocols_wlr::data_control::v1::client::zwlr_data_control_offer_v1::{
    Event, ZwlrDataControlOfferV1,
@@ -149,7 +149,7 @@ where
        let data = data.data_control_offer_data();

        if let Event::Offer { mime_type } = event {
-            trace!("Adding new offer with type '{mime_type}'");
+            debug!("Adding new offer with type '{mime_type}'");
            data.push_mime_type(mime_type.clone());
            state.offer(conn, qh, &mut lock!(data.inner).offer, mime_type);
        }
--- a/src/clients/wayland/wlr_foreign_toplevel/mod.rs
+++ b/src/clients/wayland/wlr_foreign_toplevel/mod.rs
@@ -30,7 +30,7 @@ impl ToplevelManagerHandler for Environment {

 impl ToplevelHandleHandler for Environment {
    fn new_handle(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, handle: ToplevelHandle) {
-        trace!("Handler received new handle");
+        debug!("Handler received new handle");

        match handle.info() {
            Some(info) => {
@@ -50,7 +50,7 @@ impl ToplevelHandleHandler for Environment {
        _qh: &QueueHandle<Self>,
        handle: ToplevelHandle,
    ) {
-        trace!("Handler received handle update");
+        debug!("Handler received handle update");

        match handle.info() {
            Some(info) => {
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -21,7 +21,6 @@ use crate::modules::tray::TrayModule;
 use crate::modules::upower::UpowerModule;
 #[cfg(feature = "workspaces")]
 use crate::modules::workspaces::WorkspacesModule;
-use cfg_if::cfg_if;
 use serde::Deserialize;
 use std::collections::HashMap;

@@ -31,7 +30,7 @@ pub use self::truncate::{EllipsizeMode, TruncateMode};
 #[derive(Debug, Deserialize, Clone)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ModuleConfig {
-    #[cfg(feature = "clipboard")]
+    #[cfg(feature = "clock")]
    Clipboard(Box<ClipboardModule>),
    #[cfg(feature = "clock")]
    Clock(Box<ClockModule>),
@@ -97,7 +96,6 @@ pub struct Config {
    pub margin: MarginConfig,
    #[serde(default = "default_popup_gap")]
    pub popup_gap: i32,
-    pub name: Option<String>,

    /// GTK icon theme to use.
    pub icon_theme: Option<String>,
@@ -111,36 +109,6 @@ pub struct Config {
    pub monitors: Option<HashMap<String, MonitorConfig>>,
 }

-impl Default for Config {
-    fn default() -> Self {
-        cfg_if! {
-            if #[cfg(feature = "clock")] {
-                let end = Some(vec![ModuleConfig::Clock(Box::default())]);
-            }
-            else {
-                let end = None;
-            }
-        }
-
-        Self {
-            position: BarPosition::default(),
-            height: default_bar_height(),
-            margin: MarginConfig::default(),
-            name: None,
-            popup_gap: default_popup_gap(),
-            icon_theme: None,
-            ironvar_defaults: None,
-            start: Some(vec![ModuleConfig::Label(
-                LabelModule::new("ℹ️ Using default config".to_string()).into(),
-            )]),
-            center: Some(vec![ModuleConfig::Focused(Box::default())]),
-            end,
-            anchor_to_edges: default_true(),
-            monitors: None,
-        }
-    }
-}
-
 const fn default_bar_height() -> i32 {
    42
 }
--- a/src/desktop_file.rs
+++ b/src/desktop_file.rs
@@ -1,7 +1,8 @@
 use lazy_static::lazy_static;
 use std::collections::{HashMap, HashSet};
-use std::env;
-use std::fs;
+use std::fs::File;
+use std::io;
+use std::io::BufRead;
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 use tracing::warn;
@@ -28,14 +29,6 @@ fn find_application_dirs() -> Vec<PathBuf> {
        PathBuf::from("/var/lib/flatpak/exports/share/applications"), // flatpak apps
    ];

-    let xdg_dirs = env::var_os("XDG_DATA_DIRS");
-    if let Some(xdg_dirs) = xdg_dirs {
-        for mut xdg_dir in env::split_paths(&xdg_dirs).map(PathBuf::from) {
-            xdg_dir.push("applications");
-            dirs.push(xdg_dir);
-        }
-    }
-
    let user_dir = dirs::data_local_dir(); // user installed apps
    if let Some(mut user_dir) = user_dir {
        user_dir.push("applications");
@@ -65,40 +58,33 @@ pub fn find_desktop_file(app_id: &str) -> Option<PathBuf> {
    // this is necessary to invalidate the cache
    let files = find_desktop_files();

-    find_desktop_file_by_filename(app_id, &files)
-        .or_else(|| find_desktop_file_by_filedata(app_id, &files))
+    if let Some(path) = find_desktop_file_by_filename(app_id, &files) {
+        return Some(path);
+    }
+
+    find_desktop_file_by_filedata(app_id, &files)
 }

 /// Finds the correct desktop file using a simple condition check
 fn find_desktop_file_by_filename(app_id: &str, files: &[PathBuf]) -> Option<PathBuf> {
-    let with_names = files
-        .iter()
-        .map(|f| {
-            (
-                f,
-                f.file_stem()
-                    .unwrap_or_default()
-                    .to_string_lossy()
-                    .to_lowercase(),
-            )
-        })
-        .collect::<Vec<_>>();
+    let app_id = app_id.to_lowercase();

-    with_names
+    files
        .iter()
-        // first pass - check for exact match
-        .find(|(_, name)| name.eq_ignore_ascii_case(app_id))
-        // second pass - check for substring
-        .or_else(|| {
-            with_names.iter().find(|(_, name)| {
-                // this will attempt to find flatpak apps that are in the format
-                // `com.company.app` or `com.app.something`
-                app_id
-                    .split(&[' ', ':', '@', '.', '_'][..])
-                    .any(|part| name.eq_ignore_ascii_case(part))
-            })
+        .find(|file| {
+            let file_name: String = file
+                .file_name()
+                .expect("file name doesn't end with ...")
+                .to_string_lossy()
+                .to_lowercase();
+
+            file_name.contains(&app_id)
+                || app_id
+                    .split(&['-', ' ', ':', '@', '.', '_'][..])
+                    .any(|part| file_name.contains(part)) // this will attempt to find flatpak apps that are like this
+                                                          // `com.company.app` or `com.app.something`
        })
-        .map(|(file, _)| file.into())
+        .map(ToOwned::to_owned)
 }

 /// Finds the correct desktop file using the keys in `DESKTOP_FILES_LOOK_OUT_KEYS`
@@ -106,7 +92,7 @@ fn find_desktop_file_by_filedata(app_id: &str, files: &[PathBuf]) -> Option<Path
    let app_id = &app_id.to_lowercase();
    let mut desktop_files_cache = lock!(DESKTOP_FILES);

-    let files = files
+    files
        .iter()
        .filter_map(|file| {
            let Some(parsed_desktop_file) = parse_desktop_file(file) else { return None };
@@ -114,71 +100,46 @@ fn find_desktop_file_by_filedata(app_id: &str, files: &[PathBuf]) -> Option<Path
            desktop_files_cache.insert(file.clone(), parsed_desktop_file.clone());
            Some((file.clone(), parsed_desktop_file))
        })
-        .collect::<Vec<_>>();
-
-    let file = files
-        .iter()
-        // first pass - check name key for exact match
        .find(|(_, desktop_file)| {
            desktop_file
-                .get("Name")
-                .map(|names| names.iter().any(|name| name.eq_ignore_ascii_case(app_id)))
-                .unwrap_or_default()
+                .values()
+                .flatten()
+                .any(|value| value.to_lowercase().contains(app_id))
        })
-        // second pass - check name key for substring
-        .or_else(|| {
-            files.iter().find(|(_, desktop_file)| {
-                desktop_file
-                    .get("Name")
-                    .map(|names| {
-                        names
-                            .iter()
-                            .any(|name| name.to_lowercase().contains(app_id))
-                    })
-                    .unwrap_or_default()
-            })
-        })
-        // third pass - check all keys for substring
-        .or_else(|| {
-            files.iter().find(|(_, desktop_file)| {
-                desktop_file
-                    .values()
-                    .flatten()
-                    .any(|value| value.to_lowercase().contains(app_id))
-            })
-        });
-
-    file.map(|(path, _)| path).cloned()
+        .map(|(path, _)| path)
 }

 /// Parses a desktop file into a hashmap of keys/vector(values).
 fn parse_desktop_file(path: &Path) -> Option<DesktopFile> {
-    let Ok(file) = fs::read_to_string(path) else {
+    let Ok(file) = File::open(path) else {
        warn!("Couldn't Open File: {}", path.display());
-        return None;
+            return None;
    };

+    let lines = io::BufReader::new(file).lines();
+
    let mut desktop_file: DesktopFile = DesktopFile::new();

-    file.lines()
-        .filter_map(|line| {
-            let Some((key, value)) = line.split_once('=') else { return None };
+    let _ = lines.flatten().map(|line| {
+        line.split_once('=')
+            .iter()
+            .filter_map(|(key, value)| {
+                let key = key.trim();
+                let value = value.trim();

-            let key = key.trim();
-            let value = value.trim();
-
-            if DESKTOP_FILES_LOOK_OUT_KEYS.contains(key) {
-                Some((key, value))
-            } else {
-                None
-            }
-        })
-        .for_each(|(key, value)| {
-            desktop_file
-                .entry(key.to_string())
-                .or_insert_with(Vec::new)
-                .push(value.to_string());
-        });
+                if DESKTOP_FILES_LOOK_OUT_KEYS.contains(key) {
+                    Some((key, value))
+                } else {
+                    None
+                }
+            })
+            .for_each(|(key, value)| {
+                desktop_file
+                    .entry(key.to_string())
+                    .or_insert_with(Vec::new)
+                    .push(value.to_string());
+            });
+    });

    Some(desktop_file)
 }
--- a/src/dynamic_value/dynamic_string.rs
+++ b/src/dynamic_value/dynamic_string.rs
@@ -1,8 +1,9 @@
 #[cfg(feature = "ipc")]
 use crate::ironvar::get_variable_manager;
 use crate::script::{OutputStream, Script};
-use crate::{arc_mut, lock, send};
+use crate::{lock, send};
 use gtk::prelude::*;
+use std::sync::{Arc, Mutex};
 use tokio::spawn;

 /// A segment of a dynamic string,
@@ -33,7 +34,7 @@ where
 {
    let tokens = parse_input(input);

-    let label_parts = arc_mut!(vec![]);
+    let label_parts = Arc::new(Mutex::new(Vec::new()));
    let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);

    for (i, segment) in tokens.into_iter().enumerate() {
@@ -144,7 +145,7 @@ fn parse_script(chars: &[char]) -> (DynamicStringSegment, usize) {
        .map(|w| w[0])
        .collect::<String>();

-    let len = str.chars().count() + SKIP_BRACKETS;
+    let len = str.len() + SKIP_BRACKETS;
    let script = Script::from(str.as_str());

    (DynamicStringSegment::Script(script), len)
@@ -160,7 +161,7 @@ fn parse_variable(chars: &[char]) -> (DynamicStringSegment, usize) {
        .take_while(|&c| !c.is_whitespace())
        .collect::<String>();

-    let len = str.chars().count() + SKIP_HASH;
+    let len = str.len() + SKIP_HASH;
    let value = str.into();

    (DynamicStringSegment::Variable(value), len)
@@ -173,16 +174,15 @@ fn parse_static(chars: &[char]) -> (DynamicStringSegment, usize) {
        .map(|w| w[0])
        .collect::<String>();

-    let mut char_count = str.chars().count();
-
    // if segment is at end of string, last char gets missed above due to uneven window.
-    if chars.len() == char_count + 1 {
-        let remaining_char = *chars.get(char_count).expect("Failed to find last char");
+    if chars.len() == str.len() + 1 {
+        let remaining_char = *chars.get(str.len()).expect("Failed to find last char");
        str.push(remaining_char);
-        char_count += 1;
    }

-    (DynamicStringSegment::Static(str), char_count)
+    let len = str.len();
+
+    (DynamicStringSegment::Static(str), len)
 }

 #[cfg(test)]
--- a/src/error.rs
+++ b/src/error.rs
@@ -2,6 +2,7 @@
 pub enum ExitCode {
    GtkDisplay = 1,
    CreateBars = 2,
+    Config = 3,
 }

 pub const ERR_OUTPUTS: &str = "GTK and Wayland are reporting a different set of outputs - this is a severe bug and should never happen";
--- a/src/global_state.rs
+++ b/src/global_state.rs
@@ -1,43 +0,0 @@
-use crate::popup::Popup;
-use crate::write_lock;
-use std::collections::HashMap;
-use std::sync::{Arc, RwLock, RwLockWriteGuard};
-
-/// Global application state shared across all bars.
-///
-/// Data that needs to be accessed from anywhere
-/// that is not otherwise accessible should be placed on here.
-#[derive(Debug)]
-pub struct GlobalState {
-    popups: HashMap<Box<str>, Arc<RwLock<Popup>>>,
-}
-
-impl GlobalState {
-    pub(crate) fn new() -> Self {
-        Self {
-            popups: HashMap::new(),
-        }
-    }
-
-    pub fn popups(&self) -> &HashMap<Box<str>, Arc<RwLock<Popup>>> {
-        &self.popups
-    }
-
-    pub fn popups_mut(&mut self) -> &mut HashMap<Box<str>, Arc<RwLock<Popup>>> {
-        &mut self.popups
-    }
-
-    pub fn with_popup_mut<F, T>(&self, monitor_name: &str, f: F) -> Option<T>
-    where
-        F: FnOnce(RwLockWriteGuard<Popup>) -> T,
-    {
-        let popup = self.popups().get(monitor_name);
-
-        if let Some(popup) = popup {
-            let popup = write_lock!(popup);
-            Some(f(popup))
-        } else {
-            None
-        }
-    }
-}
--- a/src/gtk_helpers.rs
+++ b/src/gtk_helpers.rs
@@ -1,77 +1,8 @@
 use glib::IsA;
 use gtk::prelude::*;
-use gtk::{Orientation, Widget};
+use gtk::Widget;

-/// Represents a widget's size
-/// and location relative to the bar's start edge.
-#[derive(Debug, Copy, Clone)]
-pub struct WidgetGeometry {
-    /// Position of the start edge of the widget
-    /// from the start edge of the bar.
-    pub position: i32,
-    /// The length of the widget.
-    pub size: i32,
-    /// The length of the bar.
-    pub bar_size: i32,
-}
-
-pub trait IronbarGtkExt {
-    /// Adds a new CSS class to the widget.
-    fn add_class(&self, class: &str);
-    /// Gets the geometry for the widget
-    fn geometry(&self, orientation: Orientation) -> WidgetGeometry;
-
-    /// Gets a data tag on a widget, if it exists.
-    fn get_tag<V: 'static>(&self, key: &str) -> Option<&V>;
-    /// Sets a data tag on a widget.
-    fn set_tag<V: 'static>(&self, key: &str, value: V);
-}
-
-impl<W: IsA<Widget>> IronbarGtkExt for W {
-    fn add_class(&self, class: &str) {
-        self.style_context().add_class(class);
-    }
-
-    fn geometry(&self, orientation: Orientation) -> WidgetGeometry {
-        let allocation = self.allocation();
-
-        let widget_size = if orientation == Orientation::Horizontal {
-            allocation.width()
-        } else {
-            allocation.height()
-        };
-
-        let top_level = self.toplevel().expect("Failed to get top-level widget");
-        let top_level_allocation = top_level.allocation();
-
-        let bar_size = if orientation == Orientation::Horizontal {
-            top_level_allocation.width()
-        } else {
-            top_level_allocation.height()
-        };
-
-        let (widget_x, widget_y) = self
-            .translate_coordinates(&top_level, 0, 0)
-            .unwrap_or((0, 0));
-
-        let widget_pos = if orientation == Orientation::Horizontal {
-            widget_x
-        } else {
-            widget_y
-        };
-
-        WidgetGeometry {
-            position: widget_pos,
-            size: widget_size,
-            bar_size,
-        }
-    }
-
-    fn get_tag<V: 'static>(&self, key: &str) -> Option<&V> {
-        unsafe { self.data(key).map(|val| val.as_ref()) }
-    }
-
-    fn set_tag<V: 'static>(&self, key: &str, value: V) {
-        unsafe { self.set_data(key, value) }
-    }
+/// Adds a new CSS class to a widget.
+pub fn add_class<W: IsA<Widget>>(widget: &W, class: &str) {
+    widget.style_context().add_class(class);
 }
--- a/src/image/gtk.rs
+++ b/src/image/gtk.rs
@@ -1,5 +1,5 @@
 use super::ImageProvider;
-use crate::gtk_helpers::IronbarGtkExt;
+use crate::gtk_helpers::add_class;
 use gtk::prelude::*;
 use gtk::{Button, IconTheme, Image, Label, Orientation};

@@ -9,10 +9,10 @@ pub fn new_icon_button(input: &str, icon_theme: &IconTheme, size: i32) -> Button

    if ImageProvider::is_definitely_image_input(input) {
        let image = Image::new();
-        image.add_class("image");
-        image.add_class("icon");
+        add_class(&image, "image");
+        add_class(&image, "icon");

-        match ImageProvider::parse(input, icon_theme, false, size)
+        match ImageProvider::parse(input, icon_theme, size)
            .map(|provider| provider.load_into_image(image.clone()))
        {
            Some(_) => {
@@ -36,17 +36,17 @@ pub fn new_icon_label(input: &str, icon_theme: &IconTheme, size: i32) -> gtk::Bo

    if ImageProvider::is_definitely_image_input(input) {
        let image = Image::new();
-        image.add_class("icon");
-        image.add_class("image");
+        add_class(&image, "icon");
+        add_class(&image, "image");

        container.add(&image);

-        ImageProvider::parse(input, icon_theme, false, size)
+        ImageProvider::parse(input, icon_theme, size)
            .map(|provider| provider.load_into_image(image));
    } else {
        let label = Label::new(Some(input));
-        label.add_class("icon");
-        label.add_class("text-icon");
+        add_class(&label, "icon");
+        add_class(&label, "text-icon");

        container.add(&label);
    }
--- a/src/image/provider.rs
+++ b/src/image/provider.rs
@@ -41,44 +41,23 @@ impl<'a> ImageProvider<'a> {
    ///
    /// Note this checks that icons exist in theme, or files exist on disk
    /// but no other check is performed.
-    pub fn parse(input: &str, theme: &'a IconTheme, use_fallback: bool, size: i32) -> Option<Self> {
-        let location = Self::get_location(input, theme, size, use_fallback, 0)?;
-
+    pub fn parse(input: &str, theme: &'a IconTheme, size: i32) -> Option<Self> {
+        let location = Self::get_location(input, theme, size)?;
        Some(Self { location, size })
    }

    /// Returns true if the input starts with a prefix
    /// that is supported by the parser
    /// (ie the parser would not fallback to checking the input).
+    #[cfg(any(feature = "music", feature = "workspaces"))]
    pub fn is_definitely_image_input(input: &str) -> bool {
        input.starts_with("icon:")
            || input.starts_with("file://")
            || input.starts_with("http://")
            || input.starts_with("https://")
-            || input.starts_with('/')
    }

-    fn get_location(
-        input: &str,
-        theme: &'a IconTheme,
-        size: i32,
-        use_fallback: bool,
-        recurse_depth: usize,
-    ) -> Option<ImageLocation<'a>> {
-        macro_rules! fallback {
-            () => {
-                if use_fallback {
-                    Some(Self::get_fallback_icon(theme))
-                } else {
-                    None
-                }
-            };
-        }
-
-        const MAX_RECURSE_DEPTH: usize = 2;
-
-        let should_parse_desktop_file = !Self::is_definitely_image_input(input);
-
+    fn get_location(input: &str, theme: &'a IconTheme, size: i32) -> Option<ImageLocation<'a>> {
        let (input_type, input_name) = input
            .split_once(':')
            .map_or((None, input), |(t, n)| (Some(t), n));
@@ -113,26 +92,21 @@ impl<'a> ImageProvider<'a> {
                    Report::msg(format!("Unsupported image type: {input_type}"))
                        .note("You may need to recompile with support if available")
                );
-                fallback!()
+                None
            }
            None if PathBuf::from(input_name).is_file() => {
                Some(ImageLocation::Local(PathBuf::from(input_name)))
            }
-            None if recurse_depth == MAX_RECURSE_DEPTH => fallback!(),
-            None if should_parse_desktop_file => {
-                if let Some(location) = get_desktop_icon_name(input_name).map(|input| {
-                    Self::get_location(&input, theme, size, use_fallback, recurse_depth + 1)
-                }) {
+            None => {
+                if let Some(location) = get_desktop_icon_name(input_name)
+                    .map(|input| Self::get_location(&input, theme, size))
+                {
                    location
                } else {
                    warn!("Failed to find image: {input}");
-                    fallback!()
+                    None
                }
            }
-            None => {
-                warn!("Failed to find image: {input}");
-                fallback!()
-            }
        }
    }

@@ -274,11 +248,4 @@ impl<'a> ImageProvider<'a> {
            )))
        }
    }
-
-    fn get_fallback_icon(theme: &'a IconTheme) -> ImageLocation<'a> {
-        ImageLocation::Icon {
-            name: "dialog-question-symbolic".to_string(),
-            theme,
-        }
-    }
 }
--- a/src/ipc/commands.rs
+++ b/src/ipc/commands.rs
@@ -1,10 +1,9 @@
-use std::path::PathBuf;
-
 use clap::Subcommand;
 use serde::{Deserialize, Serialize};
+use std::path::PathBuf;

 #[derive(Subcommand, Debug, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
+#[serde(tag = "type")]
 pub enum Command {
    /// Return "ok"
    Ping,
@@ -12,15 +11,12 @@ pub enum Command {
    /// Open the GTK inspector
    Inspect,

-    /// Reload the config
-    Reload,
-
    /// Set an `ironvar` value.
    /// This creates it if it does not already exist, and updates it if it does.
    /// Any references to this variable are automatically and immediately updated.
    /// Keys and values can be any valid UTF-8 string.
    Set {
-        /// Variable key. Can be any alphanumeric ASCII string.
+        /// Variable key. Can be any valid UTF-8 string.
        key: Box<str>,
        /// Variable value. Can be any valid UTF-8 string.
        value: String,
@@ -38,42 +34,4 @@ pub enum Command {
        /// The path to the sheet.
        path: PathBuf,
    },
-
-    /// Set the visibility of the bar with the given name.
-    SetVisible {
-        ///Bar name to target.
-        bar_name: String,
-        /// The visibility status.
-        #[arg(short, long)]
-        visible: bool,
-    },
-
-    /// Get the visibility of the bar with the given name.
-    GetVisible {
-        /// Bar name to target.
-        bar_name: String,
-    },
-
-    /// Toggle a popup open/closed.
-    /// If opening this popup, and a different popup on the same bar is already open, the other is closed.
-    TogglePopup {
-        /// The name of the monitor the bar is located on.
-        bar_name: String,
-        /// The name of the widget.
-        name: String,
-    },
-
-    /// Open a popup, regardless of current state.
-    OpenPopup {
-        /// The name of the monitor the bar is located on.
-        bar_name: String,
-        /// The name of the widget.
-        name: String,
-    },
-
-    /// Close a popup, regardless of current state.
-    ClosePopup {
-        /// The name of the monitor the bar is located on.
-        bar_name: String,
-    },
 }
--- a/src/ipc/mod.rs
+++ b/src/ipc/mod.rs
@@ -3,25 +3,21 @@ pub mod commands;
 pub mod responses;
 mod server;

-use std::cell::RefCell;
-use std::path::{Path, PathBuf};
-use std::rc::Rc;
+use std::path::PathBuf;
 use tracing::warn;

-use crate::GlobalState;
 pub use commands::Command;
 pub use responses::Response;

 #[derive(Debug)]
 pub struct Ipc {
    path: PathBuf,
-    global_state: Rc<RefCell<GlobalState>>,
 }

 impl Ipc {
    /// Creates a new IPC instance.
    /// This can be used as both a server and client.
-    pub fn new(global_state: Rc<RefCell<GlobalState>>) -> Self {
+    pub fn new() -> Self {
        let ipc_socket_file = std::env::var("XDG_RUNTIME_DIR")
            .map_or_else(|_| PathBuf::from("/tmp"), PathBuf::from)
            .join("ironbar-ipc.sock");
@@ -32,11 +28,6 @@ impl Ipc {

        Self {
            path: ipc_socket_file,
-            global_state,
        }
    }
-
-    pub fn path(&self) -> &Path {
-        self.path.as_path()
-    }
 }
--- a/src/ipc/responses.rs
+++ b/src/ipc/responses.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};

 #[derive(Debug, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
+#[serde(tag = "type")]
 pub enum Response {
    Ok,
    OkValue { value: String },
--- a/src/ipc/server.rs
+++ b/src/ipc/server.rs
@@ -1,32 +1,24 @@
-use std::cell::RefCell;
-use std::fs;
-use std::path::Path;
-use std::rc::Rc;
-
-use color_eyre::{Report, Result};
-use glib::Continue;
-use gtk::prelude::*;
-use gtk::Application;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::{UnixListener, UnixStream};
-use tokio::spawn;
-use tokio::sync::mpsc::{self, Receiver, Sender};
-use tracing::{debug, error, info, warn};
-
+use super::Ipc;
 use crate::bridge_channel::BridgeChannel;
 use crate::ipc::{Command, Response};
 use crate::ironvar::get_variable_manager;
-use crate::modules::PopupButton;
 use crate::style::load_css;
-use crate::{read_lock, send_async, try_send, write_lock, GlobalState};
-
-use super::Ipc;
+use crate::{read_lock, send_async, try_send, write_lock};
+use color_eyre::{Report, Result};
+use glib::Continue;
+use std::fs;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::{UnixListener, UnixStream};
+use tokio::spawn;
+use tokio::sync::mpsc;
+use tokio::sync::mpsc::{Receiver, Sender};
+use tracing::{debug, error, info, warn};

 impl Ipc {
    /// Starts the IPC server on its socket.
    ///
    /// Once started, the server will begin accepting connections.
-    pub fn start(&self, application: &Application) {
+    pub fn start(&self) {
        let bridge = BridgeChannel::<Command>::new();
        let cmd_tx = bridge.create_sender();
        let (res_tx, mut res_rx) = mpsc::channel(32);
@@ -36,7 +28,7 @@ impl Ipc {
        if path.exists() {
            warn!("Socket already exists. Did Ironbar exit abruptly?");
            warn!("Attempting IPC shutdown to allow binding to address");
-            Self::shutdown(&path);
+            self.shutdown();
        }

        spawn(async move {
@@ -69,10 +61,8 @@ impl Ipc {
            }
        });

-        let application = application.clone();
-        let global_state = self.global_state.clone();
        bridge.recv(move |command| {
-            let res = Self::handle_command(command, &application, &global_state);
+            let res = Self::handle_command(command);
            try_send!(res_tx, res);
            Continue(true)
        });
@@ -112,27 +102,12 @@ impl Ipc {
    /// Takes an input command, runs it and returns with the appropriate response.
    ///
    /// This runs on the main thread, allowing commands to interact with GTK.
-    fn handle_command(
-        command: Command,
-        application: &Application,
-        global_state: &Rc<RefCell<GlobalState>>,
-    ) -> Response {
+    fn handle_command(command: Command) -> Response {
        match command {
            Command::Inspect => {
                gtk::Window::set_interactive_debugging(true);
                Response::Ok
            }
-            Command::Reload => {
-                info!("Closing existing bars");
-                let windows = application.windows();
-                for window in windows {
-                    window.close();
-                }
-
-                crate::load_interface(application, global_state);
-
-                Response::Ok
-            }
            Command::Set { key, value } => {
                let variable_manager = get_variable_manager();
                let mut variable_manager = write_lock!(variable_manager);
@@ -157,107 +132,13 @@ impl Ipc {
                    Response::error("File not found")
                }
            }
-            Command::TogglePopup { bar_name, name } => {
-                let global_state = global_state.borrow();
-                let response = global_state.with_popup_mut(&bar_name, |mut popup| {
-                    let current_widget = popup.current_widget();
-                    popup.hide();
-
-                    let data = popup
-                        .cache
-                        .iter()
-                        .find(|(_, (module_name, _))| module_name == &name)
-                        .map(|module| (module, module.1 .1.buttons.first()));
-
-                    match data {
-                        Some(((&id, _), Some(button))) if current_widget != Some(id) => {
-                            let button_id = button.popup_id();
-                            popup.show(id, button_id);
-
-                            Response::Ok
-                        }
-                        Some((_, None)) => Response::error("Module has no popup functionality"),
-                        Some(_) => Response::Ok,
-                        None => Response::error("Invalid module name"),
-                    }
-                });
-
-                response.unwrap_or_else(|| Response::error("Invalid monitor name"))
-            }
-            Command::OpenPopup { bar_name, name } => {
-                let global_state = global_state.borrow();
-                let response = global_state.with_popup_mut(&bar_name, |mut popup| {
-                    // only one popup per bar, so hide if open for another widget
-                    popup.hide();
-
-                    let data = popup
-                        .cache
-                        .iter()
-                        .find(|(_, (module_name, _))| module_name == &name)
-                        .map(|module| (module, module.1 .1.buttons.first()));
-
-                    match data {
-                        Some(((&id, _), Some(button))) => {
-                            let button_id = button.popup_id();
-                            popup.show(id, button_id);
-
-                            Response::Ok
-                        }
-                        Some((_, None)) => Response::error("Module has no popup functionality"),
-                        None => Response::error("Invalid module name"),
-                    }
-                });
-
-                response.unwrap_or_else(|| Response::error("Invalid monitor name"))
-            }
-            Command::ClosePopup { bar_name } => {
-                let global_state = global_state.borrow();
-                let popup_found = global_state
-                    .with_popup_mut(&bar_name, |mut popup| popup.hide())
-                    .is_some();
-
-                if popup_found {
-                    Response::Ok
-                } else {
-                    Response::error("Invalid monitor name")
-                }
-            }
            Command::Ping => Response::Ok,
-            Command::SetVisible { bar_name, visible } => {
-                let windows = application.windows();
-                let found = windows
-                    .iter()
-                    .find(|window| window.widget_name() == bar_name);
-
-                if let Some(window) = found {
-                    window.set_visible(visible);
-                    Response::Ok
-                } else {
-                    Response::error("Bar not found")
-                }
-            }
-            Command::GetVisible { bar_name } => {
-                let windows = application.windows();
-                let found = windows
-                    .iter()
-                    .find(|window| window.widget_name() == bar_name);
-
-                if let Some(window) = found {
-                    Response::OkValue {
-                        value: window.is_visible().to_string(),
-                    }
-                } else {
-                    Response::error("Bar not found")
-                }
-            }
        }
    }

    /// Shuts down the IPC server,
    /// removing the socket file in the process.
-    ///
-    /// Note this is static as the `Ipc` struct is not `Send`.
-    pub fn shutdown<P: AsRef<Path>>(path: P) {
-        fs::remove_file(&path).ok();
+    pub fn shutdown(&self) {
+        fs::remove_file(&self.path).ok();
    }
 }
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -100,7 +100,7 @@ macro_rules! write_lock {
 #[macro_export]
 macro_rules! arc_mut {
    ($val:expr) => {
-        std::sync::Arc::new(std::sync::Mutex::new($val))
+        std::sync::Arc::new(std::Sync::Mutex::new($val))
    };
 }

--- a/src/main.rs
+++ b/src/main.rs
@@ -1,35 +1,5 @@
 #![doc = include_str!("../README.md")]

-use std::cell::{Cell, RefCell};
-use std::env;
-use std::future::Future;
-use std::path::PathBuf;
-use std::process::exit;
-use std::rc::Rc;
-use std::sync::mpsc;
-
-use cfg_if::cfg_if;
-#[cfg(feature = "cli")]
-use clap::Parser;
-use color_eyre::eyre::Result;
-use color_eyre::Report;
-use dirs::config_dir;
-use gtk::gdk::Display;
-use gtk::prelude::*;
-use gtk::Application;
-use tokio::runtime::Handle;
-use tokio::task::{block_in_place, spawn_blocking};
-use tracing::{debug, error, info, warn};
-use universal_config::ConfigLoader;
-
-use clients::wayland;
-
-use crate::bar::create_bar;
-use crate::config::{Config, MonitorConfig};
-use crate::error::ExitCode;
-use crate::global_state::GlobalState;
-use crate::style::load_css;
-
 mod bar;
 mod bridge_channel;
 #[cfg(feature = "cli")]
@@ -39,7 +9,6 @@ mod config;
 mod desktop_file;
 mod dynamic_value;
 mod error;
-mod global_state;
 mod gtk_helpers;
 mod image;
 #[cfg(feature = "ipc")]
@@ -54,6 +23,33 @@ mod script;
 mod style;
 mod unique_id;

+use crate::bar::create_bar;
+use crate::config::{Config, MonitorConfig};
+use crate::style::load_css;
+use cfg_if::cfg_if;
+#[cfg(feature = "cli")]
+use clap::Parser;
+use color_eyre::eyre::Result;
+use color_eyre::Report;
+use dirs::config_dir;
+use gtk::gdk::Display;
+use gtk::prelude::*;
+use gtk::Application;
+use std::cell::Cell;
+use std::env;
+use std::future::Future;
+use std::path::PathBuf;
+use std::process::exit;
+use std::rc::Rc;
+use std::sync::mpsc;
+use tokio::runtime::Handle;
+use tokio::task::{block_in_place, spawn_blocking};
+
+use crate::error::ExitCode;
+use clients::wayland;
+use tracing::{debug, error, info};
+use universal_config::ConfigLoader;
+
 const GTK_APP_ID: &str = "dev.jstanger.ironbar";
 const VERSION: &str = env!("CARGO_PKG_VERSION");

@@ -61,34 +57,32 @@ const VERSION: &str = env!("CARGO_PKG_VERSION");
 async fn main() {
    let _guard = logging::install_logging();

-    let global_state = Rc::new(RefCell::new(GlobalState::new()));
-
    cfg_if! {
        if #[cfg(feature = "cli")] {
-            run_with_args(global_state).await;
+            run_with_args().await;
        } else {
-            start_ironbar(global_state);
+            start_ironbar();
        }
    }
 }

 #[cfg(feature = "cli")]
-async fn run_with_args(global_state: Rc<RefCell<GlobalState>>) {
+async fn run_with_args() {
    let args = cli::Args::parse();

    match args.command {
        Some(command) => {
-            let ipc = ipc::Ipc::new(global_state);
+            let ipc = ipc::Ipc::new();
            match ipc.send(command).await {
                Ok(res) => cli::handle_response(res),
                Err(err) => error!("{err:?}"),
            };
        }
-        None => start_ironbar(global_state),
+        None => start_ironbar(),
    }
 }

-fn start_ironbar(global_state: Rc<RefCell<GlobalState>>) {
+fn start_ironbar() {
    info!("Ironbar version {}", VERSION);
    info!("Starting application");

@@ -107,12 +101,51 @@ fn start_ironbar(global_state: Rc<RefCell<GlobalState>>) {

        cfg_if! {
            if #[cfg(feature = "ipc")] {
-                let ipc = ipc::Ipc::new(global_state.clone());
-                ipc.start(app);
+                let ipc = ipc::Ipc::new();
+                ipc.start();
            }
        }

-        load_interface(app, &global_state);
+        let display = Display::default().map_or_else(
+            || {
+                let report = Report::msg("Failed to get default GTK display");
+                error!("{:?}", report);
+                exit(ExitCode::GtkDisplay as i32)
+            },
+            |display| display,
+        );
+
+        let config_res = env::var("IRONBAR_CONFIG").map_or_else(
+            |_| ConfigLoader::new("ironbar").find_and_load(),
+            ConfigLoader::load,
+        );
+
+        let mut config: Config = match config_res {
+            Ok(config) => config,
+            Err(err) => {
+                error!("{:?}", err);
+                exit(ExitCode::Config as i32)
+            }
+        };
+
+        debug!("Loaded config file");
+
+        #[cfg(feature = "ipc")]
+        if let Some(ironvars) = config.ironvar_defaults.take() {
+            let variable_manager = ironvar::get_variable_manager();
+            for (k, v) in ironvars {
+                if write_lock!(variable_manager).set(k.clone(), v).is_err() {
+                    tracing::warn!("Ignoring invalid ironvar: '{k}'");
+                }
+            }
+        }
+
+        if let Err(err) = create_bars(app, &display, &config) {
+            error!("{:?}", err);
+            exit(ExitCode::CreateBars as i32);
+        }
+
+        debug!("Created bars");

        let style_path = env::var("IRONBAR_CSS").ok().map_or_else(
            || {
@@ -134,15 +167,13 @@ fn start_ironbar(global_state: Rc<RefCell<GlobalState>>) {

        let (tx, rx) = mpsc::channel();

-        #[cfg(feature = "ipc")]
-        let ipc_path = ipc.path().to_path_buf();
        spawn_blocking(move || {
            rx.recv().expect("to receive from channel");

            info!("Shutting down");

            #[cfg(feature = "ipc")]
-            ipc::Ipc::shutdown(ipc_path);
+            ipc.shutdown();

            exit(0);
        });
@@ -156,58 +187,8 @@ fn start_ironbar(global_state: Rc<RefCell<GlobalState>>) {
    app.run_with_args(&Vec::<&str>::new());
 }

-/// Loads the Ironbar config and interface.
-pub fn load_interface(app: &Application, global_state: &Rc<RefCell<GlobalState>>) {
-    let display = Display::default().map_or_else(
-        || {
-            let report = Report::msg("Failed to get default GTK display");
-            error!("{:?}", report);
-            exit(ExitCode::GtkDisplay as i32)
-        },
-        |display| display,
-    );
-
-    let mut config = env::var("IRONBAR_CONFIG")
-        .map_or_else(
-            |_| ConfigLoader::new("ironbar").find_and_load(),
-            ConfigLoader::load,
-        )
-        .unwrap_or_else(|err| {
-            error!("Failed to load config: {}", err);
-            warn!("Falling back to the default config");
-            info!("If this is your first time using Ironbar, you should create a config in ~/.config/ironbar/");
-            info!("More info here: https://github.com/JakeStanger/ironbar/wiki/configuration-guide");
-
-            Config::default()
-        });
-
-    debug!("Loaded config file");
-
-    #[cfg(feature = "ipc")]
-    if let Some(ironvars) = config.ironvar_defaults.take() {
-        let variable_manager = ironvar::get_variable_manager();
-        for (k, v) in ironvars {
-            if write_lock!(variable_manager).set(k.clone(), v).is_err() {
-                warn!("Ignoring invalid ironvar: '{k}'");
-            }
-        }
-    }
-
-    if let Err(err) = create_bars(app, &display, &config, global_state) {
-        error!("{:?}", err);
-        exit(ExitCode::CreateBars as i32);
-    }
-
-    debug!("Created bars");
-}
-
 /// Creates each of the bars across each of the (configured) outputs.
-fn create_bars(
-    app: &Application,
-    display: &Display,
-    config: &Config,
-    global_state: &Rc<RefCell<GlobalState>>,
-) -> Result<()> {
+fn create_bars(app: &Application, display: &Display, config: &Config) -> Result<()> {
    let wl = wayland::get_client();
    let outputs = lock!(wl).get_outputs();

@@ -229,19 +210,19 @@ fn create_bars(
        config.monitors.as_ref().map_or_else(
            || {
                info!("Creating bar on '{}'", monitor_name);
-                create_bar(app, &monitor, monitor_name, config.clone(), global_state)
+                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(), global_state)
+                        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(), global_state)?;
+                            create_bar(app, &monitor, monitor_name, config.clone())?;
                        }

                        Ok(())
--- a/src/modules/clipboard.rs
+++ b/src/modules/clipboard.rs
@@ -2,9 +2,8 @@ use crate::clients::clipboard::{self, ClipboardEvent};
 use crate::clients::wayland::{ClipboardItem, ClipboardValue};
 use crate::config::{CommonConfig, TruncateMode};
 use crate::image::new_icon_button;
-use crate::modules::{
-    Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, PopupButton, WidgetContext,
-};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::popup::Popup;
 use crate::try_send;
 use gtk::gdk_pixbuf::Pixbuf;
 use gtk::gio::{Cancellable, MemoryInputStream};
@@ -125,26 +124,25 @@ impl Module<Button> for ClipboardModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> color_eyre::Result<ModuleParts<Button>> {
+    ) -> color_eyre::Result<ModuleWidget<Button>> {
+        let position = info.bar_position;
+
        let button = new_icon_button(&self.icon, info.icon_theme, self.icon_size);
        button.style_context().add_class("btn");

        button.connect_clicked(move |button| {
-            try_send!(
-                context.tx,
-                ModuleUpdateEvent::TogglePopup(button.popup_id())
-            );
+            let pos = Popup::widget_geometry(button, position.get_orientation());
+            try_send!(context.tx, ModuleUpdateEvent::TogglePopup(pos));
        });

        // we need to bind to the receiver as the channel does not open
        // until the popup is first opened.
        context.widget_rx.attach(None, |_| Continue(true));

-        let popup = self
-            .into_popup(context.controller_tx, context.popup_rx, info)
-            .into_popup_parts(vec![&button]);
-
-        Ok(ModuleParts::new(button, popup))
+        Ok(ModuleWidget {
+            widget: button,
+            popup: self.into_popup(context.controller_tx, context.popup_rx, info),
+        })
    }

    fn into_popup(
--- a/src/modules/clock.rs
+++ b/src/modules/clock.rs
@@ -1,6 +1,9 @@
-use std::env;
-
-use chrono::{DateTime, Local, Locale};
+use crate::config::CommonConfig;
+use crate::gtk_helpers::add_class;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::popup::Popup;
+use crate::{send_async, try_send};
+use chrono::{DateTime, Local};
 use color_eyre::Result;
 use glib::Continue;
 use gtk::prelude::*;
@@ -10,13 +13,6 @@ use tokio::spawn;
 use tokio::sync::mpsc;
 use tokio::time::sleep;

-use crate::config::CommonConfig;
-use crate::gtk_helpers::IronbarGtkExt;
-use crate::modules::{
-    Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, PopupButton, WidgetContext,
-};
-use crate::{send_async, try_send};
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct ClockModule {
    /// Date/time format string.
@@ -27,48 +23,14 @@ pub struct ClockModule {
    #[serde(default = "default_format")]
    format: String,

-    #[serde(default = "default_popup_format")]
-    format_popup: String,
-
-    #[serde(default = "default_locale")]
-    locale: String,
-
    #[serde(flatten)]
    pub common: Option<CommonConfig>,
 }

-impl Default for ClockModule {
-    fn default() -> Self {
-        ClockModule {
-            format: default_format(),
-            format_popup: default_popup_format(),
-            locale: default_locale(),
-            common: Some(CommonConfig::default()),
-        }
-    }
-}
-
 fn default_format() -> String {
    String::from("%d/%m/%Y %H:%M")
 }

-fn default_popup_format() -> String {
-    String::from("%H:%M:%S")
-}
-
-fn default_locale() -> String {
-    env::var("LC_TIME")
-        .or_else(|_| env::var("LANG"))
-        .map_or_else(|_| "POSIX".to_string(), strip_tail)
-}
-
-fn strip_tail(string: String) -> String {
-    string
-        .split_once('.')
-        .map(|(head, _)| head.to_string())
-        .unwrap_or(string)
-}
-
 impl Module<Button> for ClockModule {
    type SendMessage = DateTime<Local>;
    type ReceiveMessage = ();
@@ -98,33 +60,35 @@ impl Module<Button> for ClockModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<Button>> {
+    ) -> 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| {
            try_send!(
                context.tx,
-                ModuleUpdateEvent::TogglePopup(button.popup_id())
+                ModuleUpdateEvent::TogglePopup(Popup::widget_geometry(button, orientation))
            );
        });

        let format = self.format.clone();
-        let locale = Locale::try_from(self.locale.as_str()).unwrap_or(Locale::POSIX);
+        {
+            context.widget_rx.attach(None, move |date| {
+                let date_string = format!("{}", date.format(&format));
+                label.set_label(&date_string);
+                Continue(true)
+            });
+        }

-        context.widget_rx.attach(None, move |date| {
-            let date_string = format!("{}", date.format_localized(&format, locale));
-            label.set_label(&date_string);
-            Continue(true)
-        });
+        let popup = self.into_popup(context.controller_tx, context.popup_rx, info);

-        let popup = self
-            .into_popup(context.controller_tx, context.popup_rx, info)
-            .into_popup_parts(vec![&button]);
-
-        Ok(ModuleParts::new(button, popup))
+        Ok(ModuleWidget {
+            widget: button,
+            popup,
+        })
    }

    fn into_popup(
@@ -136,22 +100,22 @@ impl Module<Button> for ClockModule {
        let container = gtk::Box::new(Orientation::Vertical, 0);

        let clock = Label::builder().halign(Align::Center).build();
-        clock.add_class("calendar-clock");
+        add_class(&clock, "calendar-clock");
+        let format = "%H:%M:%S";

        container.add(&clock);

        let calendar = Calendar::new();
-        calendar.add_class("calendar");
+        add_class(&calendar, "calendar");
        container.add(&calendar);

-        let format = self.format_popup;
-        let locale = Locale::try_from(self.locale.as_str()).unwrap_or(Locale::POSIX);
-
-        rx.attach(None, move |date| {
-            let date_string = format!("{}", date.format_localized(&format, locale));
-            clock.set_label(&date_string);
-            Continue(true)
-        });
+        {
+            rx.attach(None, move |date| {
+                let date_string = format!("{}", date.format(format));
+                clock.set_label(&date_string);
+                Continue(true)
+            });
+        }

        container.show_all();

--- a/src/modules/custom/box.rs
+++ b/src/modules/custom/box.rs
@@ -27,7 +27,7 @@ impl CustomWidget for BoxWidget {

        if let Some(widgets) = self.widgets {
            for widget in widgets {
-                widget.widget.add_to(&container, &context, widget.common);
+                widget.widget.add_to(&container, context, widget.common);
            }
        }

--- a/src/modules/custom/button.rs
+++ b/src/modules/custom/button.rs
@@ -1,13 +1,11 @@
+use super::{CustomWidget, CustomWidgetContext, ExecEvent};
+use crate::dynamic_value::dynamic_string;
+use crate::popup::Popup;
+use crate::{build, try_send};
 use gtk::prelude::*;
 use gtk::{Button, Label};
 use serde::Deserialize;

-use crate::dynamic_value::dynamic_string;
-use crate::modules::PopupButton;
-use crate::{build, try_send};
-
-use super::{CustomWidget, CustomWidgetContext, ExecEvent};
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct ButtonWidget {
    name: Option<String>,
@@ -21,7 +19,6 @@ impl CustomWidget for ButtonWidget {

    fn into_widget(self, context: CustomWidgetContext) -> Self::Widget {
        let button = build!(self, Self::Widget);
-        context.popup_buttons.borrow_mut().push(button.clone());

        if let Some(text) = self.label {
            let label = Label::new(None);
@@ -35,6 +32,7 @@ impl CustomWidget for ButtonWidget {
        }

        if let Some(exec) = self.on_click {
+            let bar_orientation = context.bar_orientation;
            let tx = context.tx.clone();

            button.connect_clicked(move |button| {
@@ -43,7 +41,7 @@ impl CustomWidget for ButtonWidget {
                    ExecEvent {
                        cmd: exec.clone(),
                        args: None,
-                        id: button.try_popup_id().unwrap_or(usize::MAX), // may not be a popup button
+                        geometry: Popup::widget_geometry(button, bar_orientation),
                    }
                );
            });
--- a/src/modules/custom/image.rs
+++ b/src/modules/custom/image.rs
@@ -1,12 +1,10 @@
-use gtk::prelude::*;
-use gtk::Image;
-use serde::Deserialize;
-
+use super::{CustomWidget, CustomWidgetContext};
 use crate::build;
 use crate::dynamic_value::dynamic_string;
 use crate::image::ImageProvider;
-
-use super::{CustomWidget, CustomWidgetContext};
+use gtk::prelude::*;
+use gtk::Image;
+use serde::Deserialize;

 #[derive(Debug, Deserialize, Clone)]
 pub struct ImageWidget {
@@ -32,7 +30,7 @@ impl CustomWidget for ImageWidget {
            let icon_theme = context.icon_theme.clone();

            dynamic_string(&self.src, move |src| {
-                ImageProvider::parse(&src, &icon_theme, false, self.size)
+                ImageProvider::parse(&src, &icon_theme, self.size)
                    .map(|image| image.load_into_image(gtk_image.clone()));

                Continue(true)
--- a/src/modules/custom/label.rs
+++ b/src/modules/custom/label.rs
@@ -1,12 +1,10 @@
+use super::{CustomWidget, CustomWidgetContext};
+use crate::build;
+use crate::dynamic_value::dynamic_string;
 use gtk::prelude::*;
 use gtk::Label;
 use serde::Deserialize;

-use crate::build;
-use crate::dynamic_value::dynamic_string;
-
-use super::{CustomWidget, CustomWidgetContext};
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct LabelWidget {
    name: Option<String>,
--- a/src/modules/custom/mod.rs
+++ b/src/modules/custom/mod.rs
@@ -13,16 +13,15 @@ use crate::config::CommonConfig;
 use crate::modules::custom::button::ButtonWidget;
 use crate::modules::custom::progress::ProgressWidget;
 use crate::modules::{
-    wrap_widget, Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, WidgetContext,
+    wrap_widget, Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext,
 };
+use crate::popup::WidgetGeometry;
 use crate::script::Script;
 use crate::send_async;
 use color_eyre::{Report, Result};
 use gtk::prelude::*;
-use gtk::{Button, IconTheme, Orientation};
+use gtk::{IconTheme, Orientation};
 use serde::Deserialize;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tokio::spawn;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::{debug, error};
@@ -57,12 +56,11 @@ pub enum Widget {
    Progress(ProgressWidget),
 }

-#[derive(Clone)]
+#[derive(Clone, Copy)]
 struct CustomWidgetContext<'a> {
    tx: &'a Sender<ExecEvent>,
    bar_orientation: Orientation,
    icon_theme: &'a IconTheme,
-    popup_buttons: Rc<RefCell<Vec<Button>>>,
 }

 trait CustomWidget {
@@ -117,11 +115,11 @@ fn try_get_orientation(orientation: &str) -> Result<Orientation> {

 impl Widget {
    /// Creates this widget and adds it to the parent container
-    fn add_to(self, parent: &gtk::Box, context: &CustomWidgetContext, common: CommonConfig) {
+    fn add_to(self, parent: &gtk::Box, context: CustomWidgetContext, common: CommonConfig) {
        macro_rules! create {
            ($widget:expr) => {
                wrap_widget(
-                    &$widget.into_widget(context.clone()),
+                    &$widget.into_widget(context),
                    common,
                    context.bar_orientation,
                )
@@ -145,7 +143,7 @@ impl Widget {
 pub struct ExecEvent {
    cmd: String,
    args: Option<Vec<String>>,
-    id: usize,
+    geometry: WidgetGeometry,
 }

 impl Module<gtk::Box> for CustomModule {
@@ -175,9 +173,9 @@ impl Module<gtk::Box> for CustomModule {
                        error!("{err:?}");
                    }
                } else if event.cmd == "popup:toggle" {
-                    send_async!(tx, ModuleUpdateEvent::TogglePopup(event.id));
+                    send_async!(tx, ModuleUpdateEvent::TogglePopup(event.geometry));
                } else if event.cmd == "popup:open" {
-                    send_async!(tx, ModuleUpdateEvent::OpenPopup(event.id));
+                    send_async!(tx, ModuleUpdateEvent::OpenPopup(event.geometry));
                } else if event.cmd == "popup:close" {
                    send_async!(tx, ModuleUpdateEvent::ClosePopup);
                } else {
@@ -193,30 +191,25 @@ impl Module<gtk::Box> for CustomModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<gtk::Box>> {
+    ) -> Result<ModuleWidget<gtk::Box>> {
        let orientation = info.bar_position.get_orientation();
        let container = gtk::Box::builder().orientation(orientation).build();

-        let popup_buttons = Rc::new(RefCell::new(Vec::new()));
-
        let custom_context = CustomWidgetContext {
            tx: &context.controller_tx,
            bar_orientation: orientation,
            icon_theme: info.icon_theme,
-            popup_buttons: popup_buttons.clone(),
        };

        self.bar.clone().into_iter().for_each(|widget| {
            widget
                .widget
-                .add_to(&container, &custom_context, widget.common);
+                .add_to(&container, custom_context, widget.common);
        });

-        let popup = self
-            .into_popup(context.controller_tx, context.popup_rx, info)
-            .into_popup_parts_owned(popup_buttons.take());
+        let popup = self.into_popup(context.controller_tx, context.popup_rx, info);

-        Ok(ModuleParts {
+        Ok(ModuleWidget {
            widget: container,
            popup,
        })
@@ -238,13 +231,12 @@ impl Module<gtk::Box> for CustomModule {
                tx: &tx,
                bar_orientation: info.bar_position.get_orientation(),
                icon_theme: info.icon_theme,
-                popup_buttons: Rc::new(RefCell::new(vec![])),
            };

            for widget in popup {
                widget
                    .widget
-                    .add_to(&container, &custom_context, widget.common);
+                    .add_to(&container, custom_context, widget.common);
            }
        }

--- a/src/modules/custom/progress.rs
+++ b/src/modules/custom/progress.rs
@@ -1,16 +1,14 @@
+use super::{try_get_orientation, CustomWidget, CustomWidgetContext};
+use crate::dynamic_value::dynamic_string;
+use crate::modules::custom::set_length;
+use crate::script::{OutputStream, Script, ScriptInput};
+use crate::{build, send};
 use gtk::prelude::*;
 use gtk::ProgressBar;
 use serde::Deserialize;
 use tokio::spawn;
 use tracing::error;

-use crate::dynamic_value::dynamic_string;
-use crate::modules::custom::set_length;
-use crate::script::{OutputStream, Script, ScriptInput};
-use crate::{build, send};
-
-use super::{try_get_orientation, CustomWidget, CustomWidgetContext};
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct ProgressWidget {
    name: Option<String>,
--- a/src/modules/custom/slider.rs
+++ b/src/modules/custom/slider.rs
@@ -1,18 +1,16 @@
-use std::cell::Cell;
-use std::ops::Neg;
-
+use super::{try_get_orientation, CustomWidget, CustomWidgetContext, ExecEvent};
+use crate::modules::custom::set_length;
+use crate::popup::Popup;
+use crate::script::{OutputStream, Script, ScriptInput};
+use crate::{build, send, try_send};
 use gtk::prelude::*;
 use gtk::Scale;
 use serde::Deserialize;
+use std::cell::Cell;
+use std::ops::Neg;
 use tokio::spawn;
 use tracing::error;

-use crate::modules::custom::set_length;
-use crate::script::{OutputStream, Script, ScriptInput};
-use crate::{build, send, try_send};
-
-use super::{try_get_orientation, CustomWidget, CustomWidgetContext, ExecEvent};
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct SliderWidget {
    name: Option<String>,
@@ -80,7 +78,7 @@ impl CustomWidget for SliderWidget {
                Inhibit(false)
            });

-            scale.connect_change_value(move |_, _, val| {
+            scale.connect_change_value(move |scale, _, val| {
                // GTK will send values outside min/max range
                let val = val.clamp(min, max);

@@ -90,7 +88,7 @@ impl CustomWidget for SliderWidget {
                        ExecEvent {
                            cmd: on_change.clone(),
                            args: Some(vec![val.to_string()]),
-                            id: usize::MAX // ignored
+                            geometry: Popup::widget_geometry(scale, context.bar_orientation),
                        }
                    );

--- a/src/modules/focused.rs
+++ b/src/modules/focused.rs
@@ -1,8 +1,8 @@
 use crate::clients::wayland::{self, ToplevelEvent};
 use crate::config::{CommonConfig, TruncateMode};
-use crate::gtk_helpers::IronbarGtkExt;
+use crate::gtk_helpers::add_class;
 use crate::image::ImageProvider;
-use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::{lock, send_async, try_send};
 use color_eyre::Result;
 use glib::Continue;
@@ -32,18 +32,6 @@ pub struct FocusedModule {
    pub common: Option<CommonConfig>,
 }

-impl Default for FocusedModule {
-    fn default() -> Self {
-        Self {
-            show_icon: crate::config::default_true(),
-            show_title: crate::config::default_true(),
-            icon_size: default_icon_size(),
-            truncate: None,
-            common: Some(CommonConfig::default()),
-        }
-    }
-}
-
 const fn default_icon_size() -> i32 {
    32
 }
@@ -104,19 +92,19 @@ impl Module<gtk::Box> for FocusedModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<gtk::Box>> {
+    ) -> Result<ModuleWidget<gtk::Box>> {
        let icon_theme = info.icon_theme;

        let container = gtk::Box::new(info.bar_position.get_orientation(), 5);

        let icon = gtk::Image::new();
        if self.show_icon {
-            icon.add_class("icon");
+            add_class(&icon, "icon");
            container.add(&icon);
        }

        let label = Label::new(None);
-        label.add_class("label");
+        add_class(&label, "label");

        if let Some(truncate) = self.truncate {
            truncate.truncate_label(&label);
@@ -128,7 +116,7 @@ impl Module<gtk::Box> for FocusedModule {
            let icon_theme = icon_theme.clone();
            context.widget_rx.attach(None, move |(name, id)| {
                if self.show_icon {
-                    match ImageProvider::parse(&id, &icon_theme, true, self.icon_size)
+                    match ImageProvider::parse(&id, &icon_theme, self.icon_size)
                        .map(|image| image.load_into_image(icon.clone()))
                    {
                        Some(Ok(_)) => icon.show(),
@@ -144,7 +132,7 @@ impl Module<gtk::Box> for FocusedModule {
            });
        }

-        Ok(ModuleParts {
+        Ok(ModuleWidget {
            widget: container,
            popup: None,
        })
--- a/src/modules/label.rs
+++ b/src/modules/label.rs
@@ -1,6 +1,6 @@
 use crate::config::CommonConfig;
 use crate::dynamic_value::dynamic_string;
-use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::try_send;
 use color_eyre::Result;
 use glib::Continue;
@@ -17,15 +17,6 @@ pub struct LabelModule {
    pub common: Option<CommonConfig>,
 }

-impl LabelModule {
-    pub(crate) fn new(label: String) -> Self {
-        Self {
-            label,
-            common: Some(CommonConfig::default()),
-        }
-    }
-}
-
 impl Module<Label> for LabelModule {
    type SendMessage = String;
    type ReceiveMessage = ();
@@ -52,19 +43,18 @@ impl Module<Label> for LabelModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        _info: &ModuleInfo,
-    ) -> Result<ModuleParts<Label>> {
+    ) -> Result<ModuleWidget<Label>> {
        let label = Label::new(None);
-        label.set_use_markup(true);

        {
            let label = label.clone();
            context.widget_rx.attach(None, move |string| {
-                label.set_markup(&string);
+                label.set_label(&string);
                Continue(true)
            });
        }

-        Ok(ModuleParts {
+        Ok(ModuleWidget {
            widget: label,
            popup: None,
        })
--- a/src/modules/launcher/item.rs
+++ b/src/modules/launcher/item.rs
@@ -1,14 +1,13 @@
 use super::open_state::OpenState;
 use crate::clients::wayland::ToplevelHandle;
-use crate::config::BarPosition;
-use crate::gtk_helpers::IronbarGtkExt;
 use crate::image::ImageProvider;
 use crate::modules::launcher::{ItemEvent, LauncherUpdate};
 use crate::modules::ModuleUpdateEvent;
+use crate::popup::Popup;
 use crate::{read_lock, try_send};
 use color_eyre::{Report, Result};
 use gtk::prelude::*;
-use gtk::{Button, IconTheme};
+use gtk::{Button, IconTheme, Orientation};
 use indexmap::IndexMap;
 use std::rc::Rc;
 use std::sync::RwLock;
@@ -177,7 +176,7 @@ impl ItemButton {
        item: &Item,
        appearance: AppearanceOptions,
        icon_theme: &IconTheme,
-        bar_position: BarPosition,
+        orientation: Orientation,
        tx: &Sender<ModuleUpdateEvent<LauncherUpdate>>,
        controller_tx: &Sender<ItemEvent>,
    ) -> Self {
@@ -192,7 +191,7 @@ impl ItemButton {
        if appearance.show_icons {
            let gtk_image = gtk::Image::new();
            let image =
-                ImageProvider::parse(&item.app_id.clone(), icon_theme, true, appearance.icon_size);
+                ImageProvider::parse(&item.app_id.clone(), icon_theme, appearance.icon_size);
            if let Some(image) = image {
                button.set_image(Some(&gtk_image));
                button.set_always_show_image(true);
@@ -250,9 +249,7 @@ impl ItemButton {

                    try_send!(
                        tx,
-                        ModuleUpdateEvent::OpenPopupAt(
-                            button.geometry(bar_position.get_orientation())
-                        )
+                        ModuleUpdateEvent::OpenPopup(Popup::widget_geometry(button, orientation))
                    );
                } else {
                    try_send!(tx, ModuleUpdateEvent::ClosePopup);
@@ -262,31 +259,6 @@ impl ItemButton {
            });
        }

-        {
-            let tx = tx.clone();
-
-            button.connect_leave_notify_event(move |button, ev| {
-                const THRESHOLD: f64 = 5.0;
-
-                let alloc = button.allocation();
-
-                let (x, y) = ev.position();
-
-                let close = match bar_position {
-                    BarPosition::Top => y + THRESHOLD < alloc.height() as f64,
-                    BarPosition::Bottom => y > THRESHOLD,
-                    BarPosition::Left => x + THRESHOLD < alloc.width() as f64,
-                    BarPosition::Right => x > THRESHOLD,
-                };
-
-                if close {
-                    try_send!(tx, ModuleUpdateEvent::ClosePopup);
-                }
-
-                Inhibit(false)
-            });
-        }
-
        button.show_all();

        Self {
--- a/src/modules/launcher/mod.rs
+++ b/src/modules/launcher/mod.rs
@@ -7,10 +7,8 @@ use crate::clients::wayland::{self, ToplevelEvent};
 use crate::config::CommonConfig;
 use crate::desktop_file::find_desktop_file;
 use crate::modules::launcher::item::AppearanceOptions;
-use crate::modules::{
-    Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, WidgetContext,
-};
-use crate::{arc_mut, lock, send_async, try_send, write_lock};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::{lock, send_async, try_send, write_lock};
 use color_eyre::{Help, Report};
 use glib::Continue;
 use gtk::prelude::*;
@@ -18,7 +16,7 @@ use gtk::{Button, Orientation};
 use indexmap::IndexMap;
 use serde::Deserialize;
 use std::process::{Command, Stdio};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use tokio::spawn;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::{debug, error, trace};
@@ -110,7 +108,7 @@ impl Module<gtk::Box> for LauncherModule {
                    .collect::<IndexMap<_, _>>()
            });

-        let items = arc_mut!(items);
+        let items = Arc::new(Mutex::new(items));

        let items2 = Arc::clone(&items);
        let tx2 = tx.clone();
@@ -165,7 +163,6 @@ impl Module<gtk::Box> for LauncherModule {
                            match item {
                                None => {
                                    let item: Item = handle.try_into()?;
-
                                    items.insert(info.app_id.clone(), item.clone());

                                    ItemOrWindow::Item(item)
@@ -316,7 +313,7 @@ impl Module<gtk::Box> for LauncherModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> crate::Result<ModuleParts<gtk::Box>> {
+    ) -> crate::Result<ModuleWidget<gtk::Box>> {
        let icon_theme = info.icon_theme;

        let container = gtk::Box::new(info.bar_position.get_orientation(), 0);
@@ -334,7 +331,7 @@ impl Module<gtk::Box> for LauncherModule {
            };

            let show_names = self.show_names;
-            let bar_position = info.bar_position;
+            let orientation = info.bar_position.get_orientation();

            let mut buttons = IndexMap::<String, ItemButton>::new();

@@ -350,7 +347,7 @@ impl Module<gtk::Box> for LauncherModule {
                                &item,
                                appearance_options,
                                &icon_theme,
-                                bar_position,
+                                orientation,
                                &context.tx,
                                &controller_tx,
                            );
@@ -359,10 +356,9 @@ impl Module<gtk::Box> for LauncherModule {
                            buttons.insert(item.app_id, button);
                        }
                    }
-                    LauncherUpdate::AddWindow(app_id, win) => {
+                    LauncherUpdate::AddWindow(app_id, _) => {
                        if let Some(button) = buttons.get(&app_id) {
                            button.set_open(true);
-                            button.set_focused(win.open_state.is_focused());

                            let mut menu_state = write_lock!(button.menu_state);
                            menu_state.num_windows += 1;
@@ -383,12 +379,8 @@ impl Module<gtk::Box> for LauncherModule {
                            }
                        }
                    }
-                    LauncherUpdate::RemoveWindow(app_id, win_id) => {
-                        debug!("Removing window {win_id} with id {app_id}");
-
+                    LauncherUpdate::RemoveWindow(app_id, _) => {
                        if let Some(button) = buttons.get(&app_id) {
-                            button.set_focused(false);
-
                            let mut menu_state = write_lock!(button.menu_state);
                            menu_state.num_windows -= 1;
                        }
@@ -416,11 +408,8 @@ impl Module<gtk::Box> for LauncherModule {
            });
        }

-        let popup = self
-            .into_popup(context.controller_tx, context.popup_rx, info)
-            .into_popup_parts(vec![]); // since item buttons are dynamic, they pass their geometry directly
-
-        Ok(ModuleParts {
+        let popup = self.into_popup(context.controller_tx, context.popup_rx, info);
+        Ok(ModuleWidget {
            widget: container,
            popup,
        })
--- a/src/modules/mod.rs
+++ b/src/modules/mod.rs
@@ -1,19 +1,3 @@
-use std::sync::{Arc, RwLock};
-
-use color_eyre::Result;
-use glib::IsA;
-use gtk::gdk::{EventMask, Monitor};
-use gtk::prelude::*;
-use gtk::{Application, Button, EventBox, IconTheme, Orientation, Revealer, Widget};
-use tokio::sync::mpsc;
-use tracing::debug;
-
-use crate::bridge_channel::BridgeChannel;
-use crate::config::{BarPosition, CommonConfig, TransitionType};
-use crate::gtk_helpers::{IronbarGtkExt, WidgetGeometry};
-use crate::popup::Popup;
-use crate::{send, write_lock};
-
 #[cfg(feature = "clipboard")]
 pub mod clipboard;
 /// Displays the current date and time.
@@ -40,6 +24,19 @@ pub mod upower;
 #[cfg(feature = "workspaces")]
 pub mod workspaces;

+use crate::bridge_channel::BridgeChannel;
+use crate::config::{BarPosition, CommonConfig, TransitionType};
+use crate::popup::{Popup, WidgetGeometry};
+use crate::{read_lock, send, write_lock};
+use color_eyre::Result;
+use glib::IsA;
+use gtk::gdk::{EventMask, Monitor};
+use gtk::prelude::*;
+use gtk::{Application, EventBox, IconTheme, Orientation, Revealer, Widget};
+use std::sync::{Arc, RwLock};
+use tokio::sync::mpsc;
+use tracing::debug;
+
 #[derive(Clone)]
 pub enum ModuleLocation {
    Left,
@@ -57,15 +54,13 @@ pub struct ModuleInfo<'a> {

 #[derive(Debug)]
 pub enum ModuleUpdateEvent<T> {
-    /// Sends an update to the module UI.
+    /// Sends an update to the module UI
    Update(T),
    /// Toggles the open state of the popup.
-    /// Takes the button ID.
-    TogglePopup(usize),
+    TogglePopup(WidgetGeometry),
    /// Force sets the popup open.
-    /// Takes the button ID.
-    OpenPopup(usize),
-    OpenPopupAt(WidgetGeometry),
+    /// Takes the button X position and width.
+    OpenPopup(WidgetGeometry),
    /// Force sets the popup closed.
    ClosePopup,
 }
@@ -78,62 +73,9 @@ pub struct WidgetContext<TSend, TReceive> {
    pub popup_rx: glib::Receiver<TSend>,
 }

-pub struct ModuleParts<W: IsA<Widget>> {
+pub struct ModuleWidget<W: IsA<Widget>> {
    pub widget: W,
-    pub popup: Option<ModulePopupParts>,
-}
-
-impl<W: IsA<Widget>> ModuleParts<W> {
-    fn new(widget: W, popup: Option<ModulePopupParts>) -> Self {
-        Self { widget, popup }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct ModulePopupParts {
-    /// The popup container, with all its contents
-    pub container: gtk::Box,
-    /// An array of buttons which can be used for opening the popup.
-    /// For most modules, this will only be a single button.
-    /// For some advanced modules, such as `Launcher`, this is all item buttons.
-    pub buttons: Vec<Button>,
-}
-
-pub trait ModulePopup {
-    fn into_popup_parts(self, buttons: Vec<&Button>) -> Option<ModulePopupParts>;
-    fn into_popup_parts_owned(self, buttons: Vec<Button>) -> Option<ModulePopupParts>;
-}
-
-impl ModulePopup for Option<gtk::Box> {
-    fn into_popup_parts(self, buttons: Vec<&Button>) -> Option<ModulePopupParts> {
-        self.into_popup_parts_owned(buttons.into_iter().cloned().collect())
-    }
-
-    fn into_popup_parts_owned(self, buttons: Vec<Button>) -> Option<ModulePopupParts> {
-        self.map(|container| ModulePopupParts { container, buttons })
-    }
-}
-
-pub trait PopupButton {
-    fn try_popup_id(&self) -> Option<usize>;
-    fn popup_id(&self) -> usize;
-}
-
-impl PopupButton for Button {
-    /// Gets the popup ID associated with this button, if there is one.
-    /// Will return `None` if this is not a popup button.
-    fn try_popup_id(&self) -> Option<usize> {
-        self.get_tag("popup-id").copied()
-    }
-
-    /// Gets the popup ID associated with this button.
-    /// This should only be called on buttons which are known to be associated with popups.
-    ///
-    /// # Panics
-    /// Will panic if an ID has not been set.
-    fn popup_id(&self) -> usize {
-        self.try_popup_id().expect("id to exist")
-    }
+    pub popup: Option<gtk::Box>,
 }

 pub trait Module<W>
@@ -156,7 +98,7 @@ where
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<W>>;
+    ) -> Result<ModuleWidget<W>>;

    fn into_popup(
        self,
@@ -176,10 +118,9 @@ where
 pub fn create_module<TModule, TWidget, TSend, TRec>(
    module: TModule,
    id: usize,
-    name: Option<String>,
    info: &ModuleInfo,
    popup: &Arc<RwLock<Popup>>,
-) -> Result<ModuleParts<TWidget>>
+) -> Result<ModuleWidget<TWidget>>
 where
    TModule: Module<TWidget, SendMessage = TSend, ReceiveMessage = TRec>,
    TWidget: IsA<Widget>,
@@ -201,45 +142,29 @@ where
        controller_tx: ui_tx,
    };

-    let module_name = TModule::name();
-    let instance_name = name.unwrap_or_else(|| module_name.to_string());
+    let name = TModule::name();

    let module_parts = module.into_widget(context, info)?;
-    module_parts.widget.style_context().add_class(module_name);
+    module_parts.widget.style_context().add_class(name);

-    let has_popup = if let Some(popup_content) = module_parts.popup.clone() {
+    let mut has_popup = false;
+    if let Some(popup_content) = module_parts.popup.clone() {
        popup_content
-            .container
            .style_context()
-            .add_class(&format!("popup-{module_name}"));
+            .add_class(&format!("popup-{name}"));

-        register_popup_content(popup, id, instance_name, popup_content);
-        true
-    } else {
-        false
-    };
+        register_popup_content(popup, id, popup_content);
+        has_popup = true;
+    }

-    setup_receiver(
-        channel,
-        w_tx,
-        p_tx,
-        popup.clone(),
-        module_name,
-        id,
-        has_popup,
-    );
+    setup_receiver(channel, w_tx, p_tx, popup.clone(), name, id, has_popup);

    Ok(module_parts)
 }

 /// Registers the popup content with the popup.
-fn register_popup_content(
-    popup: &Arc<RwLock<Popup>>,
-    id: usize,
-    name: String,
-    popup_content: ModulePopupParts,
-) {
-    write_lock!(popup).register_content(id, name, popup_content);
+fn register_popup_content(popup: &Arc<RwLock<Popup>>, id: usize, popup_content: gtk::Box) {
+    write_lock!(popup).register_content(id, popup_content);
 }

 /// Sets up the bridge channel receiver
@@ -271,51 +196,40 @@ fn setup_receiver<TSend>(

                send!(w_tx, update);
            }
-            ModuleUpdateEvent::TogglePopup(button_id) => {
+            ModuleUpdateEvent::TogglePopup(geometry) => {
                debug!("Toggling popup for {} [#{}]", name, id);
-                let mut popup = write_lock!(popup);
+                let popup = read_lock!(popup);
                if popup.is_visible() {
                    popup.hide();
                } else {
-                    popup.show(id, button_id);
+                    popup.show_content(id);
+                    popup.show(geometry);

-                    // force re-render on initial open to try and fix size issue
                    if !has_popup_opened {
-                        popup.show(id, button_id);
+                        popup.show_content(id);
+                        popup.show(geometry);
                        has_popup_opened = true;
                    }
                }
            }
-            ModuleUpdateEvent::OpenPopup(button_id) => {
+            ModuleUpdateEvent::OpenPopup(geometry) => {
                debug!("Opening popup for {} [#{}]", name, id);

-                let mut popup = write_lock!(popup);
+                let popup = read_lock!(popup);
                popup.hide();
-                popup.show(id, button_id);
+                popup.show_content(id);
+                popup.show(geometry);

-                // force re-render on initial open to try and fix size issue
                if !has_popup_opened {
-                    popup.show(id, button_id);
-                    has_popup_opened = true;
-                }
-            }
-            ModuleUpdateEvent::OpenPopupAt(geometry) => {
-                debug!("Opening popup for {} [#{}]", name, id);
-
-                let mut popup = write_lock!(popup);
-                popup.hide();
-                popup.show_at(id, geometry);
-
-                // force re-render on initial open to try and fix size issue
-                if !has_popup_opened {
-                    popup.show_at(id, geometry);
+                    popup.show_content(id);
+                    popup.show(geometry);
                    has_popup_opened = true;
                }
            }
            ModuleUpdateEvent::ClosePopup => {
                debug!("Closing popup for {} [#{}]", name, id);

-                let mut popup = write_lock!(popup);
+                let popup = read_lock!(popup);
                popup.hide();
            }
        }
@@ -325,14 +239,14 @@ fn setup_receiver<TSend>(
 }

 pub fn set_widget_identifiers<TWidget: IsA<Widget>>(
-    widget_parts: &ModuleParts<TWidget>,
+    widget_parts: &ModuleWidget<TWidget>,
    common: &CommonConfig,
 ) {
    if let Some(ref name) = common.name {
        widget_parts.widget.set_widget_name(name);

        if let Some(ref popup) = widget_parts.popup {
-            popup.container.set_widget_name(&format!("popup-{name}"));
+            popup.set_widget_name(&format!("popup-{name}"));
        }
    }

@@ -344,10 +258,7 @@ pub fn set_widget_identifiers<TWidget: IsA<Widget>>(

        if let Some(ref popup) = widget_parts.popup {
            for part in class.split(' ') {
-                popup
-                    .container
-                    .style_context()
-                    .add_class(&format!("popup-{part}"));
+                popup.style_context().add_class(&format!("popup-{part}"));
            }
        }
    }
--- a/src/modules/music/mod.rs
+++ b/src/modules/music/mod.rs
@@ -1,33 +1,26 @@
-use std::path::PathBuf;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use std::time::Duration;
+mod config;

+use crate::clients::music::{self, MusicClient, PlayerState, PlayerUpdate, Status, Track};
+use crate::gtk_helpers::add_class;
+use crate::image::{new_icon_button, new_icon_label, ImageProvider};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::popup::Popup;
+use crate::{send_async, try_send};
 use color_eyre::Result;
-use glib::{Continue, PropertySet};
+use glib::Continue;
 use gtk::prelude::*;
 use gtk::{Button, IconTheme, Label, Orientation, Scale};
 use regex::Regex;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
 use tokio::spawn;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::error;

-use crate::clients::music::{
-    self, MusicClient, PlayerState, PlayerUpdate, ProgressTick, Status, Track,
-};
-use crate::gtk_helpers::IronbarGtkExt;
-use crate::image::{new_icon_button, new_icon_label, ImageProvider};
-use crate::modules::PopupButton;
-use crate::modules::{
-    Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, WidgetContext,
-};
-use crate::{send_async, try_send};
-
 pub use self::config::MusicModule;
 use self::config::PlayerType;

-mod config;
-
 #[derive(Debug)]
 pub enum PlayerCommand {
    Previous,
@@ -35,7 +28,6 @@ pub enum PlayerCommand {
    Pause,
    Next,
    Volume(u8),
-    Seek(Duration),
 }

 /// Formats a duration given in seconds
@@ -55,12 +47,6 @@ fn get_tokens(re: &Regex, format_string: &str) -> Vec<String> {
        .collect::<Vec<_>>()
 }

-#[derive(Clone, Debug)]
-pub enum ControllerEvent {
-    Update(Option<SongUpdate>),
-    UpdateProgress(ProgressTick),
-}
-
 #[derive(Clone, Debug)]
 pub struct SongUpdate {
    song: Track,
@@ -81,7 +67,7 @@ async fn get_client(
 }

 impl Module<Button> for MusicModule {
-    type SendMessage = ControllerEvent;
+    type SendMessage = Option<SongUpdate>;
    type ReceiveMessage = PlayerCommand;

    fn name() -> &'static str {
@@ -117,7 +103,7 @@ impl Module<Button> for MusicModule {
                            PlayerUpdate::Update(track, status) => match *track {
                                Some(track) => {
                                    let display_string =
-                                        replace_tokens(format.as_str(), &tokens, &track);
+                                        replace_tokens(format.as_str(), &tokens, &track, &status);

                                    let update = SongUpdate {
                                        song: track,
@@ -125,24 +111,10 @@ impl Module<Button> for MusicModule {
                                        display_string,
                                    };

-                                    send_async!(
-                                        tx,
-                                        ModuleUpdateEvent::Update(ControllerEvent::Update(Some(
-                                            update
-                                        )))
-                                    );
+                                    send_async!(tx, ModuleUpdateEvent::Update(Some(update)));
                                }
-                                None => send_async!(
-                                    tx,
-                                    ModuleUpdateEvent::Update(ControllerEvent::Update(None))
-                                ),
+                                None => send_async!(tx, ModuleUpdateEvent::Update(None)),
                            },
-                            PlayerUpdate::ProgressTick(progress_tick) => send_async!(
-                                tx,
-                                ModuleUpdateEvent::Update(ControllerEvent::UpdateProgress(
-                                    progress_tick
-                                ))
-                            ),
                            PlayerUpdate::Disconnect => break,
                        }
                    }
@@ -165,7 +137,6 @@ impl Module<Button> for MusicModule {
                        PlayerCommand::Pause => client.pause(),
                        PlayerCommand::Next => client.next(),
                        PlayerCommand::Volume(vol) => client.set_volume_percent(vol),
-                        PlayerCommand::Seek(duration) => client.seek(duration),
                    };

                    if let Err(err) = res {
@@ -182,10 +153,10 @@ impl Module<Button> for MusicModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<Button>> {
+    ) -> Result<ModuleWidget<Button>> {
        let button = Button::new();
        let button_contents = gtk::Box::new(Orientation::Horizontal, 5);
-        button_contents.add_class("contents");
+        add_class(&button_contents, "contents");

        button.add(&button_contents);

@@ -203,11 +174,16 @@ impl Module<Button> for MusicModule {
        button_contents.add(&icon_play);
        button_contents.add(&label);

+        let orientation = info.bar_position.get_orientation();
+
        {
            let tx = context.tx.clone();

            button.connect_clicked(move |button| {
-                try_send!(tx, ModuleUpdateEvent::TogglePopup(button.popup_id()));
+                try_send!(
+                    tx,
+                    ModuleUpdateEvent::TogglePopup(Popup::widget_geometry(button, orientation,))
+                );
            });
        }

@@ -215,9 +191,7 @@ impl Module<Button> for MusicModule {
            let button = button.clone();
            let tx = context.tx.clone();

-            context.widget_rx.attach(None, move |event| {
-                let ControllerEvent::Update(mut event) = event else { return Continue(true) };
-
+            context.widget_rx.attach(None, move |mut event| {
                if let Some(event) = event.take() {
                    label.set_label(&event.display_string);

@@ -251,11 +225,12 @@ impl Module<Button> for MusicModule {
            });
        };

-        let popup = self
-            .into_popup(context.controller_tx, context.popup_rx, info)
-            .into_popup_parts(vec![&button]);
+        let popup = self.into_popup(context.controller_tx, context.popup_rx, info);

-        Ok(ModuleParts::new(button, popup))
+        Ok(ModuleWidget {
+            widget: button,
+            popup,
+        })
    }

    fn into_popup(
@@ -266,14 +241,13 @@ impl Module<Button> for MusicModule {
    ) -> Option<gtk::Box> {
        let icon_theme = info.icon_theme;

-        let container = gtk::Box::new(Orientation::Vertical, 10);
-        let main_container = gtk::Box::new(Orientation::Horizontal, 10);
+        let container = gtk::Box::new(Orientation::Horizontal, 10);

        let album_image = gtk::Image::builder()
            .width_request(128)
            .height_request(128)
            .build();
-        album_image.add_class("album-art");
+        add_class(&album_image, "album-art");

        let icons = self.icons;

@@ -282,28 +256,28 @@ impl Module<Button> for MusicModule {
        let album_label = IconLabel::new(&icons.album, None, icon_theme);
        let artist_label = IconLabel::new(&icons.artist, None, icon_theme);

-        title_label.container.add_class("title");
-        album_label.container.add_class("album");
-        artist_label.container.add_class("artist");
+        add_class(&title_label.container, "title");
+        add_class(&album_label.container, "album");
+        add_class(&artist_label.container, "artist");

        info_box.add(&title_label.container);
        info_box.add(&album_label.container);
        info_box.add(&artist_label.container);

        let controls_box = gtk::Box::new(Orientation::Horizontal, 0);
-        controls_box.add_class("controls");
+        add_class(&controls_box, "controls");

        let btn_prev = new_icon_button(&icons.prev, icon_theme, self.icon_size);
-        btn_prev.add_class("btn-prev");
+        add_class(&btn_prev, "btn-prev");

        let btn_play = new_icon_button(&icons.play, icon_theme, self.icon_size);
-        btn_play.add_class("btn-play");
+        add_class(&btn_play, "btn-play");

        let btn_pause = new_icon_button(&icons.pause, icon_theme, self.icon_size);
-        btn_pause.add_class("btn-pause");
+        add_class(&btn_pause, "btn-pause");

        let btn_next = new_icon_button(&icons.next, icon_theme, self.icon_size);
-        btn_next.add_class("btn-next");
+        add_class(&btn_next, "btn-next");

        controls_box.add(&btn_prev);
        controls_box.add(&btn_play);
@@ -313,22 +287,21 @@ impl Module<Button> for MusicModule {
        info_box.add(&controls_box);

        let volume_box = gtk::Box::new(Orientation::Vertical, 5);
-        volume_box.add_class("volume");
+        add_class(&volume_box, "volume");

        let volume_slider = Scale::with_range(Orientation::Vertical, 0.0, 100.0, 5.0);
        volume_slider.set_inverted(true);
-        volume_slider.add_class("slider");
+        add_class(&volume_slider, "slider");

        let volume_icon = new_icon_label(&icons.volume, icon_theme, self.icon_size);
-        volume_icon.add_class("icon");
+        add_class(&volume_icon, "icon");

        volume_box.pack_start(&volume_slider, true, true, 0);
        volume_box.pack_end(&volume_icon, false, false, 0);

-        main_container.add(&album_image);
-        main_container.add(&info_box);
-        main_container.add(&volume_box);
-        container.add(&main_container);
+        container.add(&album_image);
+        container.add(&info_box);
+        container.add(&volume_box);

        let tx_prev = tx.clone();
        btn_prev.connect_clicked(move |_| {
@@ -350,49 +323,12 @@ impl Module<Button> for MusicModule {
            try_send!(tx_next, PlayerCommand::Next);
        });

-        let tx_vol = tx.clone();
+        let tx_vol = tx;
        volume_slider.connect_change_value(move |_, _, val| {
            try_send!(tx_vol, PlayerCommand::Volume(val as u8));
            Inhibit(false)
        });

-        let progress_box = gtk::Box::new(Orientation::Horizontal, 5);
-        progress_box.add_class("progress");
-
-        let progress_label = Label::new(None);
-        progress_label.add_class("label");
-
-        let progress = Scale::builder()
-            .orientation(Orientation::Horizontal)
-            .draw_value(false)
-            .hexpand(true)
-            .build();
-        progress.add_class("slider");
-
-        progress_box.add(&progress);
-        progress_box.add(&progress_label);
-        container.add(&progress_box);
-
-        let drag_lock = Arc::new(AtomicBool::new(false));
-        {
-            let drag_lock = drag_lock.clone();
-            progress.connect_button_press_event(move |_, _| {
-                drag_lock.set(true);
-                Inhibit(false)
-            });
-        }
-
-        {
-            let drag_lock = drag_lock.clone();
-            progress.connect_button_release_event(move |scale, _| {
-                let value = scale.value();
-                try_send!(tx, PlayerCommand::Seek(Duration::from_secs_f64(value)));
-
-                drag_lock.set(false);
-                Inhibit(false)
-            });
-        }
-
        container.show_all();

        {
@@ -400,91 +336,68 @@ impl Module<Button> for MusicModule {
            let image_size = self.cover_image_size;

            let mut prev_cover = None;
-            rx.attach(None, move |event| {
-                match event {
-                    ControllerEvent::Update(Some(update)) => {
-                        // only update art when album changes
-                        let new_cover = update.song.cover_path;
-                        if prev_cover != new_cover {
-                            prev_cover = new_cover.clone();
-                            let res = if let Some(image) = new_cover.and_then(|cover_path| {
-                                ImageProvider::parse(&cover_path, &icon_theme, false, image_size)
-                            }) {
-                                album_image.show();
-                                image.load_into_image(album_image.clone())
-                            } else {
-                                album_image.set_from_pixbuf(None);
-                                album_image.hide();
-                                Ok(())
-                            };
-
-                            if let Err(err) = res {
-                                error!("{err:?}");
-                            }
-                        }
-
-                        update_popup_metadata_label(update.song.title, &title_label);
-                        update_popup_metadata_label(update.song.album, &album_label);
-                        update_popup_metadata_label(update.song.artist, &artist_label);
-
-                        match update.status.state {
-                            PlayerState::Stopped => {
-                                btn_pause.hide();
-                                btn_play.show();
-                                btn_play.set_sensitive(false);
-                            }
-                            PlayerState::Playing => {
-                                btn_play.set_sensitive(false);
-                                btn_play.hide();
-
-                                btn_pause.set_sensitive(true);
-                                btn_pause.show();
-                            }
-                            PlayerState::Paused => {
-                                btn_pause.set_sensitive(false);
-                                btn_pause.hide();
-
-                                btn_play.set_sensitive(true);
-                                btn_play.show();
-                            }
-                        }
-
-                        let enable_prev = update.status.playlist_position > 0;
-
-                        let enable_next =
-                            update.status.playlist_position < update.status.playlist_length;
-
-                        btn_prev.set_sensitive(enable_prev);
-                        btn_next.set_sensitive(enable_next);
-
-                        if let Some(volume) = update.status.volume_percent {
-                            volume_slider.set_value(volume as f64);
-                            volume_box.show();
+            rx.attach(None, move |update| {
+                if let Some(update) = update {
+                    // only update art when album changes
+                    let new_cover = update.song.cover_path;
+                    if prev_cover != new_cover {
+                        prev_cover = new_cover.clone();
+                        let res = if let Some(image) = new_cover.and_then(|cover_path| {
+                            ImageProvider::parse(&cover_path, &icon_theme, image_size)
+                        }) {
+                            image.load_into_image(album_image.clone())
                        } else {
-                            volume_box.hide();
+                            album_image.set_from_pixbuf(None);
+                            Ok(())
+                        };
+
+                        if let Err(err) = res {
+                            error!("{err:?}");
                        }
                    }
-                    ControllerEvent::UpdateProgress(progress_tick)
-                        if !drag_lock.load(Ordering::Relaxed) =>
-                    {
-                        if let (Some(elapsed), Some(duration)) =
-                            (progress_tick.elapsed, progress_tick.duration)
-                        {
-                            progress_label.set_label(&format!(
-                                "{}/{}",
-                                format_time(elapsed),
-                                format_time(duration)
-                            ));

-                            progress.set_value(elapsed.as_secs_f64());
-                            progress.set_range(0.0, duration.as_secs_f64());
-                            progress_box.show_all();
-                        } else {
-                            progress_box.hide();
+                    title_label
+                        .label
+                        .set_text(&update.song.title.unwrap_or_default());
+                    album_label
+                        .label
+                        .set_text(&update.song.album.unwrap_or_default());
+                    artist_label
+                        .label
+                        .set_text(&update.song.artist.unwrap_or_default());
+
+                    match update.status.state {
+                        PlayerState::Stopped => {
+                            btn_pause.hide();
+                            btn_play.show();
+                            btn_play.set_sensitive(false);
+                        }
+                        PlayerState::Playing => {
+                            btn_play.set_sensitive(false);
+                            btn_play.hide();
+
+                            btn_pause.set_sensitive(true);
+                            btn_pause.show();
+                        }
+                        PlayerState::Paused => {
+                            btn_pause.set_sensitive(false);
+                            btn_pause.hide();
+
+                            btn_play.set_sensitive(true);
+                            btn_play.show();
                        }
                    }
-                    _ => {}
-                };
+
+                    let enable_prev = update.status.playlist_position > 0;
+
+                    let enable_next =
+                        update.status.playlist_position < update.status.playlist_length;
+
+                    btn_prev.set_sensitive(enable_prev);
+                    btn_next.set_sensitive(enable_next);
+
+                    volume_slider.set_value(update.status.volume_percent as f64);
+                }

                Continue(true)
            });
@@ -494,24 +407,17 @@ impl Module<Button> for MusicModule {
    }
 }

-fn update_popup_metadata_label(text: Option<String>, label: &IconLabel) {
-    match text {
-        Some(value) => {
-            label.label.set_text(&value);
-            label.container.show_all();
-        }
-        None => {
-            label.container.hide();
-        }
-    }
-}
-
 /// Replaces each of the formatting tokens in the formatting string
 /// with actual data pulled from the music player
-fn replace_tokens(format_string: &str, tokens: &Vec<String>, song: &Track) -> String {
+fn replace_tokens(
+    format_string: &str,
+    tokens: &Vec<String>,
+    song: &Track,
+    status: &Status,
+) -> String {
    let mut compiled_string = format_string.to_string();
    for token in tokens {
-        let value = get_token_value(song, token);
+        let value = get_token_value(song, status, token);
        compiled_string = compiled_string.replace(format!("{{{token}}}").as_str(), value.as_str());
    }
    compiled_string
@@ -519,7 +425,7 @@ fn replace_tokens(format_string: &str, tokens: &Vec<String>, song: &Track) -> St

 /// Converts a string format token value
 /// into its respective value.
-fn get_token_value(song: &Track, token: &str) -> String {
+fn get_token_value(song: &Track, status: &Status, token: &str) -> String {
    match token {
        "title" => song.title.clone(),
        "album" => song.album.clone(),
@@ -528,6 +434,8 @@ fn get_token_value(song: &Track, token: &str) -> String {
        "disc" => song.disc.map(|x| x.to_string()),
        "genre" => song.genre.clone(),
        "track" => song.track.map(|x| x.to_string()),
+        "duration" => status.duration.map(format_time),
+        "elapsed" => status.elapsed.map(format_time),
        _ => Some(token.to_string()),
    }
    .unwrap_or_default()
@@ -546,8 +454,8 @@ impl IconLabel {
        let icon = new_icon_label(icon_input, icon_theme, 24);
        let label = Label::new(label);

-        icon.add_class("icon-box");
-        label.add_class("label");
+        add_class(&icon, "icon-box");
+        add_class(&label, "label");

        container.add(&icon);
        container.add(&label);
--- a/src/modules/script.rs
+++ b/src/modules/script.rs
@@ -1,5 +1,5 @@
 use crate::config::CommonConfig;
-use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::script::{OutputStream, Script, ScriptMode};
 use crate::try_send;
 use color_eyre::{Help, Report, Result};
@@ -83,7 +83,7 @@ impl Module<Label> for ScriptModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<Label>> {
+    ) -> Result<ModuleWidget<Label>> {
        let label = Label::builder().use_markup(true).build();
        label.set_angle(info.bar_position.get_angle());

@@ -95,7 +95,7 @@ impl Module<Label> for ScriptModule {
            });
        }

-        Ok(ModuleParts {
+        Ok(ModuleWidget {
            widget: label,
            popup: None,
        })
--- a/src/modules/sysinfo.rs
+++ b/src/modules/sysinfo.rs
@@ -1,6 +1,6 @@
 use crate::config::CommonConfig;
-use crate::gtk_helpers::IronbarGtkExt;
-use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
+use crate::gtk_helpers::add_class;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::send_async;
 use color_eyre::Result;
 use gtk::prelude::*;
@@ -186,7 +186,7 @@ impl Module<gtk::Box> for SysInfoModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<gtk::Box>> {
+    ) -> Result<ModuleWidget<gtk::Box>> {
        let re = Regex::new(r"\{([^}]+)}")?;

        let container = gtk::Box::new(info.bar_position.get_orientation(), 10);
@@ -196,7 +196,7 @@ impl Module<gtk::Box> for SysInfoModule {
        for format in &self.format {
            let label = Label::builder().label(format).use_markup(true).build();

-            label.add_class("item");
+            add_class(&label, "item");
            label.set_angle(info.bar_position.get_angle());

            container.add(&label);
@@ -220,7 +220,7 @@ impl Module<gtk::Box> for SysInfoModule {
            });
        }

-        Ok(ModuleParts {
+        Ok(ModuleWidget {
            widget: container,
            popup: None,
        })
--- a/src/modules/tray.rs
+++ b/src/modules/tray.rs
@@ -1,6 +1,6 @@
 use crate::clients::system_tray::get_tray_event_client;
 use crate::config::CommonConfig;
-use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::{await_sync, try_send};
 use color_eyre::Result;
 use gtk::gdk_pixbuf::{Colorspace, InterpType};
@@ -11,9 +11,9 @@ use gtk::{
 };
 use serde::Deserialize;
 use std::collections::HashMap;
-use system_tray::message::menu::{MenuItem as MenuItemInfo, MenuType};
-use system_tray::message::tray::StatusNotifierItem;
-use system_tray::message::{NotifierItemCommand, NotifierItemMessage};
+use stray::message::menu::{MenuItem as MenuItemInfo, MenuType};
+use stray::message::tray::StatusNotifierItem;
+use stray::message::{NotifierItemCommand, NotifierItemMessage};
 use tokio::spawn;
 use tokio::sync::mpsc;
 use tokio::sync::mpsc::{Receiver, Sender};
@@ -172,7 +172,7 @@ impl Module<MenuBar> for TrayModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        _info: &ModuleInfo,
-    ) -> Result<ModuleParts<MenuBar>> {
+    ) -> Result<ModuleWidget<MenuBar>> {
        let container = MenuBar::new();

        {
@@ -238,7 +238,7 @@ impl Module<MenuBar> for TrayModule {
            });
        };

-        Ok(ModuleParts {
+        Ok(ModuleWidget {
            widget: container,
            popup: None,
        })
--- a/src/modules/upower.rs
+++ b/src/modules/upower.rs
@@ -1,3 +1,10 @@
+use crate::clients::upower::get_display_proxy;
+use crate::config::CommonConfig;
+use crate::gtk_helpers::add_class;
+use crate::image::ImageProvider;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::popup::Popup;
+use crate::{await_sync, error, send_async, try_send};
 use color_eyre::Result;
 use futures_lite::stream::StreamExt;
 use gtk::{prelude::*, Button};
@@ -8,16 +15,6 @@ use tokio::sync::mpsc::{Receiver, Sender};
 use upower_dbus::BatteryState;
 use zbus;

-use crate::clients::upower::get_display_proxy;
-use crate::config::CommonConfig;
-use crate::gtk_helpers::IronbarGtkExt;
-use crate::image::ImageProvider;
-use crate::modules::PopupButton;
-use crate::modules::{
-    Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, WidgetContext,
-};
-use crate::{await_sync, error, send_async, try_send};
-
 const DAY: i64 = 24 * 60 * 60;
 const HOUR: i64 = 60 * 60;
 const MINUTE: i64 = 60;
@@ -153,31 +150,32 @@ impl Module<gtk::Button> for UpowerModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<Button>> {
+    ) -> Result<ModuleWidget<Button>> {
        let icon_theme = info.icon_theme.clone();
        let icon = gtk::Image::new();
-        icon.add_class("icon");
+        add_class(&icon, "icon");

        let label = Label::builder()
            .label(&self.format)
            .use_markup(true)
            .build();
-        label.add_class("label");
+        add_class(&label, "label");

        let container = gtk::Box::new(Orientation::Horizontal, 5);
-        container.add_class("contents");
+        add_class(&container, "contents");

        let button = Button::new();
-        button.add_class("button");
+        add_class(&button, "button");

        container.add(&icon);
        container.add(&label);
        button.add(&container);

+        let orientation = info.bar_position.get_orientation();
        button.connect_clicked(move |button| {
            try_send!(
                context.tx,
-                ModuleUpdateEvent::TogglePopup(button.popup_id())
+                ModuleUpdateEvent::TogglePopup(Popup::widget_geometry(button, orientation))
            );
        });

@@ -189,17 +187,18 @@ impl Module<gtk::Button> for UpowerModule {
            .attach(None, move |properties: UpowerProperties| {
                let format = format.replace("{percentage}", &properties.percentage.to_string());
                let icon_name = String::from("icon:") + &properties.icon_name;
-                ImageProvider::parse(&icon_name, &icon_theme, false, self.icon_size)
+                ImageProvider::parse(&icon_name, &icon_theme, self.icon_size)
                    .map(|provider| provider.load_into_image(icon.clone()));
                label.set_markup(format.as_ref());
                Continue(true)
            });

-        let popup = self
-            .into_popup(context.controller_tx, context.popup_rx, info)
-            .into_popup_parts(vec![&button]);
+        let popup = self.into_popup(context.controller_tx, context.popup_rx, info);

-        Ok(ModuleParts::new(button, popup))
+        Ok(ModuleWidget {
+            widget: button,
+            popup,
+        })
    }

    fn into_popup(
@@ -216,7 +215,7 @@ impl Module<gtk::Button> for UpowerModule {
            .build();

        let label = Label::new(None);
-        label.add_class("upower-details");
+        add_class(&label, "upower-details");
        container.add(&label);

        rx.attach(None, move |properties| {
--- a/src/modules/workspaces.rs
+++ b/src/modules/workspaces.rs
@@ -1,14 +1,14 @@
-use crate::clients::compositor::{Compositor, Workspace, WorkspaceUpdate};
+use crate::clients::compositor::{Compositor, WorkspaceUpdate};
 use crate::config::CommonConfig;
 use crate::image::new_icon_button;
-use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::{send_async, try_send};
 use color_eyre::{Report, Result};
 use gtk::prelude::*;
 use gtk::{Button, IconTheme};
 use serde::Deserialize;
 use std::cmp::Ordering;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use tokio::spawn;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::trace;
@@ -29,32 +29,11 @@ impl Default for SortOrder {
    }
 }

-#[derive(Debug, Deserialize, Clone)]
-#[serde(untagged)]
-pub enum Favorites {
-    ByMonitor(HashMap<String, Vec<String>>),
-    Global(Vec<String>),
-}
-
-impl Default for Favorites {
-    fn default() -> Self {
-        Self::Global(vec![])
-    }
-}
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct WorkspacesModule {
    /// Map of actual workspace names to custom names.
    name_map: Option<HashMap<String, String>>,

-    /// Array of always shown workspaces, and what monitor to show on
-    #[serde(default)]
-    favorites: Favorites,
-
-    /// List of workspace names to never show
-    #[serde(default)]
-    hidden: Vec<String>,
-
    /// Whether to display buttons for all monitors.
    #[serde(default = "crate::config::default_false")]
    all_monitors: bool,
@@ -77,7 +56,6 @@ const fn default_icon_size() -> i32 {
 fn create_button(
    name: &str,
    focused: bool,
-    inactive: bool,
    name_map: &HashMap<String, String>,
    icon_theme: &IconTheme,
    icon_size: i32,
@@ -93,8 +71,6 @@ fn create_button(

    if focused {
        style_context.add_class("focused");
-    } else if inactive {
-        style_context.add_class("inactive");
    }

    {
@@ -129,13 +105,6 @@ fn reorder_workspaces(container: &gtk::Box) {
    }
 }

-impl WorkspacesModule {
-    fn show_workspace_check(&self, output: &String, work: &Workspace) -> bool {
-        (work.focused || !self.hidden.contains(&work.name))
-            && (self.all_monitors || output == &work.monitor)
-    }
-}
-
 impl Module<gtk::Box> for WorkspacesModule {
    type SendMessage = WorkspaceUpdate;
    type ReceiveMessage = String;
@@ -185,12 +154,10 @@ impl Module<gtk::Box> for WorkspacesModule {
        self,
        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
        info: &ModuleInfo,
-    ) -> Result<ModuleParts<gtk::Box>> {
+    ) -> Result<ModuleWidget<gtk::Box>> {
        let container = gtk::Box::new(info.bar_position.get_orientation(), 0);

-        let name_map = self.name_map.clone().unwrap_or_default();
-        let favs = self.favorites.clone();
-        let mut fav_names: Vec<String> = vec![];
+        let name_map = self.name_map.unwrap_or_default();

        let mut button_map: HashMap<String, Button> = HashMap::new();

@@ -209,49 +176,19 @@ impl Module<gtk::Box> for WorkspacesModule {
                    WorkspaceUpdate::Init(workspaces) => {
                        if !has_initialized {
                            trace!("Creating workspace buttons");
+                            for workspace in workspaces {
+                                if self.all_monitors || workspace.monitor == output_name {
+                                    let item = create_button(
+                                        &workspace.name,
+                                        workspace.focused,
+                                        &name_map,
+                                        &icon_theme,
+                                        icon_size,
+                                        &context.controller_tx,
+                                    );
+                                    container.add(&item);

-                            let mut added = HashSet::new();
-
-                            let mut add_workspace = |name: &str, focused: bool| {
-                                let item = create_button(
-                                    name,
-                                    focused,
-                                    false,
-                                    &name_map,
-                                    &icon_theme,
-                                    icon_size,
-                                    &context.controller_tx,
-                                );
-
-                                container.add(&item);
-                                button_map.insert(name.to_string(), item);
-                            };
-
-                            // add workspaces from client
-                            for workspace in &workspaces {
-                                if self.show_workspace_check(&output_name, workspace) {
-                                    add_workspace(&workspace.name, workspace.focused);
-                                    added.insert(workspace.name.to_string());
-                                }
-                            }
-
-                            let mut add_favourites = |names: &Vec<String>| {
-                                for name in names {
-                                    if !added.contains(name) {
-                                        add_workspace(name, false);
-                                        added.insert(name.to_string());
-                                        fav_names.push(name.to_string());
-                                    }
-                                }
-                            };
-
-                            // add workspaces from favourites
-                            match &favs {
-                                Favorites::Global(names) => add_favourites(names),
-                                Favorites::ByMonitor(map) => {
-                                    if let Some(to_add) = map.get(&output_name) {
-                                        add_favourites(to_add);
-                                    }
+                                    button_map.insert(workspace.name, item);
                                }
                            }

@@ -275,17 +212,11 @@ impl Module<gtk::Box> for WorkspacesModule {
                        }
                    }
                    WorkspaceUpdate::Add(workspace) => {
-                        if fav_names.contains(&workspace.name) {
-                            let btn = button_map.get(&workspace.name);
-                            if let Some(btn) = btn {
-                                btn.style_context().remove_class("inactive");
-                            }
-                        } else if self.show_workspace_check(&output_name, &workspace) {
+                        if self.all_monitors || workspace.monitor == output_name {
                            let name = workspace.name;
                            let item = create_button(
                                &name,
                                workspace.focused,
-                                false,
                                &name_map,
                                &icon_theme,
                                icon_size,
@@ -305,13 +236,12 @@ impl Module<gtk::Box> for WorkspacesModule {
                        }
                    }
                    WorkspaceUpdate::Move(workspace) => {
-                        if !self.hidden.contains(&workspace.name) && !self.all_monitors {
+                        if !self.all_monitors {
                            if workspace.monitor == output_name {
                                let name = workspace.name;
                                let item = create_button(
                                    &name,
                                    workspace.focused,
-                                    false,
                                    &name_map,
                                    &icon_theme,
                                    icon_size,
@@ -337,11 +267,7 @@ impl Module<gtk::Box> for WorkspacesModule {
                    WorkspaceUpdate::Remove(workspace) => {
                        let button = button_map.get(&workspace);
                        if let Some(item) = button {
-                            if fav_names.contains(&workspace) {
-                                item.style_context().add_class("inactive");
-                            } else {
-                                container.remove(item);
-                            }
+                            container.remove(item);
                        }
                    }
                    WorkspaceUpdate::Update(_) => {}
@@ -351,7 +277,7 @@ impl Module<gtk::Box> for WorkspacesModule {
            });
        }

-        Ok(ModuleParts {
+        Ok(ModuleWidget {
            widget: container,
            popup: None,
        })
--- a/src/popup.rs
+++ b/src/popup.rs
@@ -1,22 +1,18 @@
 use std::collections::HashMap;

+use crate::config::BarPosition;
+use crate::modules::ModuleInfo;
 use gtk::gdk::Monitor;
 use gtk::prelude::*;
 use gtk::{ApplicationWindow, Orientation};
 use tracing::debug;

-use crate::config::BarPosition;
-use crate::gtk_helpers::{IronbarGtkExt, WidgetGeometry};
-use crate::modules::{ModuleInfo, ModulePopupParts, PopupButton};
-use crate::unique_id::get_unique_usize;
-
 #[derive(Debug, Clone)]
 pub struct Popup {
    pub window: ApplicationWindow,
-    pub cache: HashMap<usize, (String, ModulePopupParts)>,
+    pub cache: HashMap<usize, gtk::Box>,
    monitor: Monitor,
    pos: BarPosition,
-    current_widget: Option<usize>,
 }

 impl Popup {
@@ -32,7 +28,6 @@ impl Popup {
            .build();

        gtk_layer_shell::init_for_window(&win);
-        gtk_layer_shell::set_monitor(&win, module_info.monitor);
        gtk_layer_shell::set_layer(&win, gtk_layer_shell::Layer::Overlay);
        gtk_layer_shell::set_namespace(&win, env!("CARGO_PKG_NAME"));

@@ -113,54 +108,20 @@ impl Popup {
            cache: HashMap::new(),
            monitor: module_info.monitor.clone(),
            pos,
-            current_widget: None,
        }
    }

-    pub fn register_content(&mut self, key: usize, name: String, content: ModulePopupParts) {
+    pub fn register_content(&mut self, key: usize, content: gtk::Box) {
        debug!("Registered popup content for #{}", key);
-
-        for button in &content.buttons {
-            let id = get_unique_usize();
-            button.set_tag("popup-id", id);
-        }
-
-        self.cache.insert(key, (name, content));
+        self.cache.insert(key, content);
    }

-    pub fn show(&mut self, widget_id: usize, button_id: usize) {
+    pub fn show_content(&self, key: usize) {
        self.clear_window();

-        if let Some((_name, content)) = self.cache.get(&widget_id) {
-            self.current_widget = Some(widget_id);
-
-            content.container.style_context().add_class("popup");
-            self.window.add(&content.container);
-
-            self.window.show();
-
-            let button = content
-                .buttons
-                .iter()
-                .find(|b| b.popup_id() == button_id)
-                .expect("to find valid button");
-
-            let orientation = self.pos.get_orientation();
-            let geometry = button.geometry(orientation);
-
-            self.set_pos(geometry);
-        }
-    }
-
-    pub fn show_at(&self, widget_id: usize, geometry: WidgetGeometry) {
-        self.clear_window();
-
-        if let Some((_name, content)) = self.cache.get(&widget_id) {
-            content.container.style_context().add_class("popup");
-            self.window.add(&content.container);
-
-            self.window.show();
-            self.set_pos(geometry);
+        if let Some(content) = self.cache.get(&key) {
+            content.style_context().add_class("popup");
+            self.window.add(content);
        }
    }

@@ -171,9 +132,14 @@ impl Popup {
        }
    }

+    /// Shows the popup
+    pub fn show(&self, geometry: WidgetGeometry) {
+        self.window.show();
+        self.set_pos(geometry);
+    }
+
    /// Hides the popover
-    pub fn hide(&mut self) {
-        self.current_widget = None;
+    pub fn hide(&self) {
        self.window.hide();
    }

@@ -182,10 +148,6 @@ impl Popup {
        self.window.is_visible()
    }

-    pub fn current_widget(&self) -> Option<usize> {
-        self.current_widget
-    }
-
    /// Sets the popup's X/Y position relative to the left or border of the screen
    /// (depending on orientation).
    fn set_pos(&self, geometry: WidgetGeometry) {
@@ -225,4 +187,48 @@ impl Popup {

        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 widget_geometry<W>(widget: &W, orientation: Orientation) -> WidgetGeometry
+    where
+        W: IsA<gtk::Widget>,
+    {
+        let widget_size = if orientation == Orientation::Horizontal {
+            widget.allocation().width()
+        } else {
+            widget.allocation().height()
+        };
+
+        let top_level = widget.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 (widget_x, widget_y) = widget
+            .translate_coordinates(&top_level, 0, 0)
+            .unwrap_or((0, 0));
+
+        let widget_pos = if orientation == Orientation::Horizontal {
+            widget_x
+        } else {
+            widget_y
+        };
+
+        WidgetGeometry {
+            position: widget_pos,
+            size: widget_size,
+            bar_size,
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct WidgetGeometry {
+    position: i32,
+    size: i32,
+    bar_size: i32,
 }