chore(release): v0.10.0

feat: add feature flags

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,50 @@
+---
+name: Bug report
+about: Report an issue with the bar not working as expected
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+> A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+> A clear and concise description of what you expected to happen.
+
+**System information:**
+ - Distro: [e.g. Arch Linux, Ubuntu 22.10]
+- Compositor: [e.g. Sway]
+ - Ironbar version: [e.g. 0.8.0]
+
+**Configuration**
+> Share your bar configuration and stylesheet as applicable:
+
+<details><summary>Config</summary>
+
+```
+
+```
+</details>
+
+
+<details><summary>Styles</summary>
+
+```css
+
+```
+</details>
+
+**Additional context**
+> Add any other context about the problem here.
+
+**Screenshots**
+> If applicable, add screenshots to help explain your problem.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,22 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+> A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+
+**Describe the solution you'd like**
+> A clear and concise description of what you want to happen.
+> The more info here about what you are trying to achieve, the better - there's likely more than one way to go about implementing a solution.
+
+**Describe alternatives you've considered**
+> A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+> Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/other.md

@@ -0,0 +1,10 @@
+---
+name: Other
+about: Any other issue type
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+

.github/scripts/sync-wiki.sh

@@ -0,0 +1,43 @@
+#!/bin/sh
+set -eu
+
+TEMP_REPO_DIR="wiki_action_$GITHUB_REPOSITORY$GITHUB_SHA"
+TEMP_WIKI_DIR="temp_wiki_$GITHUB_SHA"
+
+WIKI_DIR='docs'
+
+if [ -z "$GH_TOKEN" ]; then
+    echo "Token is not specified"
+    exit 1
+fi
+
+#Clone repo
+echo "Cloning repo https://github.com/$GITHUB_REPOSITORY"
+git clone "https://$GITHUB_ACTOR:$GH_TOKEN@github.com/$GITHUB_REPOSITORY" "$TEMP_REPO_DIR"
+
+#Clone wiki repo
+echo "Cloning wiki repo https://github.com/$GITHUB_REPOSITORY.wiki.git"
+cd "$TEMP_REPO_DIR"
+git clone "https://$GITHUB_ACTOR:$GH_TOKEN@github.com/$GITHUB_REPOSITORY.wiki.git" "$TEMP_WIKI_DIR"
+
+#Get commit details
+author='Jake Stanger'
+email='mail@jstanger.dev'
+message='action: sync wiki'
+
+echo "Copying edited wiki"
+cp -R "$TEMP_WIKI_DIR/.git" "$WIKI_DIR/"
+
+echo "Checking if wiki has changes"
+cd "$WIKI_DIR"
+git config --local user.email "$email"
+git config --local user.name "$author"
+git add .
+
+if git diff-index --quiet HEAD; then
+  echo "Nothing changed"
+  exit 0
+fi
+
+echo "Pushing changes to wiki"
+git commit -m "$message" && git push "https://$GITHUB_ACTOR:$GH_TOKEN@github.com/$GITHUB_REPOSITORY.wiki.git"

.github/workflows/build.yml

@@ -1,6 +1,7 @@
 name: Build
 
 on:
+  workflow_dispatch:
   push:
     branches: [ "master" ]
   pull_request:
@@ -22,16 +23,51 @@ jobs:
           override: true
 
       - name: Install build deps
-        run: sudo apt install libgtk-3-dev libgtk-layer-shell-dev
+        run: |
+          sudo apt-get update
+          sudo apt-get install libgtk-3-dev libgtk-layer-shell-dev
 
-      - name: Build
-        run: cargo build --verbose
+      - name: Check formatting
+        run: cargo fmt --check
 
-      - name: Clippy
+      - name: Clippy (base features)
+        uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --no-default-features --features config+json
+
+      - name: Clippy (all features)
         uses: actions-rs/clippy-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           args: --all-features
 
-      - name: Check formatting
-        run: cargo fmt --check
+      - name: Build
+        run: cargo build --verbose
+
+      - name: Run tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+
+
+
+  build-nix:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: cachix/install-nix-action@v17
+        with:
+          install_url: https://nixos.org/nix/install
+          extra_nix_config: |
+            auto-optimise-store = true
+            experimental-features = nix-command flakes
+
+      - uses: cachix/cachix-action@v11
+        with:
+          name: jakestanger
+          signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'
+
+      - run: nix build --print-build-logs

.github/workflows/deploy.yml

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

.github/workflows/update-nix-flake-lock.yml

@@ -0,0 +1,27 @@
+name: update-nix-flake-lock
+on:
+  workflow_dispatch: # allows manual triggering
+  schedule:
+    - cron: '0 0 1 * *' # first day of every month
+
+jobs:
+  update-nix-flake-lock:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Install Nix
+        uses: cachix/install-nix-action@v16
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+
+      - name: Update flake.lock
+        uses: DeterminateSystems/update-flake-lock@v15
+        with:
+          pr-title: "Update flake.lock" # Title of PR to be created
+          pr-labels: |                  # Labels to be set on the PR
+            dependencies
+            automated

.github/workflows/wiki.yml

@@ -0,0 +1,17 @@
+name: Sync Wiki
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Sync Wiki
+        run: ./.github/scripts/sync-wiki.sh
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.idea/runConfigurations/Format.xml

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

.idea/runConfigurations/Run.xml

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

.idea/runConfigurations/Run__GTK_Debug_.xml

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

.idea/runConfigurations/Run__Live_Config_.xml

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

CHANGELOG.md

@@ -0,0 +1,197 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v0.9.0] - 2023-01-28
+### :boom: BREAKING CHANGES
+- due to [`fa67d07`](https://github.com/JakeStanger/ironbar/commit/fa67d077b136b109edf6dbaa11a33aebf3e044b4) - mouse event config options *(commit by [@JakeStanger](https://github.com/JakeStanger))*:
+
+  `on_click` is now called `on_click_left` for consistency with new options.
+
+- due to [`6d8e647`](https://github.com/JakeStanger/ironbar/commit/6d8e647f123e54ba389c5ab2fe908200aa5e4cf6) - mpris support *(commit by [@JakeStanger](https://github.com/JakeStanger))*:
+
+  The `mpd` module has been renamed to `music`. You will need to update the `type` value in your config and add `player_type` to continue using MPD. You will also need to update your styles.
+
+
+### :sparkles: New Features
+- [`1dd5863`](https://github.com/JakeStanger/ironbar/commit/1dd586343143bfd501a44c6556719fac9d582d6b) - better surface some config error messages *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`fa67d07`](https://github.com/JakeStanger/ironbar/commit/fa67d077b136b109edf6dbaa11a33aebf3e044b4) - mouse event config options *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`6d8e647`](https://github.com/JakeStanger/ironbar/commit/6d8e647f123e54ba389c5ab2fe908200aa5e4cf6) - mpris support *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`6e5d0c1`](https://github.com/JakeStanger/ironbar/commit/6e5d0c1e8c0b5d7e330608fc835e1e9733f156de) - **workspaces**: hyprland support *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`9ba28fe`](https://github.com/JakeStanger/ironbar/commit/9ba28fe7faf84e06febc2ffea089442f8f5b90a2) - **workspaces**: better ordering *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :bug: Bug Fixes
+- [`e1f523c`](https://github.com/JakeStanger/ironbar/commit/e1f523cf2a15b74a5c570dd7440db4c1b476d782) - **music**: popup artist label using wrong name *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`08cfbbc`](https://github.com/JakeStanger/ironbar/commit/08cfbbc2eaf6e74780dd7196efcc15ea6d2e7d12) - **music**: unable to go to prev with mpris *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`0cefcbd`](https://github.com/JakeStanger/ironbar/commit/0cefcbd02b0af518352e35060644f281da249d3e) - **music**: wrong widget name on vol slider *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`90cd078`](https://github.com/JakeStanger/ironbar/commit/90cd078973b23b2291cf156e46729842f33c1806) - **mpd**: stops working if connection lost *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :recycle: Refactors
+- [`2c1b292`](https://github.com/JakeStanger/ironbar/commit/2c1b2924d4a103183d3974ac066623a80277a79a) - move most of the horrible `add_module` macro content into proper functions *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`fd2d7e5`](https://github.com/JakeStanger/ironbar/commit/fd2d7e5c7ab8de50c4621b19d07d8b012a451564) - move startup logging code to logging module *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`9d5049d`](https://github.com/JakeStanger/ironbar/commit/9d5049dde01cdb76f4772f8ce8f61a8b5bad3a50) - standardise error messages *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`5e21cbc`](https://github.com/JakeStanger/ironbar/commit/5e21cbcca6cc30d725acdea0f6561cfd6acdcc3c) - macros to reduce repeated code *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`ea2c84d`](https://github.com/JakeStanger/ironbar/commit/ea2c84d1bd15798e32496397c4a6aa42fab39d95) - general code tidy-up *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`0d7ab54`](https://github.com/JakeStanger/ironbar/commit/0d7ab541604691455ed39c73e039ac0635307bc8) - remove redundant clone *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :memo: Documentation Changes
+- [`b97f018`](https://github.com/JakeStanger/ironbar/commit/b97f018e81aa55a871a12aa3e1e4b07b1f8eb50f) - update CHANGELOG.md for v0.8.0 [skip ci] *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`c223892`](https://github.com/JakeStanger/ironbar/commit/c223892a57b29ae56431fc585b8cec503f3206c7) - **workspaces**: update for hyprland/new ordering option *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.8.0] - 2022-11-30
+### :boom: BREAKING CHANGES
+- due to [`df77020`](https://github.com/JakeStanger/ironbar/commit/df77020c5277ae9e379bb4fd67c221be5cb20426) - use snake_case for module tokens for consistency *(commit by [@JakeStanger](https://github.com/JakeStanger))*:
+
+  This renames the module from `sys-info` to `sys_info`, and almost every formatting token from `kebab-case` to `snake_case`. Any use of this module will need to be updated.
+
+- due to [`8c75bc4`](https://github.com/JakeStanger/ironbar/commit/8c75bc46ac2885a748d31df9261d988cc797e916) - rename `path` to `cmd` for consistency *(commit by [@JakeStanger](https://github.com/JakeStanger))*:
+
+  This changes the option in the `script` module. Any uses of the module must be updated to use the new option name.
+
+- due to [`e274ba3`](https://github.com/JakeStanger/ironbar/commit/e274ba39cd6d8f1c73033ac1e60e5bce89205ce2) - rename `exec` to `on_click` for consistency *(commit by [@JakeStanger](https://github.com/JakeStanger))*:
+
+  This changes the option on buttons in the `custom` module. Any uses of the module must be updated to use the new custom widget attribute name.
+
+
+### :sparkles: New Features
+- [`73158c2`](https://github.com/JakeStanger/ironbar/commit/73158c2fce2880347b88d58541dea000534996c8) - **script**: new watch mode *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`a3f90ad`](https://github.com/JakeStanger/ironbar/commit/a3f90adaf19aebed7020eeb44b91250af080d313) - add nix flake support *(commit by [@yavko](https://github.com/yavko))*
+- [`c9e66d4`](https://github.com/JakeStanger/ironbar/commit/c9e66d4664137c50aba4aecdc3a3ba43d3da11fe) - common module options (`show_if`, `on_click`, `tooltip`) *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`5d153a0`](https://github.com/JakeStanger/ironbar/commit/5d153a02fc9b113bb77a04596b806edd182fc5d3) - **custom**: ability to embed scripts in labels for dynamic content *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`d20972c`](https://github.com/JakeStanger/ironbar/commit/d20972cb32714627d0cca947021453979c76dd03) - dynamic tooltips *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :recycle: Refactors
+- [`ff17ec1`](https://github.com/JakeStanger/ironbar/commit/ff17ec1996cf344663e84e79d11b08dc84b97635) - various changes based on rust 1.65 clippy *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`4662f60`](https://github.com/JakeStanger/ironbar/commit/4662f60ac54165be6fb7aea12c245309db0fe5d6) - move various clients to own folder *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`0fb5fa8`](https://github.com/JakeStanger/ironbar/commit/0fb5fa8c2a166c3d46b006ceb0d53af076824ff4) - use latest `libcorn` with serde support *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`df77020`](https://github.com/JakeStanger/ironbar/commit/df77020c5277ae9e379bb4fd67c221be5cb20426) - **sys_info**: use snake_case for module tokens for consistency *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`8c75bc4`](https://github.com/JakeStanger/ironbar/commit/8c75bc46ac2885a748d31df9261d988cc797e916) - **script**: rename `path` to `cmd` for consistency *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`e274ba3`](https://github.com/JakeStanger/ironbar/commit/e274ba39cd6d8f1c73033ac1e60e5bce89205ce2) - **custom**: rename `exec` to `on_click` for consistency *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`64f5404`](https://github.com/JakeStanger/ironbar/commit/64f54040ef626157af6b6a9ce5258507a10a23fb) - move dynamic_label.rs to dynamic_string.rs and fix failing test *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :white_check_mark: Tests
+- [`907a565`](https://github.com/JakeStanger/ironbar/commit/907a565f3d418a276dfb454e1189ddede1814291) - **dynamic label**: do not run if cannot initialise gtk *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :memo: Documentation Changes
+- [`1c032ae`](https://github.com/JakeStanger/ironbar/commit/1c032ae8e3a38b82c286bab7d102842f14b708e1) - update CHANGELOG.md for v0.7.0 [skip ci] *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`58d55db`](https://github.com/JakeStanger/ironbar/commit/58d55db6600fe2f9b23ae8ec6a50a686d2acaf65) - migrate wiki into main repo *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`c480296`](https://github.com/JakeStanger/ironbar/commit/c48029664d5f58bf73faa2931f34b38b8b184d25) - **script**: improve doc comment *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`8c77410`](https://github.com/JakeStanger/ironbar/commit/8c774100f1c8ea051284c6950339a2c8ed59a52a) - **script**: add information on new mode options *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`c4cdf4b`](https://github.com/JakeStanger/ironbar/commit/c4cdf4be8ba83f3669158a1552eab4a840085204) - update example configs *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`ec69649`](https://github.com/JakeStanger/ironbar/commit/ec69649a04f6199953836e51c2efe1fe2a19e320) - update example configs *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`1320639`](https://github.com/JakeStanger/ironbar/commit/1320639d4e6b7c8cd8f861b26b2b854504775ef0) - add custom power menu example *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`afedf02`](https://github.com/JakeStanger/ironbar/commit/afedf0214d3a71f6283c70bd3a110d24f68d2fdf) - add link to new custom power menu example *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.7.0] - 2022-11-05
+### :sparkles: New Features
+- [`fad90fd`](https://github.com/JakeStanger/ironbar/commit/fad90fdad683a612497ac7822a66a90f43fce0a2) - **sys-info**: add loads more formatting tokens *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`dec402e`](https://github.com/JakeStanger/ironbar/commit/dec402edd9d6c5b8677ff337699ad99ebc69b776) - **sys-info**: config options for refresh intervals *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`91c57ed`](https://github.com/JakeStanger/ironbar/commit/91c57edc73f15397ea0de70c4a6a6532c35caf2a) - **sys-info**: pango markup support *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`ec1d596`](https://github.com/JakeStanger/ironbar/commit/ec1d59677b13c9654a98d78f909ba2d0fcfbb72d) - **logging**: `IRONBAR_LOG` and `IRONBAR_FILE_LOG` env vars *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`493df6b`](https://github.com/JakeStanger/ironbar/commit/493df6bb49fec8c465706d3f9b395728ba73a621) - **mpd**: add volume slider to popup *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`3750124`](https://github.com/JakeStanger/ironbar/commit/3750124d8cfb4783932a6b3359384f245fcd2394) - new custom module *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`b7792a4`](https://github.com/JakeStanger/ironbar/commit/b7792a415e09fc535750ea5af530f91aa791c4bc) - env var to set custom css location *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`ad77dc4`](https://github.com/JakeStanger/ironbar/commit/ad77dc4e4c2f80fcb4c9604c796be0f981e895ee) - improved logging & error handling *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :bug: Bug Fixes
+- [`9e6dbbd`](https://github.com/JakeStanger/ironbar/commit/9e6dbbd131a09f101b0d490265fe7d4ec564e38c) - **sys-info**: tokens not replaced if more than one in string *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`f17ae7a`](https://github.com/JakeStanger/ironbar/commit/f17ae7a415b931c64942de085e8889f37b3f9b11) - **script**: not parsing pango markup *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`b66bd78`](https://github.com/JakeStanger/ironbar/commit/b66bd788b23256a2127a1352693fdd3f929d9c4b) - logging for creating bar incorrect still *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`3c43c20`](https://github.com/JakeStanger/ironbar/commit/3c43c20c6ae53a9aa6b67770b0c489806784f4ac) - weird behaviour when config does not exist *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`70e1b52`](https://github.com/JakeStanger/ironbar/commit/70e1b526a9681b16545d7f05d77470d76bd8819e) - **logging**: file log not capturing panics *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`cbd0c49`](https://github.com/JakeStanger/ironbar/commit/cbd0c49e251b5c8e0289ca6200a393d89994992d) - css watcher not working *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`e693c1c`](https://github.com/JakeStanger/ironbar/commit/e693c1c166eef0b5edcdcd033bb12d572e4e5f04) - **mpd**: volume slider causing mpd server errors *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`3a83bd3`](https://github.com/JakeStanger/ironbar/commit/3a83bd31ab165869f7f274b054b2f16485261fd1) - able to insert duplicate keys into collection *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :recycle: Refactors
+- [`5ebc84c`](https://github.com/JakeStanger/ironbar/commit/5ebc84c7b98cc648a659ca37fdc0f041057f0ea4) - **logging**: consts for default log levels *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`bc625b9`](https://github.com/JakeStanger/ironbar/commit/bc625b929b8644ce92f275b5d98cdf74b93fe067) - clippy & fmt *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :memo: Documentation Changes
+- [`9d9c275`](https://github.com/JakeStanger/ironbar/commit/9d9c2753137331ae85ac8ab7d75a6de9a9c82042) - update CHANGELOG.md for v0.6.0 [skip ci] *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`27d0479`](https://github.com/JakeStanger/ironbar/commit/27d04795af1c25fe5f765c7480d5dd5d096a8ab7) - **readme**: add warning about crate being outdated *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`a06c4bc`](https://github.com/JakeStanger/ironbar/commit/a06c4bccca6cb51935605ac9239e63024fb7c663) - **examples**: add full system info config *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`0a331f3`](https://github.com/JakeStanger/ironbar/commit/0a331f31381f0d967793c0d8b7a14e2a43bf666f) - **readme**: remove warning about outdated cargo package *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.6.0] - 2022-10-15
+### :sparkles: New Features
+- [`b188bc7`](https://github.com/JakeStanger/ironbar/commit/b188bc714614406935d8bb88a719adab2dfce32f) - initial support for running outside sway *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`324f00c`](https://github.com/JakeStanger/ironbar/commit/324f00cdf9200e3e3ecedfa68ab4c99b170242e2) - wlroots-agnostic support for `focused` module *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`b1c66b9`](https://github.com/JakeStanger/ironbar/commit/b1c66b9117cf8a10350cdb857a5267a1a72ad914) - wlroots-agnostic support for `launcher` module *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`1dd0a9e`](https://github.com/JakeStanger/ironbar/commit/1dd0a9e52f69e672d9ac313c1da0e201c911e6c2) - **launcher**: add popup css selectors *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`06cfad6`](https://github.com/JakeStanger/ironbar/commit/06cfad62e228f7fc63938f2280206450005cb064) - more positioning options *(PR [#23](https://github.com/JakeStanger/ironbar/pull/23) by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :bug: Bug Fixes
+- [`5523e9a`](https://github.com/JakeStanger/ironbar/commit/5523e9af46e457f9d45902debaaacf26b586e457) - **popup**: often opening in wrong place *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`8536ad7`](https://github.com/JakeStanger/ironbar/commit/8536ad719a92aec4166e35b75cb029075ad3ae34) - **mpd**: incorrectly checking for unix sockets *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`bd5bdf5`](https://github.com/JakeStanger/ironbar/commit/bd5bdf5af548304958663d593fccb454afa6c8ff) - logging for creating bar incorrect *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`75339f0`](https://github.com/JakeStanger/ironbar/commit/75339f07ed164fa94838036a604a1dcb6d53564c) - vertical bars ignoring height config option *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`b7b6488`](https://github.com/JakeStanger/ironbar/commit/b7b64886e3c48ace3faffbb1e277275aeeac3adf) - sometimes panicking on startup *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :recycle: Refactors
+- [`5ce50b0`](https://github.com/JakeStanger/ironbar/commit/5ce50b0987812a1ade2d1262e8d7df6916cfc39a) - tidy and format *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`1b853bc`](https://github.com/JakeStanger/ironbar/commit/1b853bcb71197a4bf3ca75725cc010b1d404c2b3) - fix clippy warning *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :memo: Documentation Changes
+- [`daafa09`](https://github.com/JakeStanger/ironbar/commit/daafa0943e5b9886b09fd18d6fff04558fb02335) - update CHANGELOG.md for v0.5.2 [skip ci] *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`b352181`](https://github.com/JakeStanger/ironbar/commit/b352181b3d232ccc79ffc1d9e22a633729d01a47) - update json example *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`bb4fe7f`](https://github.com/JakeStanger/ironbar/commit/bb4fe7f7f58fa2a6d0a2259bd9442700d2c884f7) - **readme**: credit smithay client toolkit *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`994d0f5`](https://github.com/JakeStanger/ironbar/commit/994d0f580b4d1b6ff750839652a7f06149743172) - **readme**: update references to sway *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :boom: BREAKING CHANGES
+- due to [`06cfad6`](https://github.com/JakeStanger/ironbar/commit/06cfad62e228f7fc63938f2280206450005cb064) - more positioning options *(PR [#23](https://github.com/JakeStanger/ironbar/pull/23) by [@JakeStanger](https://github.com/JakeStanger))*:
+
+  The `left` and `right` config options have been renamed to `start` and `end`
+
+
+## [v0.5.2] - 2022-09-07
+### :wrench: Chores
+- [`b801751`](https://github.com/JakeStanger/ironbar/commit/b801751bdabd8416084f46e6b6d803ea28a259ec) - **release**: v0.5.2 *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.5.1] - 2022-09-06
+### :bug: Bug Fixes
+- [`b81927e`](https://github.com/JakeStanger/ironbar/commit/b81927e3a57808188e31419695a36aa4ea3f2830) - **launcher**: opening new instances when focused/urgent *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`a35d255`](https://github.com/JakeStanger/ironbar/commit/a35d25520cd3fd235cdc77ec6209d88499ca3639) - **launcher**: item state changes not handled correctly *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :wrench: Chores
+- [`481adfc`](https://github.com/JakeStanger/ironbar/commit/481adfcaa41c0d3a1ba7d61edb68db49d959c78f) - **intellij**: update run configs *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`6871126`](https://github.com/JakeStanger/ironbar/commit/6871126bd8def89ccbf2934180d615e781ec32c7) - **release**: v0.5.1 *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.5.0] - 2022-08-25
+### :sparkles: New Features
+- [`1e38719`](https://github.com/JakeStanger/ironbar/commit/1e387199962b81caeb40ffbd99a956f24abdf4e3) - introduce logging in some areas *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :bug: Bug Fixes
+- [`023c2fb`](https://github.com/JakeStanger/ironbar/commit/023c2fb118f46f3592f1dfe1a6704014c062ab3f) - **workspaces**: not listening to move event *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+- [`6dcae66`](https://github.com/JakeStanger/ironbar/commit/6dcae66570cf5434e077ec823cded33771b4239c) - avoid creating loads of sway/mpd clients *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :wrench: Chores
+- [`015dcd3`](https://github.com/JakeStanger/ironbar/commit/015dcd3204dfa6a1ebcef1b4f3b345ed733fee2f) - **release**: v0.5.0 *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+## [v0.4.0] - 2022-08-22
+### :sparkles: New Features
+- [`ab8f7ec`](https://github.com/JakeStanger/ironbar/commit/ab8f7ecfc8fa4b96fce78518af75794641950140) - logging support and proper error handling *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :bug: Bug Fixes
+- [`f2ee2df`](https://github.com/JakeStanger/ironbar/commit/f2ee2dfe7a0f5575d0c3ec09644ca990b088cd85) - error when using with `swaybar_command` *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+### :wrench: Chores
+- [`1d7c377`](https://github.com/JakeStanger/ironbar/commit/1d7c3772e4b97c7198043cb55fe9c71695a211ab) - **release**: v0.4.0 *(commit by [@JakeStanger](https://github.com/JakeStanger))*
+
+
+[v0.4.0]: https://github.com/JakeStanger/ironbar/compare/v0.3.0...v0.4.0
+[v0.5.0]: https://github.com/JakeStanger/ironbar/compare/v0.4.0...v0.5.0
+[v0.5.1]: https://github.com/JakeStanger/ironbar/compare/v0.5.0...v0.5.1
+[v0.5.2]: https://github.com/JakeStanger/ironbar/compare/v0.5.1...v0.5.2
+[v0.6.0]: https://github.com/JakeStanger/ironbar/compare/v0.5.2...v0.6.0
+[v0.7.0]: https://github.com/JakeStanger/ironbar/compare/v0.6.0...v0.7.0
+[v0.8.0]: https://github.com/JakeStanger/ironbar/compare/v0.7.0...v0.8.0
+[v0.9.0]: https://github.com/JakeStanger/ironbar/compare/v0.8.0...v0.9.0

CONTRIBUTING.md

@@ -14,3 +14,4 @@ I welcome contributions of any kind with open arms. That said, please do stick t
 
 - For issues:
   - Please provide as much information as you can - share your config, any logs, steps to reproduce...
+  - If reporting an error, please ensure you use `IRONBAR_LOG` or `IRONBAR_FILE_LOG` set to `debug`.

Cargo.toml

@@ -1,37 +1,95 @@
 [package]
 name = "ironbar"
-version = "0.4.0"
+version = "0.10.0"
 edition = "2021"
 license = "MIT"
-description = "Customisable wlroots/sway bar"
+description = "Customisable GTK Layer Shell wlroots/sway bar"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+default = [
+    "http",
+    "config+all",
+    "clock",
+    "music+all",
+    "sys_info",
+    "tray",
+    "workspaces+all"
+]
+
+http = ["dep:reqwest"]
+
+"config+all" = ["config+json", "config+yaml", "config+toml", "config+corn"]
+"config+json" = ["serde_json"]
+"config+yaml" = ["serde_yaml"]
+"config+toml" = ["toml"]
+"config+corn" = ["libcorn"]
+
+clock = ["chrono"]
+
+music = ["regex"]
+"music+all" = ["music", "music+mpris", "music+mpd"]
+"music+mpris" = ["music", "mpris"]
+"music+mpd" = ["music", "mpd_client"]
+
+sys_info = ["sysinfo", "regex"]
+
+tray = ["stray"]
+
+workspaces = ["futures-util"]
+"workspaces+all" = ["workspaces", "workspaces+sway", "workspaces+hyprland"]
+"workspaces+sway" = ["workspaces", "swayipc-async"]
+"workspaces+hyprland" = ["workspaces", "hyprland"]
 
 [dependencies]
-gtk = "0.15.5"
-gtk-layer-shell = "0.4.1"
-glib = "0.15.12"
-tokio = { version = "1.20.1", features = ["macros", "rt-multi-thread", "time"] }
-tracing = "0.1.36"
-tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
+# core
+gtk = "0.16.0"
+gtk-layer-shell = "0.5.0"
+glib = "0.16.2"
+tokio = { version = "1.21.2", features = ["macros", "rt-multi-thread", "time", "process", "sync", "io-util", "net"] }
+tracing = "0.1.37"
+tracing-subscriber = { version = "0.3.16", features = ["env-filter"] }
 tracing-error = "0.2.0"
 tracing-appender = "0.2.2"
 strip-ansi-escapes = "0.1.1"
 color-eyre = "0.6.2"
-futures-util = "0.3.21"
-chrono = "0.4.19"
 serde = { version = "1.0.141", features = ["derive"] }
-serde_json = "1.0.82"
-serde_yaml = "0.9.4"
-toml = "0.5.9"
-cornfig = "0.2.0"
-regex = "1.6.0"
-stray = "0.1.1"
+indexmap = "1.9.1"
 dirs = "4.0.0"
 walkdir = "2.3.2"
-notify = "4.0.17"
-mpd_client = "0.7.5"
-ksway = "0.1.0"
-sysinfo = "0.25.1"
-# required for wrapping ksway
-crossbeam-channel = "0.3.9"
+notify = { version = "5.0.0", default-features = false }
+wayland-client = "0.29.5"
+wayland-protocols = { version = "0.29.5", features = ["unstable_protocols", "client"] }
+smithay-client-toolkit = { version = "0.16.0", default-features = false, features = ["calloop"] }
+lazy_static = "1.4.0"
+async_once = "0.2.6"
+cfg-if = "1.0.0"
+
+# http
+reqwest = { version = "0.11.14", optional = true }
+
+# config
+serde_json = { version = "1.0.82", optional = true }
+serde_yaml = { version = "0.9.4", optional = true }
+toml = { version = "0.7.0", optional = true }
+libcorn = { version = "0.6.1", optional = true }
+
+# clock
+chrono = { version = "0.4.19", optional = true }
+
+# music
+mpd_client = { version = "1.0.0", optional = true }
+mpris = { version = "2.0.0", optional = true }
+
+# sys_info
+sysinfo = { version = "0.27.0", optional = true }
+
+# tray
+stray = { version = "0.1.3", optional = true }
+
+# workspaces
+swayipc-async = { version = "2.0.1", optional = true }
+hyprland = { version = "0.3.0", optional = true }
+futures-util = { version = "0.3.21", optional = true }
+
+# shared
+regex = { version = "1.6.0", default-features = false, features = ["std"], optional = true } # music, sys_info

README.md

@@ -1,17 +1,15 @@
 # Ironbar
 
-Ironbar is a customisable and feature-rich bar targeting the Sway compositor, written in Rust. 
+Ironbar is a customisable and feature-rich bar for wlroots compositors, written in Rust.
 It uses GTK3 and gtk-layer-shell.
 
-The bar can be styled to your liking using CSS and hot-loads style changes. 
+The bar can be styled to your liking using CSS and hot-loads style changes.
 For information and examples on styling please see the [wiki](https://github.com/JakeStanger/ironbar/wiki).
 
-![Screenshot of fully configured bar with MPD widget open](https://user-images.githubusercontent.com/5057870/184539623-92d56a44-a659-49a9-91f9-5cdc453e5dfb.png)
+![Screenshot of fully configured bar with MPD widget open](https://f.jstanger.dev/github/ironbar/bar.png)
 
 ## Installation
 
-Run using `ironbar`.
-
 ### Cargo
 
 ```sh
@@ -26,6 +24,54 @@ cargo install ironbar
 yay -S ironbar-git
 ```
 
+[aur package](https://aur.archlinux.org/packages/ironbar-git)
+
+### Nix Flake
+
+A flake is included with the repo which can be used with home-manager.
+
+#### Example
+
+Here is an example nix flake that uses Ironbar.
+
+```nix
+{
+  # Add the ironbar flake input
+  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+  inputs.ironbar = {
+    url = "github:JakeStanger/ironbar";
+    inputs.nixpkgs.follows = "nixpkgs";
+  };
+  inputs.hm = {
+    url = "github:nix-community/home-manager";
+    inputs.nixpkgs.follows = "nixpkgs";
+  };
+
+  outputs = inputs: {
+    homeManagerConfigurations."USER@HOSTNAME" = inputs.hm.lib.homeManagerConfiguration {
+      pkgs = nixpkgs.legacyPackages.x86_64-linux;
+      modules = [
+        # And add the home-manager module
+        inputs.ironbar.homeManagerModules.default
+        {
+          # And configure
+          programs.ironbar = {
+            enable = true;
+            config = {};
+            style = "";
+          };
+        }
+      ];
+    };
+  };
+}
+```
+
+#### Binary Caching
+
+There is a Cachix cache available at `https://app.cachix.org/cache/jakestanger`
+in case you don't want to compile Ironbar.
+
 ### Source
 
 ```sh
@@ -36,33 +82,46 @@ cargo build --release
 install target/release/ironbar ~/.local/bin/ironbar
 ```
 
-[aur package](https://aur.archlinux.org/packages/ironbar-git)
+By default, all features are enabled. 
+See [here](https://github.com/JakeStanger/ironbar/wiki/compiling) for controlling which features are included.
+
+[repo](https://github.com/jakestanger/ironbar)
+
+## Running
+
+All of the above installation methods provide a binary called `ironbar`.
+
+You can set the `IRONBAR_LOG` or `IRONBAR_FILE_LOG` environment variables to 
+`error`, `warn`, `info`, `debug` or `trace` to configure the log output level.
+These default to `IRONBAR_LOG=info` and `IRONBAR_FILE_LOG=error`.
+File output can be found at `~/.local/share/ironbar/error.log`.
 
 ## Configuration
 
-Ironbar gives a lot of flexibility when configuring, including multiple file formats 
-and options for scaling complexity: you can use a single config across all monitors, 
-or configure different/multiple bars per monitor. 
+Ironbar gives a lot of flexibility when configuring, including multiple file formats
+and options for scaling complexity: you can use a single config across all monitors,
+or configure different/multiple bars per monitor.
 
 A full configuration guide can be found [here](https://github.com/JakeStanger/ironbar/wiki/configuration-guide).
 
 ## Styling
 
-To get started, create a stylesheet at `.config/ironbar/style.css`. Changes will be hot-reloaded every time you save the file.
+To get started, create a stylesheet at `.config/ironbar/style.css`. Changes will be hot-reloaded every time you save the
+file.
 
 A full styling guide can be found [here](https://github.com/JakeStanger/ironbar/wiki/styling-guide).
 
 ## Project Status
 
-This project is in alpha, but should be usable. 
-Everything that is implemented works and should be documented. 
+This project is in alpha, but should be usable.
+Everything that is implemented works and should be documented.
 Proper error handling is in place so things should either fail gracefully with detail, or not fail at all.
 
 There is currently room for lots more modules, and lots more configuration options for the existing modules.
 The current configuration schema is not set in stone and breaking changes could come along at any point;
 until the project matures I am more interested in ease of use than backwards compatibility.
 
-A few bugs do exist, and I am sure there are plenty more to be found. 
+A few bugs do exist, and I am sure there are plenty more to be found.
 
 The project will be *actively developed* as I am using it on my daily driver.
 Bugs will be fixed, features will be added, code will be refactored.
@@ -75,3 +134,4 @@ Please check [here](https://github.com/JakeStanger/ironbar/blob/master/CONTRIBUT
 
 - [Waybar](https://github.com/Alexays/Waybar) - A lot of the initial inspiration, and a pretty great bar.
 - [Rustbar](https://github.com/zeroeightysix/rustbar) - Served as a good demo for writing a basic GTK bar in Rust
+- [Smithay Client Toolkit](https://github.com/Smithay/client-toolkit) - Essential in being able to communicate to Wayland

docs/Compiling.md

@@ -0,0 +1,51 @@
+You can compile Ironbar from source using `cargo`. 
+Just clone the repo and build:
+
+```sh
+git clone https://github.com/jakestanger/ironbar.git
+cd ironbar
+cargo build --release
+# change path to wherever you want to install
+install target/release/ironbar ~/.local/bin/ironbar
+```
+
+## Features
+
+By default, all features are enabled for convenience. This can result in a significant compile time.
+If you know you are not going to need all the features, you can compile with only the features you need.
+
+As of `v0.10.0`, compiling with no features is about 33% faster. 
+On a 3800X, it takes about 60 seconds for no features and 90 seconds for all. 
+This difference is expected to increase as the bar develops. 
+
+Features containing a `+` can be stacked, for example `config+json` and `config+yaml` could both be enabled.
+
+To build using only specific features, disable default features and pass a comma separated list to `cargo build`:
+
+```shell
+cargo build --release --no-default-features \
+  --features http,config+json,clock
+```
+
+> ⚠ Make sure you enable at least one `config` feature otherwise you will not be able to start the bar!
+
+| Feature             | Description                                                                       |
+|---------------------|-----------------------------------------------------------------------------------|
+| **Core**            |                                                                                   |
+| http                | Enables HTTP features. Currently this includes the ability to load remote images. |
+| config+all          | Enables support for all configuration languages.                                  |
+| config+json         | Enables configuration support for JSON.                                           |
+| config+yaml         | Enables configuration support for YAML.                                           |
+| config+toml         | Enables configuration support for TOML.                                           |
+| config+corn         | Enables configuration support for [Corn](https://github.com/jakestanger.corn).    |
+| **Modules**         |                                                                                   |
+| clock               | Enables the `clock` module.                                                       |
+| music+all           | Enables the `music` module with support for all player types.                     |
+| music+mpris         | Enables the `music` module with MPRIS support.                                    |
+| music+mpd           | Enables the `music` module with MPD support.                                      |
+| sys_info            | Enables the `sys_info` module.                                                    |
+| tray                | Enables the `tray` module.                                                        |
+| workspaces+all      | Enables the `workspaces` module with support for all compositors.                 |
+| workspaces+sway     | Enables the `workspaces` module with support for Sway.                            |
+| workspaces+hyprland | Enables the `workspaces` module with support for Hyprland.                        |
+

docs/Configuration guide.md

@@ -0,0 +1,295 @@
+By default, you get a single bar at the bottom of all your screens.
+To change that, you'll unsurprisingly need a config file.
+
+This page details putting together the skeleton for your config to get you to a stage where you can start configuring
+modules.
+It may look long and overwhelming, but that is just because the bar supports a lot of scenarios!
+
+If you want to see some ready-to-go config files check
+the [examples folder](https://github.com/JakeStanger/ironbar/tree/master/examples)
+and the example pages in the sidebar.
+
+## 1. Create config file
+
+The config file lives inside the `ironbar` directory in your XDG_CONFIG_DIR, which is usually `~/.config/ironbar`.
+
+Ironbar supports a range of configuration formats, so you can pick your favourite:
+
+- `config.json`
+- `config.toml`
+- `config.yaml`
+- `config.corn` (Experimental, includes variable support for re-using blocks.
+  See [here](https://github.com/jakestanger/corn) for info)
+
+You can also override the default config path using the `IRONBAR_CONFIG` environment variable.
+
+## 2. Pick your use-case
+
+Ironbar gives you a few ways to configure the bar to suit your needs.
+This allows you to keep your config simple and relatively flat if your use-case is simple,
+and make it more complex if required.
+
+### a) I want the same bar across all monitors
+
+Place the bar config inside the top-level object. This is automatically applied to each of your monitors.
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "position": "bottom",
+  "height": 42,
+  "start": [],
+  "center": [],
+  "end": []
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+position = "bottom"
+height = 42
+start = []
+center = []
+end = []
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+position: "bottom"
+height: 42
+start: [ ]
+center: [ ]
+end: [ ]
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```
+{
+  position = "bottom"
+  height = 42
+  start = []
+  center = []
+  end = []
+}
+```
+
+</details>
+
+### b) I want my config to differ across one or more monitors
+
+Create a map/object called `monitors` inside the top-level object.
+Each of the map's keys should be an output name,
+and each value should be an object containing the bar config.
+
+To find your output names, run `wayland-info | grep wl_output -A1`.
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "monitors": {
+    "DP-1": {
+      "start": []
+    },
+    "DP-2": {
+      "position": "bottom",
+      "height": 30,
+      "start": []
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[monitors]
+
+[monitors.DP-1]
+start = []
+
+[monitors.DP-2]
+position = "bottom"
+height = 30
+start = []
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+monitors:
+  DP-1:
+    start: [ ]
+  DP-2:
+    position: "bottom"
+    height: 30
+    start: [ ]
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```
+{
+  monitors.DP-1.start = []
+  monitors.DP-2 = {
+    position = "bottom"
+    height = 30
+    start = []
+  }
+}
+```
+
+</details>
+
+### c) I want one or more monitors to have multiple bars
+
+Create a map/object called `monitors` inside the top-level object.
+Each of the map's keys should be an output name.
+If you want the screen to have multiple bars, use an array of bar config objects.
+If you want the screen to have a single bar, use an object.
+
+To find your output names, run `wayland-info | grep wl_output -A1`.
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "monitors": {
+    "DP-1": [
+      {
+        "start": []
+      },
+      {
+        "position": "top",
+        "start": []
+      }
+    ],
+    "DP-2": {
+      "position": "bottom",
+      "height": 30,
+      "start": []
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[monitors]
+
+[[monitors.DP-1]]
+start = []
+
+[[monitors.DP-2]]
+position = "top"
+start = []
+
+[monitors.DP-2]
+position = "bottom"
+height = 30
+start = []
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+monitors:
+  DP-1:
+    - start: [ ]
+    - position: "top"
+      start: [ ]
+  DP-2:
+    position: "bottom"
+    height: 30
+    start: [ ]
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  monitors.DP-1 = [
+    { start = [] }
+    { position = "top" start = [] }
+  ]
+  monitors.DP-2 = {
+    position = "bottom"
+    height = 30
+    start = []
+  }
+}
+```
+
+</details>
+
+## 3. Write your bar config(s)
+
+Once you have the basic config structure set up, it's time to actually configure your bar(s).
+
+Check [here](config) for an example config file for a fully configured bar in each format.
+
+### 3.1 Top-level options
+
+The following table lists each of the top-level bar config options:
+
+| 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.                                                             |
+| `icon_theme`      | `string`                               | `null`   | Name of the GTK icon theme to use. Leave blank to use default.                          |
+| `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
+
+The following table lists each of the module-level options that are present on **all** modules.
+For details on available modules and each of their config options, check the sidebar.
+
+For information on the `Script` type, and embedding scripts in strings, see [here](script).
+
+| Name              | Type               | Default | Description                                                                                                        |
+|-------------------|--------------------|---------|--------------------------------------------------------------------------------------------------------------------|
+| `show_if`         | `Script [polling]` | `null`  | Polls the script to check its exit code. If exit code is zero, the module is shown. For other codes, it is hidden. |
+| `on_click_left`   | `Script [oneshot]` | `null`  | Runs the script when the module is left clicked.                                                                   |
+| `on_click_middle` | `Script [oneshot]` | `null`  | Runs the script when the module is middle clicked.                                                                 |
+| `on_click_right`  | `Script [oneshot]` | `null`  | Runs the script when the module is right clicked.                                                                  |
+| `on_scroll_up`    | `Script [oneshot]` | `null`  | Runs the script when the module is scroll up on.                                                                   |
+| `on_scroll_down`  | `Script [oneshot]` | `null`  | Runs the script when the module is scrolled down on.                                                               |
+| `tooltip`         | `string`           | `null`  | Shows this text on hover. Supports embedding scripts between `{{double braces}}`.                                  |

docs/Home.md

@@ -0,0 +1,4 @@
+Welcome to the Ironbar wiki.
+
+Detail about each module, and their configuration and styling options can be found on the sidebar.
+You can also find an example configuration and stylesheet there.

docs/Images.md

@@ -0,0 +1,15 @@
+Ironbar is capable of loading images from multiple sources. 
+In any situation where an option takes text or an icon, 
+you can use a string in any of the following formats, and it will automatically be detected as an image:
+
+| Source                        | Example                         |
+|-------------------------------|---------------------------------|
+| GTK icon theme                | `icon:firefox`                  |
+| Local file                    | `file:///path/to/file.jpg`      |
+| Remote file (over HTTP/HTTPS) | `https://example.com/image.jpg` |
+
+Remote images are loaded asynchronously to avoid blocking the UI thread. 
+Be aware this can cause elements to change size upon load if the image is large enough.
+
+Note that mixing text and images is not supported. 
+Your best option here is to use Nerd Font icons instead.

docs/Scripts.md

@@ -0,0 +1,107 @@
+There are various places inside the configuration (other than the `script` module)
+that allow script input to dynamically set values.
+
+Scripts are passed to `sh -c`.
+
+Three types of scripts exist: polling, oneshot and watching:
+
+- **Polling** scripts will run and wait for exit.
+  Normally they will repeat this at an interval, hence the name, although in some cases they may only run on a user
+  event.
+  If the script exited code 0, the `stdout` will be used. Otherwise, `stderr` will be printed to the log.
+- **Oneshot** scripts are a variant of polling scripts. 
+  They wait for script to exit, and may do something with the output, but are only fired by user events instead of the interval.
+  Generally options that accept oneshot scripts do not support the other types.
+- **Watching** scripts start a long-running process. Every time the process writes to `stdout`, the last line is captured
+  and used.
+
+One should prefer to use watch-mode where possible, as it removes the overhead of regularly spawning processes.
+That said, there are some cases which only support polling. These are indicated by `Script [polling]` as the option
+type.
+
+## Writing script configs
+
+There are two available config formats for scripts, shorthand as a string, or longhand as an object.
+Shorthand can be used in all cases, but there are some cases (such as embedding scripts inside strings) where longhand
+cannot be used.
+
+In both formats, `mode` is one of `poll` or `watch` and `interval` is the number of milliseconds to wait between
+spawning the script.
+
+Both `mode` and `interval` are optional and can be excluded to fall back to their defaults of `poll` and `5000`
+respectively.
+
+For oneshot scripts, both the mode and interval are ignored.
+
+### Shorthand (string)
+
+Shorthand scripts should be written in the format:
+
+```
+mode:interval:script
+```
+
+For example:
+
+```
+poll:5000:uptime -p | cut -d ' ' -f2-
+```
+
+#### Embedding
+
+Some string config options support "embedding scripts". This allows you to mix static/dynamic content.
+An example of this is the common `tooltip` option.
+
+Scripts can be embedded in these cases using `{{double braces}}` and the shorthand syntax:
+
+```json
+"Up: {{30000:uptime -p | cut -d ' ' -f2-}}"
+```
+
+### Longhand (object)
+
+An object consisting of the `cmd` key and optionally the `mode` and/or `interval` keys.
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "mode": "poll",
+  "interval": 5000,
+  "cmd": "uptime -p | cut -d ' ' -f2-"
+}
+```
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+mode: poll
+interval: 5000
+cmd: "uptime -p | cut -d ' ' -f2-"
+```
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```toml
+mode = "poll"
+interval = 5000
+cmd = "uptime -p | cut -d ' ' -f2-"
+```
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  mode = "poll"
+  interval = 5000
+  cmd = "uptime -p | cut -d ' ' -f2-"
+}
+```
+</details>

docs/Styling guide.md

@@ -0,0 +1,20 @@
+Ironbar ships with no styles by default, so will fall back to the default GTK styles.
+
+To style the bar, create a file at `~/.config/ironbar/style.css`.
+
+Style changes are hot-loaded so there is no need to reload the bar.
+
+A reminder: since the bar is GTK-based, it uses GTK's implementation of CSS,
+which only includes a subset of the full web spec (plus a few non-standard properties).
+
+The below table describes the selectors provided by the bar itself.
+Information on styling individual modules can be found on their pages in the sidebar.
+
+| Selector       | Description                               |
+|----------------|-------------------------------------------|
+| `.background`  | Top-level window                          |
+| `#bar`         | Bar root box                              |
+| `#bar #start`  | Bar left or top modules container box     |
+| `#bar #center` | Bar center modules container box          |
+| `#bar #end`    | Bar right or bottom modules container box |
+| `.container`   | All of the above                          |

docs/_Sidebar.md

@@ -0,0 +1,28 @@
+# Guides
+
+- [Configuration guide](configuration-guide)
+  - [Scripts](scripts)
+  - [Images](images)
+- [Styling guide](styling-guide)
+- [Examples](https://github.com/JakeStanger/ironbar/tree/master/examples)
+
+# Examples
+
+- [Config](config)
+- [Stylesheet](https://github.com/JakeStanger/ironbar/blob/master/examples/style.css)
+
+## Custom
+
+- [Power Menu](power-menu)
+
+# Modules
+
+- [Clock](clock)
+- [Custom](custom)
+- [Focused](focused)
+- [Launcher](launcher)
+- [Music](music)
+- [Script](script)
+- [Sys_Info](sys-info)
+- [Tray](tray)
+- [Workspaces](workspaces)

docs/examples/Config.md

@@ -0,0 +1,10 @@
+The configs linked below show a module of each type being used.
+
+The Corn format makes heavy use of variables 
+to show how module configs can be easily referenced to improve readability 
+and reduce config length when using multiple bars.
+
+- [JSON](https://github.com/JakeStanger/ironbar/blob/master/examples/config.json)
+- [TOML](https://github.com/JakeStanger/ironbar/blob/master/examples/config.toml)
+- [YAML](https://github.com/JakeStanger/ironbar/blob/master/examples/config.yaml)
+- [Corn](https://github.com/JakeStanger/ironbar/blob/master/examples/config.corn)

docs/examples/custom/Power-Menu.md

@@ -0,0 +1,241 @@
+Creates a button on the bar, which opens a popup. The popup contains a header, shutdown button, restart button, and uptime.
+
+![A screenshot of the custom power menu module open, with some other modules present on the bar](https://f.jstanger.dev/github/ironbar/custom-power-menu.png)
+
+## Configuration
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "end": [
+    {
+      "type": "clock"
+    },
+    {
+      "bar": [
+        {
+          "label": "",
+          "name": "power-btn",
+          "on_click": "popup:toggle",
+          "type": "button"
+        }
+      ],
+      "class": "power-menu",
+      "popup": [
+        {
+          "orientation": "vertical",
+          "type": "box",
+          "widgets": [
+            {
+              "label": "Power menu",
+              "name": "header",
+              "type": "label"
+            },
+            {
+              "type": "box",
+              "widgets": [
+                {
+                  "class": "power-btn",
+                  "label": "<span font-size='40pt'></span>",
+                  "on_click": "!shutdown now",
+                  "type": "button"
+                },
+                {
+                  "class": "power-btn",
+                  "label": "<span font-size='40pt'></span>",
+                  "on_click": "!reboot",
+                  "type": "button"
+                }
+              ]
+            },
+            {
+              "label": "Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}",
+              "name": "uptime",
+              "type": "label"
+            }
+          ]
+        }
+      ],
+      "tooltip": "Up: {{30000:uptime -p | cut -d ' ' -f2-}}",
+      "type": "custom"
+    }
+  ]
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[end]]
+type = 'clock'
+
+[[end]]
+class = 'power-menu'
+tooltip = '''Up: {{30000:uptime -p | cut -d ' ' -f2-}}'''
+type = 'custom'
+
+[[end.bar]]
+label = ''
+name = 'power-btn'
+on_click = 'popup:toggle'
+type = 'button'
+
+[[end.popup]]
+orientation = 'vertical'
+type = 'box'
+
+[[end.popup.widgets]]
+label = 'Power menu'
+name = 'header'
+type = 'label'
+
+[[end.popup.widgets]]
+type = 'box'
+
+[[end.popup.widgets.widgets]]
+class = 'power-btn'
+label = '''<span font-size='40pt'></span>'''
+on_click = '!shutdown now'
+type = 'button'
+
+[[end.popup.widgets.widgets]]
+class = 'power-btn'
+label = '''<span font-size='40pt'></span>'''
+on_click = '!reboot'
+type = 'button'
+
+[[end.popup.widgets]]
+label = '''Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}'''
+name = 'uptime'
+type = 'label'
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+end:
+- type: clock
+
+- bar:
+  - label: 
+    name: power-btn
+    on_click: popup:toggle
+    type: button
+  class: power-menu
+  popup:
+  - orientation: vertical
+    type: box
+    widgets:
+    - label: Power menu
+      name: header
+      type: label
+    - type: box
+      widgets:
+      - class: power-btn
+        label: <span font-size='40pt'></span>
+        on_click: '!shutdown now'
+        type: button
+      - class: power-btn
+        label: <span font-size='40pt'></span>
+        on_click: '!reboot'
+        type: button
+    - label: 'Uptime: {{30000:uptime -p | cut -d '' '' -f2-}}'
+      name: uptime
+      type: label
+  tooltip: 'Up: {{30000:uptime -p | cut -d '' '' -f2-}}'
+  type: custom
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+let {
+    $button = { type = "button" name="power-btn" label = "" on_click = "popup:toggle" }
+
+    $popup = {
+        type = "box"
+        orientation = "vertical"
+        widgets = [
+            { type = "label" name = "header" label = "Power menu" }
+            {
+                type = "box"
+                widgets = [
+                    { type = "button" class="power-btn" label = "<span font-size='40pt'></span>" on_click = "!shutdown now" }
+                    { type = "button" class="power-btn" label = "<span font-size='40pt'></span>" on_click = "!reboot" }
+                ]
+            }
+            { type = "label" name = "uptime" label = "Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}" }
+        ]
+    }
+
+    $power_menu = {
+        type = "custom"
+        class = "power-menu"
+
+        bar = [ $button ]
+        popup = [ $popup ]
+
+        tooltip = "Up: {{30000:uptime -p | cut -d ' ' -f2-}}"
+    }
+    
+    $clock = { type = "clock" }
+} in {
+    end = [ $power_menu $clock ]
+}
+```
+</details>
+
+## Styling
+
+```css
+.power-menu {
+    margin-left: 10px;
+}
+
+.power-menu #power-btn {
+    color: white;
+    background-color: #2d2d2d;
+}
+
+.power-menu #power-btn:hover {
+    background-color: #1c1c1c;
+}
+
+.popup-power-menu {
+    padding: 1em;
+}
+
+.popup-power-menu #header {
+    color: white;
+    font-size: 1.4em;
+    border-bottom: 1px solid white;
+    padding-bottom: 0.4em;
+    margin-bottom: 0.8em;
+}
+
+.popup-power-menu .power-btn {
+    color: white;
+    background-color: #2d2d2d;
+    border: 1px solid white;
+    padding: 0.6em 1em;
+}
+
+.popup-power-menu .power-btn + .power-btn {
+    margin-left: 1em;
+}
+
+.popup-power-menu .power-btn:hover {
+    background-color: #1c1c1c;
+}
+```

docs/modules/Clock.md

@@ -0,0 +1,77 @@
+Displays the current date and time. 
+Clicking on the widget opens a popup with the time and a calendar.
+
+![Screenshot of clock widget with popup open](https://user-images.githubusercontent.com/5057870/184540521-2278bdec-9742-46f0-9ac2-58a7b6f6ea1d.png)
+
+
+## Configuration
+
+> Type: `clock`
+
+| 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>
+
+```json
+{
+  "end": [
+    {
+      "type": "clock",
+      "format": "%d/%m/%Y %H:%M"
+    }
+  ]
+}
+
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[end]]
+type = "clock"
+format = "%d/%m/%Y %H:%M"
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+end:
+  - type: "clock"
+    format: "%d/%m/%Y %H:%M"
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  end = [
+    {
+      type = "clock"
+      format = "%d/%m/%Y %H:%M"
+    }
+  ]
+}
+```
+
+</details>
+
+## Styling
+
+| Selector                      | Description                                                                        |
+|-------------------------------|------------------------------------------------------------------------------------|
+| `#clock`                      | Clock widget button                                                                |
+| `#popup-clock`                | Clock popup box                                                                    |
+| `#popup-clock #calendar-clock` | Clock inside the popup                                                             |
+| `#popup-clock #calendar`       | Calendar widget inside the popup. GTK provides some OOTB styling options for this. |

docs/modules/Custom.md

@@ -0,0 +1,276 @@
+Allows you to compose custom modules consisting of multiple widgets, including popups. 
+Labels can display dynamic content from scripts, and buttons can interact with the bar or execute commands on click.
+
+![Custom module with a button on the bar, and the popup open. The popup contains a header, shutdown button and restart button.](https://f.jstanger.dev/github/ironbar/custom-power-menu.png)
+
+## Configuration
+
+> Type: `custom`
+
+This module can be quite fiddly to configure as you effectively have to build a tree of widgets by hand.
+It is well worth looking at the examples.
+
+| Name    | Type       | Default | Description                          |
+|---------|------------|---------|--------------------------------------|
+| `class` | `string`   | `null`  | Container class name.                |
+| `bar`   | `Widget[]` | `null`  | List of widgets to add to the bar.   |
+| `popup` | `Widget[]` | `[]`    | List of widgets to add to the popup. |
+
+### `Widget`
+
+| Name          | Type                                    | Default      | Description                                                               |
+|---------------|-----------------------------------------|--------------|---------------------------------------------------------------------------|
+| `widget_type` | `box` or `label` or `button` or `image` | `null`       | Type of GTK widget to create.                                             |
+| `name`        | `string`                                | `null`       | Widget name.                                                              |
+| `class`       | `string`                                | `null`       | Widget class name.                                                        |
+| `label`       | `string`                                | `null`       | [`label` and `button`] Widget text label. Pango markup supported.         |
+| `on_click`    | `string`                                | `null`       | [`button`] Command to execute. More on this [below](#commands).           |
+| `src`         | `image`                                 | `null`       | [`image`] Image source. See [here](images) for information on images.     |
+| `size`        | `integer`                               | `null`       | [`image`] Width/height of the image. Aspect ratio is preserved.           |
+| `orientation` | `horizontal` or `vertical`              | `horizontal` | [`box`] Whether child widgets should be horizontally or vertically added. |
+| `widgets`     | `Widget[]`                              | `[]`         | [`box`] List of widgets to add to this box.                               |
+
+### Labels
+
+Labels can interpolate text from scripts to dynamically show content. 
+This can be done by including scripts in `{{double braces}}` using the shorthand script syntax.
+
+For example, the following label would output your system uptime, updated every 30 seconds.
+
+```
+Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}
+```
+
+Both polling and watching mode are supported. For more information on script syntax, see [here](script).
+
+### Commands
+
+Buttons can execute commands that interact with the bar, 
+as well as any arbitrary shell command.
+
+To execute shell commands, prefix them with an `!`. 
+For example, if you want to run `~/.local/bin/my-script.sh` on click, 
+you'd set `on_click` to `!~/.local/bin/my-script.sh`.
+
+The following bar commands are supported:
+
+- `popup:toggle`
+- `popup:open`
+- `popup:close`
+
+---
+
+XML is arguably better-suited and easier to read for this sort of markup, 
+but currently is not supported.
+Nonetheless, it may be worth comparing the examples to the below equivalent
+to help get your head around what's going on:
+
+
+```xml
+<?xml version="1.0" encoding="utf-8" ?>
+<custom class="power-menu">
+    <bar>
+        <button name="power-btn" label="" on_click="popup:toggle"/>
+    </bar>
+    <popup>
+        <box orientation="vertical">
+            <label name="header" label="Power menu" />
+            <box>
+                <button class="power-btn" label="" on_click="!shutdown now" />
+                <button class="power-btn" label="" on_click="!reboot" />
+            </box>
+            <label name="uptime" label="Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}" />
+        </box>
+    </popup>
+</custom>
+```
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "end": [
+    {
+      "type": "clock"
+    },
+    {
+      "bar": [
+        {
+          "on_click": "popup:toggle",
+          "label": "",
+          "name": "power-btn",
+          "type": "button"
+        }
+      ],
+      "class": "power-menu",
+      "popup": [
+        {
+          "orientation": "vertical",
+          "type": "box",
+          "widgets": [
+            {
+              "label": "Power menu",
+              "name": "header",
+              "type": "label"
+            },
+            {
+              "type": "box",
+              "widgets": [
+                {
+                  "class": "power-btn",
+                  "on_click": "!shutdown now",
+                  "label": "<span font-size='40pt'></span>",
+                  "type": "button"
+                },
+                {
+                  "class": "power-btn",
+                  "on_click": "!reboot",
+                  "label": "<span font-size='40pt'></span>",
+                  "type": "button"
+                }
+              ]
+            },
+            {
+              "label": "Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}",
+              "name": "uptime",
+              "type": "label"
+            }
+          ]
+        }
+      ],
+      "type": "custom"
+    }
+  ]
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[end]]
+type = 'clock'
+
+[[end]]
+class = 'power-menu'
+type = 'custom'
+
+[[end.bar]]
+on_click = 'popup:toggle'
+label = ''
+name = 'power-btn'
+type = 'button'
+
+[[end.popup]]
+orientation = 'vertical'
+type = 'box'
+
+[[end.popup.widgets]]
+label = 'Power menu'
+name = 'header'
+type = 'label'
+
+[[end.popup.widgets]]
+type = 'box'
+
+[[end.popup.widgets.widgets]]
+class = 'power-btn'
+on_click = '!shutdown now'
+label = '''<span font-size='40pt'></span>'''
+type = 'button'
+
+[[end.popup.widgets.widgets]]
+class = 'power-btn'
+on_click = '!reboot'
+label = '''<span font-size='40pt'></span>'''
+type = 'button'
+
+[[end.popup.widgets]]
+label = '''Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}'''
+name = 'uptime'
+type = 'label'
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+end:
+- type: clock
+- bar:
+  - on_click: popup:toggle
+    label: 
+    name: power-btn
+    type: button
+  class: power-menu
+  popup:
+  - orientation: vertical
+    type: box
+    widgets:
+    - label: Power menu
+      name: header
+      type: label
+    - type: box
+      widgets:
+      - class: power-btn
+        on_click: '!shutdown now'
+        label: <span font-size='40pt'></span>
+        type: button
+      - class: power-btn
+        on_click: '!reboot'
+        label: <span font-size='40pt'></span>
+        type: button
+    - label: 'Uptime: {{30000:uptime -p | cut -d '' '' -f2-}}'
+      name: uptime
+      type: label
+  type: custom
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+let {
+    $power_menu = {
+        type = "custom"
+        class = "power-menu"
+
+        bar = [ { type = "button" name="power-btn" label = "" on_click = "popup:toggle" } ]
+
+        popup = [ {
+            type = "box"
+            orientation = "vertical"
+            widgets = [
+                { type = "label" name = "header" label = "Power menu" }
+                {
+                    type = "box"
+                    widgets = [
+                        { type = "button" class="power-btn" label = "<span font-size='40pt'></span>" on_click = "!shutdown now" }
+                        { type = "button" class="power-btn" label = "<span font-size='40pt'></span>" on_click = "!reboot" }
+                    ]
+                }
+                { type = "label" name = "uptime" label = "Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}" }
+            ]
+        } ]
+    }
+} in {
+    end = [ $power_menu ]
+}
+```
+
+</details>
+
+## Styling
+
+Since the widgets are all custom, you can target them using `#name` and `.class`.
+
+| Selector  | Description             |
+|-----------|-------------------------|
+| `#custom` | Custom widget container |

docs/modules/Focused.md

@@ -0,0 +1,92 @@
+Displays the title and/or icon of the currently focused window.
+
+![Screenshot of focused widget, showing this page open on firefox](https://user-images.githubusercontent.com/5057870/184714118-c1fb1c67-cd8c-4cc0-b5cd-6faccff818ac.png)
+
+
+## Configuration
+
+> Type: `focused`
+
+| Name              | Type                                  | Default | Description                                                                                                                                           |
+|-------------------|---------------------------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `show_icon`       | `boolean`                             | `true`  | Whether to show the app's icon                                                                                                                        |
+| `show_title`      | `boolean`                             | `true`  | Whether to show the app's title                                                                                                                       |
+| `icon_size`       | `integer`                             | `32`    | Size of icon in pixels                                                                                                                                |
+| `truncate`        | `start` or `middle` or `end` or `Map` | `null`  | The location of the ellipses and where to truncate text from. Leave null to avoid truncating. Use the long-hand `Map` version if specifying a length. |
+| `truncate.mode`   | `start` or `middle` or `end`          | `null`  | The location of the ellipses and where to truncate text from. Leave null to avoid truncating.                                                         |
+| `truncate.length` | `integer`                             | `null`  | The maximum number of characters before truncating. Leave blank to let GTK automatically handle.                                                      |
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "end": [
+    {
+      "type": "focused",
+      "show_icon": true,
+      "show_title": true,
+      "icon_size": 32,
+      "truncate": "end"
+    }
+  ]
+}
+
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[end]]
+type = "focused"
+show_icon = true
+show_title = true
+icon_size = 32
+truncate = "end"
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+end:
+  - type: "focused"
+    show_icon: true
+    show_title: true
+    icon_size: 32
+    truncate: "end"
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  end = [
+    {
+      type = "focused"
+      show_icon = true
+      show_title = true
+      icon_size = 32
+      truncate = "end"
+    }
+  ]
+}
+```
+
+</details>
+
+## Styling
+
+| Selector                 | Description        |
+|--------------------------|--------------------|
+| `#focused`               | Focused widget box |
+| `#focused #icon`         | App icon           |
+| `#focused #label`        | App name           |

docs/modules/Launcher.md

@@ -0,0 +1,98 @@
+Windows-style taskbar that displays running windows, grouped by program.
+Hovering over a program with multiple windows open shows a popup with each window.
+Clicking an icon/popup item focuses or launches the program.
+Optionally displays a launchable set of favourites.
+
+![Screenshot showing several open applications, including a popup showing multiple terminal windows.](https://f.jstanger.dev/github/ironbar/launcher.png)
+
+## Configuration
+
+> Type: `launcher`
+
+|              | Type       | Default | Description                                                                                         |
+|--------------|------------|---------|-----------------------------------------------------------------------------------------------------|
+| `favorites`  | `string[]` | `[]`    | List of app IDs (or classes) to always show at the start of the launcher                            |
+| `show_names` | `boolean`  | `false` | Whether to show app names on the button label. Names will still show on tooltips when set to false. |
+| `show_icons` | `boolean`  | `true`  | Whether to show app icons on the button.                                                            |
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "start": [
+    {
+      "type": "launcher",
+      "favourites": [
+        "firefox",
+        "discord"
+      ],
+      "show_names": false,
+      "show_icons": true
+    }
+  ]
+}
+
+
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[start]]
+type = "launcher"
+favorites = ["firefox", "discord"]
+show_names = false
+show_icons = true
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+start:
+  - type: "launcher"
+    favorites:
+      - firefox
+      - discord
+    show_names: false
+    show_icons: true
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  start = [
+    {
+      type = "launcher"
+      favorites = [ "firefox" "discord" ]
+      show_names = false
+      show_icons = true
+
+    }
+  ]
+}
+```
+
+</details>
+
+## Styling
+
+| Selector                      | Description              |
+|-------------------------------|--------------------------|
+| `#launcher`                   | Launcher widget box      |
+| `#launcher .item`             | App button               |
+| `#launcher .item.open`        | App button (open app)    |
+| `#launcher .item.focused`     | App button (focused app) |
+| `#launcher .item.urgent`      | App button (urgent app)  |
+| `#launcher-popup`             | Popup container          |
+| `#launcher-popup .popup-item` | Window button in popup   |

docs/modules/Music.md

@@ -0,0 +1,153 @@
+Displays currently playing song from your music player.
+This module supports both MPRIS players and MPD servers.
+Clicking on the widget opens a popout displaying info about the current song, album art
+and playback controls.
+
+in MPRIS mode, the widget will listen to all players and automatically detect/display the active one.
+
+![Screenshot showing MPD widget with track playing with popout open](https://f.jstanger.dev/github/ironbar/music.png)
+
+## Configuration
+
+> Type: `music`
+
+|                   | Type                                  | Default                     | Description                                                                                                                                           |
+|-------------------|---------------------------------------|-----------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `player_type`     | `mpris` or `mpd`                      | `mpris`                     | Whether to connect to MPRIS players or an MPD server.                                                                                                 |
+| `format`          | `string`                              | `{icon} {title} / {artist}` | Format string for the widget. More info below.                                                                                                        |
+| `truncate`        | `start` or `middle` or `end` or `Map` | `null`                      | The location of the ellipses and where to truncate text from. Leave null to avoid truncating. Use the long-hand `Map` version if specifying a length. |
+| `truncate.mode`   | `start` or `middle` or `end`          | `null`                      | The location of the ellipses and where to truncate text from. Leave null to avoid truncating.                                                         |
+| `truncate.length` | `integer`                             | `null`                      | The maximum number of characters before truncating. Leave blank to let GTK automatically handle.                                                      |
+| `icons.play`      | `string/image`                        | ``                         | Icon to show when playing.                                                                                                                            |
+| `icons.pause`     | `string/image`                        | ``                         | Icon to show when paused.                                                                                                                             |
+| `icons.prev`      | `string/image`                        | `玲`                         | Icon to show on previous button.                                                                                                                      |
+| `icons.next`      | `string/image`                        | `怜`                         | Icon to show on next button.                                                                                                                          |
+| `icons.volume`    | `string/image`                        | `墳`                         | Icon to show under popup volume slider.                                                                                                               |
+| `icons.track`     | `string/image`                        | ``                         | Icon to show next to track title.                                                                                                                     |
+| `icons.album`     | `string/image`                        | ``                         | Icon to show next to album name.                                                                                                                      |
+| `icons.artist`    | `string/image`                        | `ﴁ`                         | Icon to show next to artist name.                                                                                                                     |
+| `host`            | `string/image`                        | `localhost:6600`            | [MPD Only] TCP or Unix socket for the MPD server.                                                                                                     |
+| `music_dir`       | `string/image`                        | `$HOME/Music`               | [MPD Only] Path to MPD server's music directory on disc. Required for album art.                                                                      |
+
+See [here](images) for information on images.
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "start": [
+    {
+      "type": "music",
+      "player_type": "mpd",
+      "format": "{title} / {artist}",
+      "truncate": "end",
+      "icons": {
+        "play": "",
+        "pause": ""
+      },
+      "music_dir": "/home/jake/Music"
+    }
+  ]
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[start]]
+type = "music"
+player_type = "mpd"
+format = "{title} / {artist}"
+music_dir = "/home/jake/Music"
+truncate = "end"
+
+[[start.icons]]
+play = ""
+pause = ""
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+start:
+  - type: "music"
+    player_type: "mpd"
+    format: "{title} / {artist}"
+    truncate: "end"
+    icons:
+      play: ""
+      pause: ""
+    music_dir: "/home/jake/Music"
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  start = [
+    {
+      type = "music"
+      player_type = "mpd"
+      format = "{title} / {artist}"
+      truncate = "end"
+      icons.play = ""
+      icons.pause = ""
+      music_dir = "/home/jake/Music"
+    }
+  ]
+}
+```
+
+</details>
+
+### Formatting Tokens
+
+The following tokens can be used in the `format` config option,
+and will be replaced with values from the currently playing track:
+
+| Token        | Description                          |
+|--------------|--------------------------------------|
+| `{title}`    | Title                                |
+| `{album}`    | Album name                           |
+| `{artist}`   | Artist name                          |
+| `{date}`     | Release date                         |
+| `{track}`    | Track number                         |
+| `{disc}`     | Disc number                          |
+| `{genre}`    | Genre                                |
+| `{duration}` | Duration in `mm:ss`                  |
+| `{elapsed}`  | Time elapsed in `mm:ss`              |
+
+## Styling
+
+| Selector                            | Description                              |
+|-------------------------------------|------------------------------------------|
+| `#music`                            | Tray widget button                       |
+| `#popup-music`                      | Popup box                                |
+| `#popup-music #album-art`           | Album art image inside popup box         |
+| `#popup-music #title`               | Track title container inside popup box   |
+| `#popup-music #title .icon`         | Track title icon label inside popup box  |
+| `#popup-music #title .label`        | Track title label inside popup box       |
+| `#popup-music #album`               | Track album container inside popup box   |
+| `#popup-music #album .icon`         | Track album icon label inside popup box  |
+| `#popup-music #album .label`        | Track album label inside popup box       |
+| `#popup-music #artist`              | Track artist container inside popup box  |
+| `#popup-music #artist .icon`        | Track artist icon label inside popup box |
+| `#popup-music #artist .label`       | Track artist label inside popup box      |
+| `#popup-music #controls`            | Controls container inside popup box      |
+| `#popup-music #controls #btn-prev`  | Previous button inside popup box         |
+| `#popup-music #controls #btn-play`  | Play button inside popup box             |
+| `#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`      | Volume slider popup box                  |
+| `#popup-music #volume .icon`        | Volume icon label inside popup box       |

docs/modules/Script.md

@@ -0,0 +1,87 @@
+Executes a script and shows the result of `stdout` on a label.
+Pango markup is supported.
+
+## Configuration
+
+> Type: `script`
+
+| Name       | Type                  | Default | Description                                             |
+|------------|-----------------------|---------|---------------------------------------------------------|
+| `cmd`      | `string`              | `null`  | Path to the script on disk                              |
+| `mode`     | `'poll'` or `'watch'` | `poll`  | See [#modes](#modes)                                    |
+| `interval` | `number`              | `5000`  | Number of milliseconds to wait between executing script |
+
+### Modes
+
+- Use `poll` to run the script wait for it to exit. On exit, the label is updated to show everything the script wrote to `stdout`.
+- Use `watch` to start a long-running script. Every time the script writes to `stdout`, the label is updated to show the latest line.
+    Note this does not work for all programs as they may use block-buffering instead of line-buffering when they detect output being piped. 
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "end": [
+    {
+      "type": "script",
+      "cmd": "/home/jake/.local/bin/phone-battery",
+      "mode": "poll",
+      "interval": 5000
+    }
+  ]
+}
+
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[end]]
+type = "script"
+cmd = "/home/jake/.local/bin/phone-battery"
+mode = "poll"
+interval = 5000
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+end:
+  - type: "script"
+    cmd: "/home/jake/.local/bin/phone-battery"
+    mode: 'poll'
+    interval : 5000
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  end = [
+    {
+      type = "script"
+      cmd = "/home/jake/.local/bin/phone-battery"
+      mode = "poll"
+      interval = 5000
+    }
+  ]
+}
+```
+
+</details>
+
+## Styling
+
+| Selector      | Description         |
+|---------------|---------------------|
+| `#script`     | Script widget label |

docs/modules/Sys-Info.md

@@ -0,0 +1,176 @@
+Displays one or more labels containing system information. 
+
+Separating information across several labels allows for styling each one independently. 
+Pango markup is supported.
+
+![Screenshot showing sys-info module with widgets for all of the types of formatting tokens](https://user-images.githubusercontent.com/5057870/196059090-4056d083-69f0-4e6f-9673-9e35dc29d9f0.png)
+
+
+## Configuration
+
+> Type: `sys_info`
+
+| Name               | Type               | Default | Description                                                                                                                    |
+|--------------------|--------------------|---------|--------------------------------------------------------------------------------------------------------------------------------|
+| `format`           | `string[]`         | `null`  | Array of strings including formatting tokens. For available tokens see below.                                                  |
+| `interval`         | `integer` or `Map` | `5`     | Seconds between refreshing. Can be a single value for all data or a map of individual refresh values for different data types. |
+| `interval.memory`  | `integer`          | `5`     | Seconds between refreshing memory data                                                                                         |
+| `interval.cpu`     | `integer`          | `5`     | Seconds between refreshing cpu data                                                                                            |
+| `interval.temps`   | `integer`          | `5`     | Seconds between refreshing temperature data                                                                                    |
+| `interval.disks`   | `integer`          | `5`     | Seconds between refreshing disk data                                                                                           |
+| `interval.network` | `integer`          | `5`     | Seconds between refreshing network data                                                                                        |
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "end": [
+    {
+      "format": [
+        " {cpu_percent}% | {temp_c:k10temp_Tccd1}°C",
+        " {memory_used} / {memory_total} GB ({memory_percent}%)",
+        "| {swap_used} / {swap_total} GB ({swap_percent}%)",
+        " {disk_used:/} / {disk_total:/} GB ({disk_percent:/}%)",
+        "李 {net_down:enp39s0} / {net_up:enp39s0} Mbps",
+        "猪 {load_average:1} | {load_average:5} | {load_average:15}",
+        " {uptime}"
+      ],
+      "interval": {
+        "cpu": 1,
+        "disks": 300,
+        "memory": 30,
+        "networks": 3,
+        "temps": 5
+      },
+      "type": "sys_info"
+    }
+  ]
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[end]]
+type = 'sys_info'
+format = [
+    ' {cpu_percent}% | {temp_c:k10temp_Tccd1}°C',
+    ' {memory_used} / {memory_total} GB ({memory_percent}%)',
+    '| {swap_used} / {swap_total} GB ({swap_percent}%)',
+    ' {disk_used:/} / {disk_total:/} GB ({disk_percent:/}%)',
+    '李 {net_down:enp39s0} / {net_up:enp39s0} Mbps',
+    '猪 {load_average:1} | {load_average:5} | {load_average:15}',
+    ' {uptime}',
+]
+
+[end.interval]
+cpu = 1
+disks = 300
+memory = 30
+networks = 3
+temps = 5
+
+
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+end:
+- format:
+  - ' {cpu_percent}% | {temp_c:k10temp_Tccd1}°C'
+  - ' {memory_used} / {memory_total} GB ({memory_percent}%)'
+  - '| {swap_used} / {swap_total} GB ({swap_percent}%)'
+  - ' {disk_used:/} / {disk_total:/} GB ({disk_percent:/}%)'
+  - '李 {net_down:enp39s0} / {net_up:enp39s0} Mbps'
+  - '猪 {load_average:1} | {load_average:5} | {load_average:15}'
+  - ' {uptime}'
+  interval:
+    cpu: 1
+    disks: 300
+    memory: 30
+    networks: 3
+    temps: 5
+  type: sys_info
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  end = [
+    {
+      type = "sys_info"
+
+      interval.memory = 30
+      interval.cpu = 1
+      interval.temps = 5
+      interval.disks = 300
+      interval.networks = 3
+
+      format = [
+        " {cpu_percent}% | {temp_c:k10temp_Tccd1}°C"
+        " {memory_used} / {memory_total} GB ({memory_percent}%)"
+        "| {swap_used} / {swap_total} GB ({swap_percent}%)"
+        " {disk_used:/} / {disk_total:/} GB ({disk_percent:/}%)"
+        "李 {net_down:enp39s0} / {net_up:enp39s0} Mbps"
+        "猪 {load_average:1} | {load_average:5} | {load_average:15}"
+        " {uptime}"
+      ]
+    }
+  ]
+}
+```
+
+</details>
+
+### Formatting Tokens
+
+The following tokens can be used in the `format` configuration option:
+
+| Token                    | Description                                                                        |
+|--------------------------|------------------------------------------------------------------------------------|
+| **CPU**                  |                                                                                    |
+| `{cpu_percent}`          | Total CPU utilisation percentage                                                   |
+| **Memory**               |                                                                                    |
+| `{memory_free}`          | Memory free in GB.                                                                 |
+| `{memory_used}`          | Memory used in GB.                                                                 |
+| `{memory_total}`         | Memory total in GB.                                                                |
+| `{memory_percent}`       | Memory utilisation percentage.                                                     |
+| `{swap_free}`            | Swap free in GB.                                                                   |
+| `{swap_used}`            | Swap used in GB.                                                                   |
+| `{swap_total}`           | Swap total in GB.                                                                  |
+| `{swap_percent}`         | Swap utilisation percentage.                                                       |
+| **Temperature**          |                                                                                    |
+| `{temp_c:[sensor]}`      | Temperature in degrees C. Replace `[sensor]` with the sensor label.                |
+| `{temp_f:[sensor]}`      | Temperature in degrees F. Replace `[sensor]` with the sensor label.                |
+| **Disk**                 |                                                                                    |
+| `{disk_free:[mount]}`    | Disk free space in GB. Replace `[mount]` with the disk mountpoint.                 |
+| `{disk_used:[mount]}`    | Disk used space in GB. Replace `[mount]` with the disk mountpoint.                 |
+| `{disk_total:[mount]}`   | Disk total space in GB. Replace `[mount]` with the disk mountpoint.                |
+| `{disk_percent:[mount]}` | Disk utilisation percentage. Replace `[mount]` with the disk mountpoint.           |
+| **Network**              |                                                                                    |
+| `{net_down:[adapter]}`   | Average network download speed in Mbps. Replace `[adapter]` with the adapter name. |
+| `{net_up:[adapter]}`     | Average network upload speed in Mbps. Replace `[adapter]` with the adapter name.   |
+| **System**               |                                                                                    |
+| `{load_average:1}`       | 1-minute load average.                                                             |
+| `{load_average:5}`       | 5-minute load average.                                                             |
+| `{load_average:15}`      | 15-minute load average.                                                            |
+| `{uptime}`               | System uptime formatted as `HH:mm`.                                                |
+
+## Styling
+
+| Selector         | Description                  |
+|------------------|------------------------------|
+| `#sysinfo`       | Sysinfo widget box           |
+| `#sysinfo #item` | Individual information label |

docs/modules/Tray.md

@@ -0,0 +1,64 @@
+Displays a fully interactive icon tray using the KDE `libappindicator` protocol. 
+
+![Screenshot showing icon tray widget](https://user-images.githubusercontent.com/5057870/184540135-78ffd79d-f802-4c79-b09a-05a733dadc55.png)
+
+## Configuration
+
+> Type: `tray`
+
+***This module provides no configuration options.***
+
+<details>
+<summary>JSON</summary>
+
+```json
+{
+  "end": [
+    {
+      "type": "tray"
+    }
+  ]
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[end]]
+type = "tray"
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+end:
+  - type: "tray"
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+  end = [
+    { type = "tray" }
+  ]
+}
+```
+
+</details>
+
+## Styling
+
+| Selector      | Description      |
+|---------------|------------------|
+| `#tray`       | Tray widget box  |
+| `#tray .item` | Tray icon button |

docs/modules/Workspaces.md

@@ -0,0 +1,95 @@
+> ⚠ **This module is currently only supported on Sway and Hyprland**
+
+Shows all current workspaces. Clicking a workspace changes focus to it.
+
+![Screenshot showing workspaces widget using custom icons with browser workspace focused](https://user-images.githubusercontent.com/5057870/184540156-26cfe4ec-ab8d-4e0f-a883-8b641025366b.png)
+
+## Configuration
+
+> Type: `workspaces`
+
+| Name           | Type                        | Default        | Description                                                                                                                                                               |
+|----------------|-----------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `name_map`     | `Map<string, string/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. |
+| `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>
+
+```json
+{
+  "end": [
+    {
+      "type": "workspaces",
+      "name_map": {
+        "1": "",
+        "2": "",
+        "3": ""
+      },
+      "all_monitors": false
+    }
+  ]
+}
+```
+
+</details>
+
+<details>
+<summary>TOML</summary>
+
+```toml
+[[end]]
+type = "workspaces"
+all_monitors = false
+
+[[end.name_map]]
+1 = ""
+2 = ""
+3 = ""
+
+```
+
+</details>
+
+<details>
+<summary>YAML</summary>
+
+```yaml
+end:
+  - type: "workspaces"
+    name_map:
+      1: ""
+      2: ""
+      3: ""
+    all_monitors: false
+```
+
+</details>
+
+<details>
+<summary>Corn</summary>
+
+```corn
+{
+    end = [
+        {
+            type = "workspaces",
+            name_map.1 = ""
+            name_map.2 = ""
+            name_map.3 = ""
+            all_monitors = false
+        }
+    ]
+}
+```
+
+</details>
+
+## Styling
+
+| Selector                    | Description                          |
+|-----------------------------|--------------------------------------|
+| `#workspaces`               | Workspaces widget box                |
+| `#workspaces .item`         | Workspace button                     |
+| `#workspaces .item.focused` | Workspace button (workspace focused) |

examples/config.corn

@@ -4,40 +4,92 @@ let {
         all_monitors = false
         name_map = {
             1 = "ﭮ"
-            2 = ""
+            2 = "icon:firefox"
             3 = ""
-            Games = ""
+            Games = "icon:steam"
             Code = ""
         }
     }
 
+    $focused = { type = "focused" }
+
     $launcher = {
         type = "launcher"
         favorites = ["firefox" "discord" "Steam"]
         show_names = false
         show_icons = true
-        icon_theme = "Paper"
     }
 
     $mpd_local = { type = "mpd" music_dir = "/home/jake/Music" }
     $mpd_server = { type = "mpd" host = "chloe:6600" }
 
     $sys_info = {
-        type = "sys-info"
-        format = ["{cpu-percent}% " "{memory-percent}% "]
+        type = "sys_info"
+
+        interval.memory = 30
+        interval.cpu = 1
+        interval.temps = 5
+        interval.disks = 300
+        interval.networks = 3
+
+        format = [
+            " {cpu_percent}% | {temp_c:k10temp_Tccd1}°C"
+            " {memory_used} / {memory_total} GB ({memory_percent}%)"
+            "| {swap_used} / {swap_total} GB ({swap_percent}%)"
+            " {disk_used:/} / {disk_total:/} GB ({disk_percent:/}%)"
+            "李 {net_down:enp39s0} / {net_up:enp39s0} Mbps"
+            "猪 {load_average:1} | {load_average:5} | {load_average:15}"
+            " {uptime}"
+        ]
     }
 
     $tray = { type = "tray" }
+
     $clock = { type = "clock" }
 
     $phone_battery = {
         type = "script"
-        path = "/home/jake/bin/phone-battery"
+        cmd = "/home/jake/bin/phone-battery"
+
+        show_if.cmd = "/home/jake/bin/phone-connected"
+        show_if.interval = 500
     }
 
+    // -- begin custom --
+    $button = { type = "button" name="power-btn" label = "" on_click = "popup:toggle" }
+
+    $popup = {
+        type = "box"
+        orientation = "vertical"
+        widgets = [
+            { type = "label" name = "header" label = "Power menu" }
+            {
+                type = "box"
+                widgets = [
+                    { type = "button" class="power-btn" label = "<span font-size='40pt'></span>" on_click = "!shutdown now" }
+                    { type = "button" class="power-btn" label = "<span font-size='40pt'></span>" on_click = "!reboot" }
+                ]
+            }
+            { type = "label" name = "uptime" label = "Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}" }
+        ]
+    }
+
+    $power_menu = {
+        type = "custom"
+        class = "power-menu"
+
+        bar = [ $button ]
+        popup = [ $popup ]
+
+        tooltip = "Up: {{30000:uptime -p | cut -d ' ' -f2-}}"
+    }
+    // -- end custom --
+
     $left = [ $workspaces $launcher ]
-    $right = [ $mpd_local $mpd_server $phone_battery $sys_info $clock ]
+    $right = [ $mpd_local $mpd_server $phone_battery $sys_info $power_menu $clock ]
 }
 in {
-    left = $left right = $right
+    anchor_to_edges = true
+    position = "top"
+    start = $left end = $right
 }

examples/config.json

@@ -1,18 +1,133 @@
 {
-  "monitors": {
-    "DP-1": [
-      {
-        "left": [{"type":  "clock"}]
+  "anchor_to_edges": true,
+  "end": [
+    {
+      "music_dir": "/home/jake/Music",
+      "player_type": "mpd",
+      "truncate": {
+        "length": 100,
+        "mode": "end"
       },
-      {
-        "position": "top",
-        "left": []
-      }
-    ],
-    "DP-2": {
-      "position": "bottom",
-      "height": 30,
-      "left": []
+      "type": "music"
+    },
+    {
+      "host": "chloe:6600",
+      "player_type": "mpd",
+      "truncate": "end",
+      "type": "music"
+    },
+    {
+      "cmd": "/home/jake/bin/phone-battery",
+      "show_if": {
+        "cmd": "/home/jake/bin/phone-connected",
+        "interval": 500
+      },
+      "type": "script"
+    },
+    {
+      "format": [
+        " {cpu_percent}% | {temp_c:k10temp_Tccd1}°C",
+        " {memory_used} / {memory_total} GB ({memory_percent}%)",
+        "| {swap_used} / {swap_total} GB ({swap_percent}%)",
+        " {disk_used:/} / {disk_total:/} GB ({disk_percent:/}%)",
+        "李 {net_down:enp39s0} / {net_up:enp39s0} Mbps",
+        "猪 {load_average:1} | {load_average:5} | {load_average:15}",
+        " {uptime}"
+      ],
+      "interval": {
+        "cpu": 1,
+        "disks": 300,
+        "memory": 30,
+        "networks": 3,
+        "temps": 5
+      },
+      "type": "sys_info"
+    },
+    {
+      "bar": [
+        {
+          "label": "",
+          "name": "power-btn",
+          "on_click": "popup:toggle",
+          "type": "button"
+        }
+      ],
+      "class": "power-menu",
+      "popup": [
+        {
+          "orientation": "vertical",
+          "type": "box",
+          "widgets": [
+            {
+              "label": "Power menu",
+              "name": "header",
+              "type": "label"
+            },
+            {
+              "type": "box",
+              "widgets": [
+                {
+                  "class": "power-btn",
+                  "label": "<span font-size='40pt'></span>",
+                  "on_click": "!shutdown now",
+                  "type": "button"
+                },
+                {
+                  "class": "power-btn",
+                  "label": "<span font-size='40pt'></span>",
+                  "on_click": "!reboot",
+                  "type": "button"
+                }
+              ]
+            },
+            {
+              "label": "Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}",
+              "name": "uptime",
+              "type": "label"
+            }
+          ]
+        }
+      ],
+      "tooltip": "Up: {{30000:uptime -p | cut -d ' ' -f2-}}",
+      "type": "custom"
+    },
+    {
+      "type": "clock"
     }
-  }
-}
+  ],
+  "icon_theme": "Paper",
+  "position": "bottom",
+  "start": [
+    {
+      "bar": [
+        {
+          "size": 32,
+          "src": "file:///path/to/image.jpg",
+          "type": "image"
+        }
+      ],
+      "type": "custom"
+    },
+    {
+      "all_monitors": false,
+      "name_map": {
+        "1": "ﭮ",
+        "2": "icon:firefox",
+        "3": "",
+        "Code": "",
+        "Games": "icon:steam"
+      },
+      "type": "workspaces"
+    },
+    {
+      "favorites": [
+        "firefox",
+        "discord",
+        "Steam"
+      ],
+      "show_icons": true,
+      "show_names": false,
+      "type": "launcher"
+    }
+  ]
+}

examples/config.toml

@@ -0,0 +1,118 @@
+anchor_to_edges = true
+icon_theme = 'Paper'
+position = 'bottom'
+
+[[end]]
+music_dir = '/home/jake/Music'
+player_type = 'mpd'
+type = 'music'
+
+[end.truncate]
+length = 100
+mode = 'end'
+
+[[end]]
+host = 'chloe:6600'
+player_type = 'mpd'
+truncate = 'end'
+type = 'music'
+
+[[end]]
+cmd = '/home/jake/bin/phone-battery'
+type = 'script'
+
+[end.show_if]
+cmd = '/home/jake/bin/phone-connected'
+interval = 500
+
+[[end]]
+type = 'sys_info'
+format = [
+    ' {cpu_percent}% | {temp_c:k10temp_Tccd1}°C',
+    ' {memory_used} / {memory_total} GB ({memory_percent}%)',
+    '| {swap_used} / {swap_total} GB ({swap_percent}%)',
+    ' {disk_used:/} / {disk_total:/} GB ({disk_percent:/}%)',
+    '李 {net_down:enp39s0} / {net_up:enp39s0} Mbps',
+    '猪 {load_average:1} | {load_average:5} | {load_average:15}',
+    ' {uptime}',
+]
+
+[end.interval]
+cpu = 1
+disks = 300
+memory = 30
+networks = 3
+temps = 5
+
+[[end]]
+class = 'power-menu'
+tooltip = '''Up: {{30000:uptime -p | cut -d ' ' -f2-}}'''
+type = 'custom'
+
+[[end.bar]]
+label = ''
+name = 'power-btn'
+on_click = 'popup:toggle'
+type = 'button'
+
+[[end.popup]]
+orientation = 'vertical'
+type = 'box'
+
+[[end.popup.widgets]]
+label = 'Power menu'
+name = 'header'
+type = 'label'
+
+[[end.popup.widgets]]
+type = 'box'
+
+[[end.popup.widgets.widgets]]
+class = 'power-btn'
+label = '''<span font-size='40pt'></span>'''
+on_click = '!shutdown now'
+type = 'button'
+
+[[end.popup.widgets.widgets]]
+class = 'power-btn'
+label = '''<span font-size='40pt'></span>'''
+on_click = '!reboot'
+type = 'button'
+
+[[end.popup.widgets]]
+label = '''Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}'''
+name = 'uptime'
+type = 'label'
+
+[[end]]
+type = 'clock'
+
+[[start]]
+type = 'custom'
+
+[[start.bar]]
+size = 32
+src = 'file:///path/to/image.jpg'
+type = 'image'
+
+[[start]]
+all_monitors = false
+type = 'workspaces'
+
+[start.name_map]
+1 = 'ﭮ'
+2 = 'icon:firefox'
+3 = ''
+Code = ''
+Games = 'icon:steam'
+
+[[start]]
+show_icons = true
+show_names = false
+type = 'launcher'
+favorites = [
+    'firefox',
+    'discord',
+    'Steam',
+]
+

examples/config.yaml

@@ -0,0 +1,97 @@
+anchor_to_edges: true
+icon_theme: Paper
+position: bottom
+
+start:
+  - bar:
+      - size: 32
+        src: file:///path/to/image.jpg
+        type: image
+    type: custom
+
+  - all_monitors: false
+    name_map:
+      '1': ﭮ
+      '2': icon:firefox
+      '3': 
+      Code: 
+      Games: icon:steam
+    type: workspaces
+
+  - favorites:
+      - firefox
+      - discord
+      - Steam
+    show_icons: true
+    show_names: false
+    type: launcher
+
+end:
+  - music_dir: /home/jake/Music
+    player_type: mpd
+    truncate:
+      length: 100
+      mode: end
+    type: music
+
+  - host: chloe:6600
+    player_type: mpd
+    truncate: end
+    type: music
+
+  - cmd: /home/jake/bin/phone-battery
+    show_if:
+      cmd: /home/jake/bin/phone-connected
+      interval: 500
+    type: script
+
+  - format:
+      -  {cpu_percent}% | {temp_c:k10temp_Tccd1}°C
+      -  {memory_used} / {memory_total} GB ({memory_percent}%)
+      - '| {swap_used} / {swap_total} GB ({swap_percent}%)'
+      -  {disk_used:/} / {disk_total:/} GB ({disk_percent:/}%)
+      - 李 {net_down:enp39s0} / {net_up:enp39s0} Mbps
+      - 猪 {load_average:1} | {load_average:5} | {load_average:15}
+      -  {uptime}
+    interval:
+      cpu: 1
+      disks: 300
+      memory: 30
+      networks: 3
+      temps: 5
+    type: sys_info
+
+  - bar:
+      - label: 
+        name: power-btn
+        on_click: popup:toggle
+        type: button
+    class: power-menu
+    popup:
+      - orientation: vertical
+        type: box
+        widgets:
+          - label: Power menu
+            name: header
+            type: label
+          - type: box
+            widgets:
+              - class: power-btn
+                label: <span font-size='40pt'></span>
+                on_click: '!shutdown now'
+                type: button
+              - class: power-btn
+                label: <span font-size='40pt'></span>
+                on_click: '!reboot'
+                type: button
+          - label: 'Uptime: {{30000:uptime -p | cut -d '' '' -f2-}}'
+            name: uptime
+            type: label
+    tooltip: 'Up: {{30000:uptime -p | cut -d '' '' -f2-}}'
+    type: custom
+
+  - type: clock
+
+
+
+

examples/style.css

@@ -1,31 +1,19 @@
 * {
     /* `otf-font-awesome` is required to be installed for icons */
     font-family: Noto Sans Nerd Font, sans-serif;
-    /* font-family: 'Jetbrains Mono', monospace;*/
     font-size: 16px;
 
-    /*color: white;*/
-    /*background-color: #2d2d2d;*/
-    /*background-color: red;*/
     border: none;
-
-    /*opacity: 0.4;*/
 }
 
 #bar {
     border-top: 1px solid #424242;
 }
 
-.container {
+.background, .container {
     background-color: #2d2d2d;
 }
 
-/* test  34543*/
-
-#right > * + * {
-    margin-left: 20px;
-}
-
 #workspaces .item {
     color: white;
     background-color: #2d2d2d;
@@ -57,7 +45,7 @@
 
 #launcher .focused {
     color: white;
-    background-color: black;
+    background-color: #1c1c1c;
     border-bottom: 4px solid #6699cc;
 }
 
@@ -66,25 +54,54 @@
     background-color: #8f0a0a;
 }
 
+#popup-launcher .popup-item {
+    color: white;
+    background-color: #2d2d2d;
+    border-radius: 0;
+}
+
+#popup-launcher .popup-item:hover {
+    background-color: #1c1c1c;
+}
+
+#popup-launcher .popup-item:not(:first-child) {
+    border-top: 1px solid white;
+}
+
 #clock {
     color: white;
     background-color: #2d2d2d;
     font-weight: bold;
+    margin-left: 5px;
+}
+
+#clock:hover {
+    background-color: #1c1c1c;
 }
 
 #script {
+    padding-left: 10px;
     color: white;
 }
 
 #sysinfo {
+    margin-left: 10px;
     color: white;
 }
 
+#sysinfo #item {
+    margin-left: 5px;
+}
+
+#tray {
+    margin-left: 10px;
+}
+
 #tray .item {
     background-color: #2d2d2d;
 }
 
-#mpd {
+#music {
     background-color: #2d2d2d;
     color: white;
 }
@@ -119,30 +136,77 @@
     background-color: #6699cc;
 }
 
-#popup-mpd {
+#music:hover {
+    background-color: #1c1c1c;
+}
+
+#popup-music {
     color: white;
     padding: 1em;
 }
 
-#popup-mpd #album-art {
-    /*border: 1px solid #424242;*/
+#popup-music #album-art {
     margin-right: 1em;
 }
 
-#popup-mpd #title .icon, #popup-mpd #title .label {
+#popup-music #title .icon *, #popup-music #title .label {
     font-size: 1.7em;
 }
 
-#popup-mpd #controls * {
+#popup-music #controls * {
     border-radius: 0;
     background-color: #2d2d2d;
     color: white;
 }
 
-#popup-mpd #controls *:disabled {
+#popup-music #controls *:disabled {
     color: #424242;
 }
 
+#popup-music #volume > box:last-child label {
+    margin-left: 6px;
+}
+
 #focused {
     color: white;
 }
+
+.power-menu {
+    margin-left: 10px;
+}
+
+.power-menu #power-btn {
+    color: white;
+    background-color: #2d2d2d;
+}
+
+.power-menu #power-btn:hover {
+    background-color: #1c1c1c;
+}
+
+.popup-power-menu {
+    padding: 1em;
+}
+
+.popup-power-menu #header {
+    color: white;
+    font-size: 1.4em;
+    border-bottom: 1px solid white;
+    padding-bottom: 0.4em;
+    margin-bottom: 0.8em;
+}
+
+.popup-power-menu .power-btn {
+    color: white;
+    background-color: #2d2d2d;
+    border: 1px solid white;
+    padding: 0.6em 1em;
+}
+
+.popup-power-menu .power-btn + .power-btn {
+    margin-left: 1em;
+}
+
+.popup-power-menu .power-btn:hover {
+    background-color: #1c1c1c;
+}

flake.lock

@@ -0,0 +1,64 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "locked": {
+        "lastModified": 1659877975,
+        "narHash": "sha256-zllb8aq3YO3h8B/U0/J1WBgAL8EX5yWf5pMj3G0NAmc=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "c0e246b9b83f637f4681389ecabcb2681b4f3af0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1675115703,
+        "narHash": "sha256-4zetAPSyY0D77x+Ww9QBe8RHn1akvIvHJ/kgg8kGDbk=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "2caf4ef5005ecc68141ecb4aac271079f7371c44",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1675132198,
+        "narHash": "sha256-izOVjdIfdv0OzcfO9rXX0lfGkQn4tdJ0eNm3P3LYo/o=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "48b1403150c3f5a9aeee8bc4c77c8926f29c6501",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,143 @@
+{
+  description = "Nix Flake for ironbar";
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+    #nci.url = "github:yusdacra/nix-cargo-integration";
+    #nci.inputs.nixpkgs.follows = "nixpkgs";
+    #nci.inputs.rust-overlay.follows = "rust-overlay";
+  };
+  outputs = {
+    self,
+    nixpkgs,
+    rust-overlay,
+    ...
+  }: let
+    inherit (nixpkgs) lib;
+    genSystems = lib.genAttrs [
+      "aarch64-linux"
+      "x86_64-linux"
+    ];
+    pkgsFor = system:
+      import nixpkgs {
+        inherit system;
+
+        overlays = [
+          self.overlays.default
+          rust-overlay.overlays.default
+        ];
+      };
+    mkRustToolchain = pkgs: pkgs.rust-bin.stable.latest.default;
+  in {
+    overlays.default = final: prev: let
+      rust = mkRustToolchain final;
+
+      rustPlatform = prev.makeRustPlatform {
+        cargo = rust;
+        rustc = rust;
+      };
+    in {
+      ironbar = rustPlatform.buildRustPackage {
+        pname = "ironbar";
+        version = self.rev or "dirty";
+        src = builtins.path {
+          name = "ironbar";
+          path = prev.lib.cleanSource ./.;
+        };
+        cargoDeps = rustPlatform.importCargoLock {lockFile = ./Cargo.lock;};
+        cargoLock.lockFile = ./Cargo.lock;
+        nativeBuildInputs = with prev; [pkg-config];
+        buildInputs = with prev; [gtk3 gdk-pixbuf gtk-layer-shell libxkbcommon openssl];
+      };
+    };
+    packages = genSystems (
+      system: let
+        pkgs = pkgsFor system;
+      in
+        (self.overlays.default pkgs pkgs)
+        // {
+          default = self.packages.${system}.ironbar;
+        }
+    );
+    devShells = genSystems (system: let
+      pkgs = pkgsFor system;
+      rust = mkRustToolchain pkgs;
+    in {
+      default = pkgs.mkShell {
+        packages = with pkgs; [
+          rust
+          rust-analyzer-unwrapped
+          gcc
+          gtk3
+          gtk-layer-shell
+          pkg-config
+          openssl
+        ];
+
+        RUST_SRC_PATH = "${rust}/lib/rustlib/src/rust/library";
+      };
+    });
+    homeManagerModules.default = {
+      config,
+      lib,
+      pkgs,
+      ...
+    }: let
+      cfg = config.programs.ironbar;
+      defaultIronbarPackage = self.packages.${pkgs.hostPlatform.system}.default;
+      jsonFormat = pkgs.formats.json {};
+    in {
+      options.programs.ironbar = {
+        enable = lib.mkEnableOption "ironbar status bar";
+        package = lib.mkOption {
+          type = with lib.types; package;
+          default = defaultIronbarPackage;
+          description = "The package for ironbar to use";
+        };
+        systemd = lib.mkOption {
+          type = lib.types.bool;
+          default = pkgs.stdenv.isLinux;
+          description = "Whether to enable to systemd service for ironbar";
+        };
+        style = lib.mkOption {
+          type = lib.types.lines;
+          default = "";
+          description = "The stylesheet to apply to ironbar";
+        };
+        config = lib.mkOption {
+          type = jsonFormat.type;
+          default = {};
+          description = "The config to pass to ironbar";
+        };
+      };
+      config = lib.mkIf cfg.enable {
+        home.packages = [cfg.package];
+        xdg.configFile = {
+          "ironbar/config.json" = lib.mkIf (cfg.config != "") {
+            source = jsonFormat.generate "ironbar-config" cfg.config;
+          };
+          "ironbar/style.css" = lib.mkIf (cfg.style != "") {
+            text = cfg.style;
+          };
+        };
+        systemd.user.services.ironbar = lib.mkIf cfg.systemd {
+          Unit = {
+            Description = "Systemd service for Ironbar";
+            Requires = ["graphical-session.target"];
+          };
+          Service = {
+            Type = "simple";
+            ExecStart = "${cfg.package}/bin/ironbar";
+          };
+          Install.WantedBy = [
+            (lib.mkIf config.wayland.windowManager.hyprland.systemdIntegration "hyprland-session.target")
+            (lib.mkIf config.wayland.windowManager.sway.systemdIntegration "sway-session.target")
+          ];
+        };
+      };
+    };
+  };
+}

src/bar.rs

@@ -1,11 +1,21 @@
-use crate::config::{BarPosition, ModuleConfig};
-use crate::modules::{Module, ModuleInfo, ModuleLocation};
-use crate::Config;
+use crate::bridge_channel::BridgeChannel;
+use crate::config::{BarPosition, CommonConfig, ModuleConfig};
+use crate::dynamic_string::DynamicString;
+use crate::modules::{Module, ModuleInfo, ModuleLocation, ModuleUpdateEvent, WidgetContext};
+use crate::popup::Popup;
+use crate::script::{OutputStream, Script};
+use crate::{await_sync, read_lock, send, write_lock, Config};
 use color_eyre::Result;
-use gtk::gdk::Monitor;
+use gtk::gdk::{EventMask, Monitor, ScrollDirection};
 use gtk::prelude::*;
-use gtk::{Application, ApplicationWindow, Orientation};
+use gtk::{Application, ApplicationWindow, EventBox, IconTheme, Orientation, Widget};
+use std::sync::{Arc, RwLock};
+use tokio::spawn;
+use tokio::sync::mpsc;
+use tracing::{debug, error, info, trace};
 
+/// Creates a new window for a bar,
+/// sets it up and adds its widgets.
 pub fn create_bar(
     app: &Application,
     monitor: &Monitor,
@@ -14,116 +24,62 @@ pub fn create_bar(
 ) -> Result<()> {
     let win = ApplicationWindow::builder().application(app).build();
 
-    setup_layer_shell(&win, monitor, &config.position);
+    setup_layer_shell(&win, monitor, config.position, config.anchor_to_edges);
+
+    let orientation = config.position.get_orientation();
 
     let content = gtk::Box::builder()
-        .orientation(Orientation::Horizontal)
+        .orientation(orientation)
         .spacing(0)
         .hexpand(false)
-        .height_request(config.height)
-        .name("bar")
-        .build();
+        .name("bar");
 
-    let left = gtk::Box::builder().spacing(0).name("left").build();
-    let center = gtk::Box::builder().spacing(0).name("center").build();
-    let right = gtk::Box::builder().spacing(0).name("right").build();
+    let content = if orientation == Orientation::Horizontal {
+        content.height_request(config.height)
+    } else {
+        content.width_request(config.height)
+    }
+    .build();
 
     content.style_context().add_class("container");
-    left.style_context().add_class("container");
-    center.style_context().add_class("container");
-    right.style_context().add_class("container");
 
-    content.add(&left);
+    let start = create_container("start", orientation);
+    let center = create_container("center", orientation);
+    let end = create_container("end", orientation);
+
+    content.add(&start);
     content.set_center_widget(Some(&center));
-    content.pack_end(&right, false, false, 0);
+    content.pack_end(&end, false, false, 0);
 
-    load_modules(&left, &center, &right, app, config, monitor, monitor_name)?;
+    load_modules(&start, &center, &end, app, config, monitor, monitor_name)?;
     win.add(&content);
 
     win.connect_destroy_event(|_, _| {
+        info!("Shutting down");
         gtk::main_quit();
         Inhibit(false)
     });
 
-    win.show_all();
+    debug!("Showing bar");
+
+    // show each box but do not use `show_all`.
+    // this ensures `show_if` option works as intended.
+    start.show();
+    center.show();
+    end.show();
+    content.show();
+    win.show();
 
     Ok(())
 }
 
-fn load_modules(
-    left: &gtk::Box,
-    center: &gtk::Box,
-    right: &gtk::Box,
-    app: &Application,
-    config: Config,
+/// Sets up GTK layer shell for a provided application window.
+fn setup_layer_shell(
+    win: &ApplicationWindow,
     monitor: &Monitor,
-    output_name: &str,
-) -> Result<()> {
-    if let Some(modules) = config.left {
-        let info = ModuleInfo {
-            app,
-            location: ModuleLocation::Left,
-            bar_position: &config.position,
-            monitor,
-            output_name,
-        };
-
-        add_modules(left, modules, &info)?;
-    }
-
-    if let Some(modules) = config.center {
-        let info = ModuleInfo {
-            app,
-            location: ModuleLocation::Center,
-            bar_position: &config.position,
-            monitor,
-            output_name,
-        };
-
-        add_modules(center, modules, &info)?;
-    }
-
-    if let Some(modules) = config.right {
-        let info = ModuleInfo {
-            app,
-            location: ModuleLocation::Right,
-            bar_position: &config.position,
-            monitor,
-            output_name,
-        };
-
-        add_modules(right, modules, &info)?;
-    }
-
-    Ok(())
-}
-
-fn add_modules(content: &gtk::Box, modules: Vec<ModuleConfig>, info: &ModuleInfo) -> Result<()> {
-    macro_rules! add_module {
-        ($module:expr, $name:literal) => {{
-            let widget = $module.into_widget(&info)?;
-            widget.set_widget_name($name);
-            content.add(&widget);
-        }};
-    }
-
-    for config in modules {
-        match config {
-            ModuleConfig::Clock(module) => add_module!(module, "clock"),
-            ModuleConfig::Mpd(module) => add_module!(module, "mpd"),
-            ModuleConfig::Tray(module) => add_module!(module, "tray"),
-            ModuleConfig::Workspaces(module) => add_module!(module, "workspaces"),
-            ModuleConfig::SysInfo(module) => add_module!(module, "sysinfo"),
-            ModuleConfig::Launcher(module) => add_module!(module, "launcher"),
-            ModuleConfig::Script(module) => add_module!(module, "script"),
-            ModuleConfig::Focused(module) => add_module!(module, "focused"),
-        }
-    }
-
-    Ok(())
-}
-
-fn setup_layer_shell(win: &ApplicationWindow, monitor: &Monitor, position: &BarPosition) {
+    position: BarPosition,
+    anchor_to_edges: bool,
+) {
     gtk_layer_shell::init_for_window(win);
     gtk_layer_shell::set_monitor(win, monitor);
     gtk_layer_shell::set_layer(win, gtk_layer_shell::Layer::Top);
@@ -134,16 +90,327 @@ fn setup_layer_shell(win: &ApplicationWindow, monitor: &Monitor, position: &BarP
     gtk_layer_shell::set_margin(win, gtk_layer_shell::Edge::Left, 0);
     gtk_layer_shell::set_margin(win, gtk_layer_shell::Edge::Right, 0);
 
+    let bar_orientation = position.get_orientation();
+
     gtk_layer_shell::set_anchor(
         win,
         gtk_layer_shell::Edge::Top,
-        position == &BarPosition::Top,
+        position == BarPosition::Top
+            || (bar_orientation == Orientation::Vertical && anchor_to_edges),
     );
     gtk_layer_shell::set_anchor(
         win,
         gtk_layer_shell::Edge::Bottom,
-        position == &BarPosition::Bottom,
+        position == BarPosition::Bottom
+            || (bar_orientation == Orientation::Vertical && anchor_to_edges),
+    );
+    gtk_layer_shell::set_anchor(
+        win,
+        gtk_layer_shell::Edge::Left,
+        position == BarPosition::Left
+            || (bar_orientation == Orientation::Horizontal && anchor_to_edges),
+    );
+    gtk_layer_shell::set_anchor(
+        win,
+        gtk_layer_shell::Edge::Right,
+        position == BarPosition::Right
+            || (bar_orientation == Orientation::Horizontal && anchor_to_edges),
     );
-    gtk_layer_shell::set_anchor(win, gtk_layer_shell::Edge::Left, true);
-    gtk_layer_shell::set_anchor(win, gtk_layer_shell::Edge::Right, true);
+}
+
+/// Creates a `gtk::Box` container to place widgets inside.
+fn create_container(name: &str, orientation: Orientation) -> gtk::Box {
+    let container = gtk::Box::builder()
+        .orientation(orientation)
+        .spacing(0)
+        .name(name)
+        .build();
+
+    container.style_context().add_class("container");
+    container
+}
+
+/// Loads the configured modules onto a bar.
+fn load_modules(
+    left: &gtk::Box,
+    center: &gtk::Box,
+    right: &gtk::Box,
+    app: &Application,
+    config: Config,
+    monitor: &Monitor,
+    output_name: &str,
+) -> Result<()> {
+    let icon_theme = IconTheme::new();
+    if let Some(ref theme) = config.icon_theme {
+        icon_theme.set_custom_theme(Some(theme));
+    }
+
+    macro_rules! info {
+        ($location:expr) => {
+            ModuleInfo {
+                app,
+                bar_position: config.position,
+                monitor,
+                output_name,
+                location: $location,
+                icon_theme: &icon_theme,
+            }
+        };
+    }
+
+    if let Some(modules) = config.start {
+        let info = info!(ModuleLocation::Left);
+        add_modules(left, modules, &info)?;
+    }
+
+    if let Some(modules) = config.center {
+        let info = info!(ModuleLocation::Center);
+        add_modules(center, modules, &info)?;
+    }
+
+    if let Some(modules) = config.end {
+        let info = info!(ModuleLocation::Right);
+        add_modules(right, modules, &info)?;
+    }
+
+    Ok(())
+}
+
+/// Adds modules into a provided GTK box,
+/// which should be one of its left, center or right containers.
+fn add_modules(content: &gtk::Box, modules: Vec<ModuleConfig>, info: &ModuleInfo) -> Result<()> {
+    let popup = Popup::new(info);
+    let popup = Arc::new(RwLock::new(popup));
+
+    macro_rules! add_module {
+        ($module:expr, $id:expr) => {{
+            let common = $module.common.take().expect("Common config did not exist");
+            let widget = create_module($module, $id, &info, &Arc::clone(&popup))?;
+
+            let container = wrap_widget(&widget);
+            content.add(&container);
+            setup_module_common_options(container, common);
+        }};
+    }
+
+    for (id, config) in modules.into_iter().enumerate() {
+        match config {
+            #[cfg(feature = "clock")]
+            ModuleConfig::Clock(mut module) => add_module!(module, id),
+            ModuleConfig::Custom(mut module) => add_module!(module, id),
+            ModuleConfig::Focused(mut module) => add_module!(module, id),
+            ModuleConfig::Launcher(mut module) => add_module!(module, id),
+            #[cfg(feature = "music")]
+            ModuleConfig::Music(mut module) => add_module!(module, id),
+            ModuleConfig::Script(mut module) => add_module!(module, id),
+            #[cfg(feature = "sys_info")]
+            ModuleConfig::SysInfo(mut module) => add_module!(module, id),
+            #[cfg(feature = "tray")]
+            ModuleConfig::Tray(mut module) => add_module!(module, id),
+            #[cfg(feature = "workspaces")]
+            ModuleConfig::Workspaces(mut module) => add_module!(module, id),
+        }
+    }
+
+    Ok(())
+}
+
+/// Creates a module and sets it up.
+/// This setup includes widget/popup content and event channels.
+fn create_module<TModule, TWidget, TSend, TRec>(
+    module: TModule,
+    id: usize,
+    info: &ModuleInfo,
+    popup: &Arc<RwLock<Popup>>,
+) -> Result<TWidget>
+where
+    TModule: Module<TWidget, SendMessage = TSend, ReceiveMessage = TRec>,
+    TWidget: IsA<Widget>,
+    TSend: Clone + Send + 'static,
+{
+    let (w_tx, w_rx) = glib::MainContext::channel::<TSend>(glib::PRIORITY_DEFAULT);
+    let (p_tx, p_rx) = glib::MainContext::channel::<TSend>(glib::PRIORITY_DEFAULT);
+
+    let channel = BridgeChannel::<ModuleUpdateEvent<TSend>>::new();
+    let (ui_tx, ui_rx) = mpsc::channel::<TRec>(16);
+
+    module.spawn_controller(info, channel.create_sender(), ui_rx)?;
+
+    let context = WidgetContext {
+        id,
+        widget_rx: w_rx,
+        popup_rx: p_rx,
+        tx: channel.create_sender(),
+        controller_tx: ui_tx,
+    };
+
+    let name = TModule::name();
+
+    let module_parts = module.into_widget(context, info)?;
+    module_parts.widget.set_widget_name(name);
+
+    let mut has_popup = false;
+    if let Some(popup_content) = module_parts.popup {
+        register_popup_content(popup, id, popup_content);
+        has_popup = true;
+    }
+
+    setup_receiver(channel, w_tx, p_tx, popup.clone(), name, id, has_popup);
+
+    Ok(module_parts.widget)
+}
+
+/// Registers the popup content with the popup.
+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
+/// to pick up events from the controller, widget or popup.
+///
+/// Handles opening/closing popups
+/// and communicating update messages between controllers and widgets/popups.
+fn setup_receiver<TSend>(
+    channel: BridgeChannel<ModuleUpdateEvent<TSend>>,
+    w_tx: glib::Sender<TSend>,
+    p_tx: glib::Sender<TSend>,
+    popup: Arc<RwLock<Popup>>,
+    name: &'static str,
+    id: usize,
+    has_popup: bool,
+) where
+    TSend: Clone + Send + 'static,
+{
+    channel.recv(move |ev| {
+        match ev {
+            ModuleUpdateEvent::Update(update) => {
+                if has_popup {
+                    send!(p_tx, update.clone());
+                }
+
+                send!(w_tx, update);
+            }
+            ModuleUpdateEvent::TogglePopup(geometry) => {
+                debug!("Toggling popup for {} [#{}]", name, id);
+                let popup = read_lock!(popup);
+                if popup.is_visible() {
+                    popup.hide();
+                } else {
+                    popup.show_content(id);
+                    popup.show(geometry);
+                }
+            }
+            ModuleUpdateEvent::OpenPopup(geometry) => {
+                debug!("Opening popup for {} [#{}]", name, id);
+
+                let popup = read_lock!(popup);
+                popup.hide();
+                popup.show_content(id);
+                popup.show(geometry);
+            }
+            ModuleUpdateEvent::ClosePopup => {
+                debug!("Closing popup for {} [#{}]", name, id);
+
+                let popup = read_lock!(popup);
+                popup.hide();
+            }
+        }
+
+        Continue(true)
+    });
+}
+
+/// Takes a widget and adds it into a new `gtk::EventBox`.
+/// The event box container is returned.
+fn wrap_widget<W: IsA<Widget>>(widget: &W) -> EventBox {
+    let container = EventBox::new();
+    container.add_events(EventMask::SCROLL_MASK);
+    container.add(widget);
+    container
+}
+
+/// Configures the module's container according to the common config options.
+fn setup_module_common_options(container: EventBox, common: CommonConfig) {
+    common.show_if.map_or_else(
+        || {
+            container.show_all();
+        },
+        |show_if| {
+            let script = Script::new_polling(show_if);
+            let container = container.clone();
+            let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
+            spawn(async move {
+                script
+                    .run(|(_, success)| {
+                        send!(tx, success);
+                    })
+                    .await;
+            });
+            rx.attach(None, move |success| {
+                if success {
+                    container.show_all();
+                } else {
+                    container.hide();
+                };
+                Continue(true)
+            });
+        },
+    );
+
+    let left_click_script = common.on_click_left.map(Script::new_polling);
+    let middle_click_script = common.on_click_middle.map(Script::new_polling);
+    let right_click_script = common.on_click_right.map(Script::new_polling);
+
+    container.connect_button_press_event(move |_, event| {
+        let script = match event.button() {
+            1 => left_click_script.as_ref(),
+            2 => middle_click_script.as_ref(),
+            3 => right_click_script.as_ref(),
+            _ => None,
+        };
+
+        if let Some(script) = script {
+            trace!("Running on-click script: {}", event.button());
+
+            match await_sync(async { script.get_output().await }) {
+                Ok((OutputStream::Stderr(out), _)) => error!("{out}"),
+                Err(err) => error!("{err:?}"),
+                _ => {}
+            }
+        }
+
+        Inhibit(false)
+    });
+
+    let scroll_up_script = common.on_scroll_up.map(Script::new_polling);
+    let scroll_down_script = common.on_scroll_down.map(Script::new_polling);
+
+    container.connect_scroll_event(move |_, event| {
+        println!("{:?}", event.direction());
+
+        let script = match event.direction() {
+            ScrollDirection::Up => scroll_up_script.as_ref(),
+            ScrollDirection::Down => scroll_down_script.as_ref(),
+            _ => None,
+        };
+
+        if let Some(script) = script {
+            trace!("Running on-scroll script: {}", event.direction());
+
+            match await_sync(async { script.get_output().await }) {
+                Ok((OutputStream::Stderr(out), _)) => error!("{out}"),
+                Err(err) => error!("{err:?}"),
+                _ => {}
+            }
+        }
+
+        Inhibit(false)
+    });
+
+    if let Some(tooltip) = common.tooltip {
+        DynamicString::new(&tooltip, move |string| {
+            container.set_tooltip_text(Some(&string));
+            Continue(true)
+        });
+    }
 }

src/bridge_channel.rs

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

src/clients/compositor/hyprland.rs

@@ -0,0 +1,281 @@
+use super::{Workspace, WorkspaceClient, WorkspaceUpdate};
+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::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};
+
+pub struct EventClient {
+    workspace_tx: Sender<WorkspaceUpdate>,
+    _workspace_rx: Receiver<WorkspaceUpdate>,
+}
+
+impl EventClient {
+    fn new() -> Self {
+        let (workspace_tx, workspace_rx) = channel(16);
+
+        Self {
+            workspace_tx,
+            _workspace_rx: workspace_rx,
+        }
+    }
+
+    fn listen_workspace_events(&self) {
+        info!("Starting Hyprland event listener");
+
+        let tx = self.workspace_tx.clone();
+
+        spawn_blocking(move || {
+            let mut event_listener = EventListener::new();
+
+            // we need a lock to ensure events don't run at the same time
+            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::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, _state| {
+                    let _lock = lock!(lock);
+                    debug!("Added workspace: {workspace_type:?}");
+
+                    let workspace_name = get_workspace_name(workspace_type);
+                    let prev_workspace = lock!(active);
+                    let focused = prev_workspace
+                        .as_ref()
+                        .map_or(false, |w| w.name == workspace_name);
+
+                    let workspace = Self::get_workspace(&workspace_name, focused);
+
+                    if let Some(workspace) = workspace {
+                        send!(tx, WorkspaceUpdate::Add(workspace));
+                    }
+                });
+            }
+
+            {
+                let tx = tx.clone();
+                let lock = lock.clone();
+                let active = active.clone();
+
+                event_listener.add_workspace_change_handler(move |workspace_type, _state| {
+                    let _lock = lock!(lock);
+
+                    let mut prev_workspace = lock!(active);
+
+                    debug!(
+                        "Received workspace change: {:?} -> {workspace_type:?}",
+                        prev_workspace.as_ref().map(|w| &w.id)
+                    );
+
+                    let workspace_name = get_workspace_name(workspace_type);
+                    let focused = prev_workspace
+                        .as_ref()
+                        .map_or(false, |w| w.name == workspace_name);
+                    let workspace = Self::get_workspace(&workspace_name, focused);
+
+                    workspace.map_or_else(
+                        || {
+                            error!("Unable to locate workspace");
+                        },
+                        |workspace| {
+                            // there may be another type of update so dispatch that regardless of focus change
+                            send!(tx, WorkspaceUpdate::Update(workspace.clone()));
+                            if !focused {
+                                Self::send_focus_change(&mut prev_workspace, workspace, &tx);
+                            }
+                        },
+                    );
+                });
+            }
+
+            {
+                let tx = tx.clone();
+                let lock = lock.clone();
+                let active = active.clone();
+
+                event_listener.add_active_monitor_change_handler(move |event_data, _state| {
+                    let _lock = lock!(lock);
+                    let workspace_type = event_data.1;
+
+                    let mut prev_workspace = lock!(active);
+
+                    debug!(
+                        "Received active monitor change: {:?} -> {workspace_type:?}",
+                        prev_workspace.as_ref().map(|w| &w.name)
+                    );
+
+                    let workspace_name = get_workspace_name(workspace_type);
+                    let focused = prev_workspace
+                        .as_ref()
+                        .map_or(false, |w| w.name == workspace_name);
+                    let workspace = Self::get_workspace(&workspace_name, focused);
+
+                    if let (Some(workspace), false) = (workspace, focused) {
+                        Self::send_focus_change(&mut prev_workspace, workspace, &tx);
+                    } else {
+                        error!("Unable to locate workspace");
+                    }
+                });
+            }
+
+            {
+                let tx = tx.clone();
+                let lock = lock.clone();
+
+                event_listener.add_workspace_moved_handler(move |event_data, _state| {
+                    let _lock = lock!(lock);
+                    let workspace_type = event_data.1;
+                    debug!("Received workspace move: {workspace_type:?}");
+
+                    let mut prev_workspace = lock!(active);
+
+                    let workspace_name = get_workspace_name(workspace_type);
+                    let focused = prev_workspace
+                        .as_ref()
+                        .map_or(false, |w| w.name == workspace_name);
+                    let workspace = Self::get_workspace(&workspace_name, focused);
+
+                    if let Some(workspace) = workspace {
+                        send!(tx, WorkspaceUpdate::Move(workspace.clone()));
+
+                        if !focused {
+                            Self::send_focus_change(&mut prev_workspace, workspace, &tx);
+                        }
+                    }
+                });
+            }
+
+            {
+                event_listener.add_workspace_destroy_handler(move |workspace_type, _state| {
+                    let _lock = lock!(lock);
+                    debug!("Received workspace destroy: {workspace_type:?}");
+
+                    let name = get_workspace_name(workspace_type);
+                    send!(tx, WorkspaceUpdate::Remove(name));
+                });
+            }
+
+            event_listener
+                .start_listener()
+                .expect("Failed to start listener");
+        });
+    }
+
+    /// Sends a `WorkspaceUpdate::Focus` event
+    /// and updates the active workspace cache.
+    fn send_focus_change(
+        prev_workspace: &mut Option<Workspace>,
+        workspace: Workspace,
+        tx: &Sender<WorkspaceUpdate>,
+    ) {
+        let old = prev_workspace
+            .as_ref()
+            .map(|w| w.name.clone())
+            .unwrap_or_default();
+
+        send!(
+            tx,
+            WorkspaceUpdate::Focus {
+                old,
+                new: workspace.name.clone(),
+            }
+        );
+
+        prev_workspace.replace(workspace);
+    }
+
+    /// Gets a workspace by name from the server.
+    ///
+    /// Use `focused` to manually mark the workspace as focused,
+    /// as this is not automatically checked.
+    fn get_workspace(name: &str, focused: bool) -> Option<Workspace> {
+        Workspaces::get()
+            .expect("Failed to get workspaces")
+            .find_map(|w| {
+                if w.name == name {
+                    Some(Workspace::from((focused, w)))
+                } else {
+                    None
+                }
+            })
+    }
+
+    /// Gets the active workspace from the server.
+    fn get_active_workspace() -> Result<Workspace> {
+        let w = HWorkspace::get_active().map(|w| Workspace::from((true, w)))?;
+        Ok(w)
+    }
+}
+
+impl WorkspaceClient for EventClient {
+    fn focus(&self, id: String) -> Result<()> {
+        Dispatch::call(DispatchType::Workspace(
+            WorkspaceIdentifierWithSpecial::Name(&id),
+        ))?;
+        Ok(())
+    }
+
+    fn subscribe_workspace_change(&self) -> Receiver<WorkspaceUpdate> {
+        let rx = self.workspace_tx.subscribe();
+
+        {
+            let tx = self.workspace_tx.clone();
+
+            let active_name = HWorkspace::get_active()
+                .map(|active| active.name)
+                .unwrap_or_default();
+
+            let workspaces = Workspaces::get()
+                .expect("Failed to get workspaces")
+                .map(|w| Workspace::from((w.name == active_name, w)))
+                .collect();
+
+            send!(tx, WorkspaceUpdate::Init(workspaces));
+        }
+
+        rx
+    }
+}
+
+lazy_static! {
+    static ref CLIENT: EventClient = {
+        let client = EventClient::new();
+        client.listen_workspace_events();
+        client
+    };
+}
+
+pub fn get_client() -> &'static EventClient {
+    &CLIENT
+}
+
+fn get_workspace_name(name: WorkspaceType) -> String {
+    match name {
+        WorkspaceType::Regular(name) => name,
+        WorkspaceType::Special(name) => name.unwrap_or_default(),
+    }
+}
+
+impl From<(bool, hyprland::data::Workspace)> for Workspace {
+    fn from((focused, workspace): (bool, hyprland::data::Workspace)) -> Self {
+        Self {
+            id: workspace.id.to_string(),
+            name: workspace.name,
+            monitor: workspace.monitor,
+            focused,
+        }
+    }
+}

src/clients/compositor/mod.rs

@@ -0,0 +1,104 @@
+use cfg_if::cfg_if;
+use color_eyre::{Help, Report, Result};
+use std::fmt::{Display, Formatter};
+use tokio::sync::broadcast;
+use tracing::debug;
+
+#[cfg(feature = "workspaces+hyprland")]
+pub mod hyprland;
+#[cfg(feature = "workspaces+sway")]
+pub mod sway;
+
+pub enum Compositor {
+    #[cfg(feature = "workspaces+sway")]
+    Sway,
+    #[cfg(feature = "workspaces+hyprland")]
+    Hyprland,
+    Unsupported,
+}
+
+impl Display for Compositor {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                #[cfg(feature = "workspaces+sway")]
+                Self::Sway => "Sway",
+                #[cfg(feature = "workspaces+hyprland")]
+                Self::Hyprland => "Hyprland",
+                Self::Unsupported => "Unsupported",
+            }
+        )
+    }
+}
+
+impl Compositor {
+    /// Attempts to get the current compositor.
+    /// This is done by checking system env vars.
+    fn get_current() -> Self {
+        if std::env::var("SWAYSOCK").is_ok() {
+            cfg_if! {
+                if #[cfg(feature = "workspaces+sway")] { Self::Sway }
+                else { tracing::error!("Not compiled with Sway support"); Self::Unsupported }
+            }
+        } else if std::env::var("HYPRLAND_INSTANCE_SIGNATURE").is_ok() {
+            cfg_if! {
+                if #[cfg(feature = "workspaces+hyprland")] { Self::Hyprland}
+                else { tracing::error!("Not compiled with Hyprland support"); Self::Unsupported }
+            }
+        } else {
+            Self::Unsupported
+        }
+    }
+
+    /// Gets the workspace client for the current compositor
+    pub fn get_workspace_client() -> Result<&'static (dyn WorkspaceClient + Send)> {
+        let current = Self::get_current();
+        debug!("Getting workspace client for: {current}");
+        match current {
+            #[cfg(feature = "workspaces+sway")]
+            Self::Sway => Ok(sway::get_sub_client()),
+            #[cfg(feature = "workspaces+hyprland")]
+            Self::Hyprland => Ok(hyprland::get_client()),
+            Self::Unsupported => Err(Report::msg("Unsupported compositor")
+                .note("Currently workspaces are only supported by Sway and Hyprland")),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Workspace {
+    /// Unique identifier
+    pub id: String,
+    /// Workspace friendly name
+    pub name: String,
+    /// Name of the monitor (output) the workspace is located on
+    pub monitor: String,
+    /// Whether the workspace is in focus
+    pub focused: bool,
+}
+
+#[derive(Debug, Clone)]
+pub enum WorkspaceUpdate {
+    /// Provides an initial list of workspaces.
+    /// This is re-sent to all subscribers when a new subscription is created.
+    Init(Vec<Workspace>),
+    Add(Workspace),
+    Remove(String),
+    Update(Workspace),
+    Move(Workspace),
+    /// Declares focus moved from the old workspace to the new.
+    Focus {
+        old: String,
+        new: String,
+    },
+}
+
+pub trait WorkspaceClient {
+    /// Requests the workspace with this name is focused.
+    fn focus(&self, name: String) -> Result<()>;
+
+    /// Creates a new to workspace event receiver.
+    fn subscribe_workspace_change(&self) -> broadcast::Receiver<WorkspaceUpdate>;
+}

src/clients/compositor/sway.rs

@@ -0,0 +1,159 @@
+use super::{Workspace, WorkspaceClient, WorkspaceUpdate};
+use crate::{await_sync, send};
+use async_once::AsyncOnce;
+use color_eyre::Report;
+use futures_util::StreamExt;
+use lazy_static::lazy_static;
+use std::sync::Arc;
+use swayipc_async::{Connection, Event, EventType, Node, WorkspaceChange, WorkspaceEvent};
+use tokio::spawn;
+use tokio::sync::broadcast::{channel, Receiver, Sender};
+use tokio::sync::Mutex;
+use tracing::{info, trace};
+
+pub struct SwayEventClient {
+    workspace_tx: Sender<WorkspaceUpdate>,
+    _workspace_rx: Receiver<WorkspaceUpdate>,
+}
+
+impl SwayEventClient {
+    fn new() -> Self {
+        let (workspace_tx, workspace_rx) = channel(16);
+
+        {
+            let workspace_tx = workspace_tx.clone();
+            spawn(async move {
+                let client = Connection::new().await?;
+                info!("Sway IPC subscription client connected");
+
+                let event_types = [EventType::Workspace];
+
+                let mut events = client.subscribe(event_types).await?;
+
+                while let Some(event) = events.next().await {
+                    trace!("event: {:?}", event);
+                    if let Event::Workspace(ev) = event? {
+                        workspace_tx.send(WorkspaceUpdate::from(*ev))?;
+                    };
+                }
+
+                Ok::<(), Report>(())
+            });
+        }
+
+        Self {
+            workspace_tx,
+            _workspace_rx: workspace_rx,
+        }
+    }
+}
+
+impl WorkspaceClient for SwayEventClient {
+    fn focus(&self, id: String) -> color_eyre::Result<()> {
+        await_sync(async move {
+            let client = get_client().await;
+            let mut client = client.lock().await;
+            client.run_command(format!("workspace {id}")).await
+        })?;
+        Ok(())
+    }
+
+    fn subscribe_workspace_change(&self) -> Receiver<WorkspaceUpdate> {
+        let rx = self.workspace_tx.subscribe();
+
+        {
+            let tx = self.workspace_tx.clone();
+            await_sync(async {
+                let client = get_client().await;
+                let mut client = client.lock().await;
+
+                let workspaces = client
+                    .get_workspaces()
+                    .await
+                    .expect("Failed to get workspaces");
+                let event =
+                    WorkspaceUpdate::Init(workspaces.into_iter().map(Workspace::from).collect());
+
+                send!(tx, event);
+            });
+        }
+
+        rx
+    }
+}
+
+lazy_static! {
+    static ref CLIENT: AsyncOnce<Arc<Mutex<Connection>>> = AsyncOnce::new(async {
+        let client = Connection::new()
+            .await
+            .expect("Failed to connect to Sway socket");
+        Arc::new(Mutex::new(client))
+    });
+    static ref SUB_CLIENT: SwayEventClient = SwayEventClient::new();
+}
+
+/// Gets the sway IPC client
+async fn get_client() -> Arc<Mutex<Connection>> {
+    let client = CLIENT.get().await;
+    Arc::clone(client)
+}
+
+/// Gets the sway IPC event subscription client
+pub fn get_sub_client() -> &'static SwayEventClient {
+    &SUB_CLIENT
+}
+
+impl From<Node> for Workspace {
+    fn from(node: Node) -> Self {
+        Self {
+            id: node.id.to_string(),
+            name: node.name.unwrap_or_default(),
+            monitor: node.output.unwrap_or_default(),
+            focused: node.focused,
+        }
+    }
+}
+
+impl From<swayipc_async::Workspace> for Workspace {
+    fn from(workspace: swayipc_async::Workspace) -> Self {
+        Self {
+            id: workspace.id.to_string(),
+            name: workspace.name,
+            monitor: workspace.output,
+            focused: workspace.focused,
+        }
+    }
+}
+
+impl From<WorkspaceEvent> for WorkspaceUpdate {
+    fn from(event: WorkspaceEvent) -> Self {
+        match event.change {
+            WorkspaceChange::Init => {
+                Self::Add(event.current.expect("Missing current workspace").into())
+            }
+            WorkspaceChange::Empty => Self::Remove(
+                event
+                    .current
+                    .expect("Missing current workspace")
+                    .name
+                    .unwrap_or_default(),
+            ),
+            WorkspaceChange::Focus => Self::Focus {
+                old: event
+                    .old
+                    .expect("Missing old workspace")
+                    .name
+                    .unwrap_or_default(),
+                new: event
+                    .current
+                    .expect("Missing current workspace")
+                    .name
+                    .unwrap_or_default(),
+            },
+            WorkspaceChange::Move => {
+                Self::Move(event.current.expect("Missing current workspace").into())
+            }
+            _ => Self::Update(event.current.expect("Missing current workspace").into()),
+        }
+    }
+}

src/clients/mod.rs

@@ -0,0 +1,7 @@
+#[cfg(feature = "workspaces")]
+pub mod compositor;
+#[cfg(feature = "music")]
+pub mod music;
+#[cfg(feature = "tray")]
+pub mod system_tray;
+pub mod wayland;

src/clients/music/mod.rs

@@ -0,0 +1,72 @@
+use color_eyre::Result;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::broadcast;
+
+#[cfg(feature = "music+mpd")]
+pub mod mpd;
+#[cfg(feature = "music+mpris")]
+pub mod mpris;
+
+#[derive(Clone, Debug)]
+pub enum PlayerUpdate {
+    Update(Box<Option<Track>>, Status),
+    Disconnect,
+}
+
+#[derive(Clone, Debug)]
+pub struct Track {
+    pub title: Option<String>,
+    pub album: Option<String>,
+    pub artist: Option<String>,
+    pub date: Option<String>,
+    pub disc: Option<u64>,
+    pub genre: Option<String>,
+    pub track: Option<u64>,
+    pub cover_path: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub enum PlayerState {
+    Playing,
+    Paused,
+    Stopped,
+}
+
+#[derive(Clone, Debug)]
+pub struct Status {
+    pub state: PlayerState,
+    pub volume_percent: u8,
+    pub duration: Option<Duration>,
+    pub elapsed: Option<Duration>,
+    pub playlist_position: u32,
+    pub playlist_length: u32,
+}
+
+pub trait MusicClient {
+    fn play(&self) -> Result<()>;
+    fn pause(&self) -> Result<()>;
+    fn next(&self) -> Result<()>;
+    fn prev(&self) -> Result<()>;
+
+    fn set_volume_percent(&self, vol: u8) -> Result<()>;
+
+    fn subscribe_change(&self) -> broadcast::Receiver<PlayerUpdate>;
+}
+
+pub enum ClientType<'a> {
+    Mpd { host: &'a str, music_dir: PathBuf },
+    Mpris,
+}
+
+pub async fn get_client(client_type: ClientType<'_>) -> Box<Arc<dyn MusicClient>> {
+    match client_type {
+        ClientType::Mpd { host, music_dir } => Box::new(
+            mpd::get_client(host, music_dir)
+                .await
+                .expect("Failed to connect to MPD client"),
+        ),
+        ClientType::Mpris => Box::new(mpris::get_client()),
+    }
+}

src/clients/music/mpd.rs

@@ -0,0 +1,311 @@
+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::protocol::MpdProtocolError;
+use mpd_client::responses::{PlayState, Song};
+use mpd_client::tag::Tag;
+use mpd_client::{commands, Client};
+use std::collections::HashMap;
+use std::fmt::{Display, Formatter};
+use std::os::unix::fs::FileTypeExt;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::net::{TcpStream, UnixStream};
+use tokio::spawn;
+use tokio::sync::broadcast::{channel, error::SendError, Receiver, Sender};
+use tokio::sync::Mutex;
+use tokio::time::sleep;
+use tracing::{debug, error, info};
+
+lazy_static! {
+    static ref CONNECTIONS: Arc<Mutex<HashMap<String, Arc<MpdClient>>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+}
+
+pub struct MpdClient {
+    client: Client,
+    music_dir: PathBuf,
+    tx: Sender<PlayerUpdate>,
+    _rx: Receiver<PlayerUpdate>,
+}
+
+#[derive(Debug)]
+pub enum MpdConnectionError {
+    MaxRetries,
+    ProtocolError(MpdProtocolError),
+}
+
+impl Display for MpdConnectionError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::MaxRetries => write!(f, "Reached max retries"),
+            Self::ProtocolError(e) => write!(f, "{e:?}"),
+        }
+    }
+}
+
+impl std::error::Error for MpdConnectionError {}
+
+impl MpdClient {
+    async fn new(host: &str, music_dir: PathBuf) -> Result<Self, MpdConnectionError> {
+        debug!("Creating new MPD connection to {}", host);
+
+        let (client, mut state_changes) =
+            wait_for_connection(host, Duration::from_secs(5), None).await?;
+
+        let (tx, rx) = channel(16);
+
+        {
+            let music_dir = music_dir.clone();
+            let tx = tx.clone();
+            let client = client.clone();
+
+            spawn(async move {
+                while let Some(change) = state_changes.next().await {
+                    debug!("Received state change: {:?}", change);
+
+                    if let ConnectionEvent::SubsystemChange(
+                        Subsystem::Player | Subsystem::Queue | Subsystem::Mixer,
+                    ) = change
+                    {
+                        Self::send_update(&client, &tx, &music_dir)
+                            .await
+                            .expect("Failed to send update");
+                    }
+                }
+
+                Ok::<(), SendError<(Option<Track>, Status)>>(())
+            });
+        }
+
+        Ok(Self {
+            client,
+            music_dir,
+            tx,
+            _rx: rx,
+        })
+    }
+
+    async fn send_update(
+        client: &Client,
+        tx: &Sender<PlayerUpdate>,
+        music_dir: &Path,
+    ) -> Result<(), SendError<PlayerUpdate>> {
+        let current_song = client.command(commands::CurrentSong).await;
+        let status = client.command(commands::Status).await;
+
+        if let (Ok(current_song), Ok(status)) = (current_song, status) {
+            let track = current_song.map(|s| Self::convert_song(&s.song, music_dir));
+            let status = Status::from(status);
+
+            tx.send(PlayerUpdate::Update(Box::new(track), status))?;
+        }
+
+        Ok(())
+    }
+
+    fn is_connected(&self) -> bool {
+        !self.client.is_connection_closed()
+    }
+
+    fn send_disconnect_update(&self) -> Result<(), SendError<PlayerUpdate>> {
+        info!("Connection to MPD server lost");
+        self.tx.send(PlayerUpdate::Disconnect)?;
+        Ok(())
+    }
+
+    fn convert_song(song: &Song, music_dir: &Path) -> Track {
+        let (track, disc) = song.number();
+
+        let cover_path = music_dir
+            .join(
+                song.file_path()
+                    .parent()
+                    .expect("Song path should not be root")
+                    .join("cover.jpg"),
+            )
+            .into_os_string()
+            .into_string()
+            .ok();
+
+        Track {
+            title: song.title().map(std::string::ToString::to_string),
+            album: song.album().map(std::string::ToString::to_string),
+            artist: Some(song.artists().join(", ")),
+            date: try_get_first_tag(song, &Tag::Date).map(std::string::ToString::to_string),
+            genre: try_get_first_tag(song, &Tag::Genre).map(std::string::ToString::to_string),
+            disc: Some(disc),
+            track: Some(track),
+            cover_path,
+        }
+    }
+}
+
+macro_rules! async_command {
+    ($client:expr, $command:expr) => {
+        await_sync(async {
+            $client
+                .command($command)
+                .await
+                .unwrap_or_else(|err| error!("Failed to send command: {err:?}"))
+        })
+    };
+}
+
+impl MusicClient for MpdClient {
+    fn play(&self) -> Result<()> {
+        async_command!(self.client, commands::SetPause(false));
+        Ok(())
+    }
+
+    fn pause(&self) -> Result<()> {
+        async_command!(self.client, commands::SetPause(true));
+        Ok(())
+    }
+
+    fn next(&self) -> Result<()> {
+        async_command!(self.client, commands::Next);
+        Ok(())
+    }
+
+    fn prev(&self) -> Result<()> {
+        async_command!(self.client, commands::Previous);
+        Ok(())
+    }
+
+    fn set_volume_percent(&self, vol: u8) -> Result<()> {
+        async_command!(self.client, commands::SetVolume(vol));
+        Ok(())
+    }
+
+    fn subscribe_change(&self) -> Receiver<PlayerUpdate> {
+        let rx = self.tx.subscribe();
+        await_sync(async {
+            Self::send_update(&self.client, &self.tx, &self.music_dir)
+                .await
+                .expect("Failed to send player update");
+        });
+        rx
+    }
+}
+
+pub async fn get_client(
+    host: &str,
+    music_dir: PathBuf,
+) -> Result<Arc<MpdClient>, MpdConnectionError> {
+    let mut connections = CONNECTIONS.lock().await;
+    match connections.get(host) {
+        None => {
+            let client = MpdClient::new(host, music_dir).await?;
+            let client = Arc::new(client);
+            connections.insert(host.to_string(), Arc::clone(&client));
+            Ok(client)
+        }
+        Some(client) => {
+            if client.is_connected() {
+                Ok(Arc::clone(client))
+            } else {
+                client
+                    .send_disconnect_update()
+                    .expect("Failed to send disconnect update");
+
+                let client = MpdClient::new(host, music_dir).await?;
+                let client = Arc::new(client);
+                connections.insert(host.to_string(), Arc::clone(&client));
+                Ok(client)
+            }
+        }
+    }
+}
+
+async fn wait_for_connection(
+    host: &str,
+    interval: Duration,
+    max_retries: Option<usize>,
+) -> Result<Connection, MpdConnectionError> {
+    let mut retries = 0;
+    let max_retries = max_retries.unwrap_or(usize::MAX);
+
+    loop {
+        if retries == max_retries {
+            break Err(MpdConnectionError::MaxRetries);
+        }
+
+        retries += 1;
+
+        match try_get_mpd_conn(host).await {
+            Ok(conn) => break Ok(conn),
+            Err(err) => {
+                if retries == max_retries {
+                    break Err(MpdConnectionError::ProtocolError(err));
+                }
+            }
+        }
+
+        sleep(interval).await;
+    }
+}
+
+/// Cycles through each MPD host and
+/// returns the first one which connects,
+/// or none if there are none
+async fn try_get_mpd_conn(host: &str) -> Result<Connection, MpdProtocolError> {
+    if is_unix_socket(host) {
+        connect_unix(host).await
+    } else {
+        connect_tcp(host).await
+    }
+}
+
+fn is_unix_socket(host: &str) -> bool {
+    let path = PathBuf::from(host);
+    path.exists()
+        && path
+            .metadata()
+            .map_or(false, |metadata| metadata.file_type().is_socket())
+}
+
+async fn connect_unix(host: &str) -> Result<Connection, MpdProtocolError> {
+    let connection = UnixStream::connect(host).await?;
+    Client::connect(connection).await
+}
+
+async fn connect_tcp(host: &str) -> Result<Connection, MpdProtocolError> {
+    let connection = TcpStream::connect(host).await?;
+    Client::connect(connection).await
+}
+
+/// Attempts to read the first value for a tag
+/// (since the MPD client returns a vector of tags, or None)
+pub fn try_get_first_tag<'a>(song: &'a Song, tag: &'a Tag) -> Option<&'a str> {
+    song.tags
+        .get(tag)
+        .and_then(|vec| vec.first().map(String::as_str))
+}
+
+impl From<mpd_client::responses::Status> for Status {
+    fn from(status: mpd_client::responses::Status) -> Self {
+        Self {
+            state: PlayerState::from(status.state),
+            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,
+        }
+    }
+}
+
+impl From<PlayState> for PlayerState {
+    fn from(value: PlayState) -> Self {
+        match value {
+            PlayState::Stopped => Self::Stopped,
+            PlayState::Playing => Self::Playing,
+            PlayState::Paused => Self::Paused,
+        }
+    }
+}

src/clients/music/mpris.rs

@@ -0,0 +1,275 @@
+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::sync::{Arc, Mutex};
+use std::thread::sleep;
+use std::time::Duration;
+use tokio::sync::broadcast::{channel, Receiver, Sender};
+use tokio::task::spawn_blocking;
+use tracing::{debug, error, trace};
+
+lazy_static! {
+    static ref CLIENT: Arc<Client> = Arc::new(Client::new());
+}
+
+pub struct Client {
+    current_player: Arc<Mutex<Option<String>>>,
+    tx: Sender<PlayerUpdate>,
+    _rx: Receiver<PlayerUpdate>,
+}
+
+impl Client {
+    fn new() -> Self {
+        let (tx, rx) = channel(32);
+
+        let current_player = Arc::new(Mutex::new(None));
+
+        {
+            let players_list = Arc::new(Mutex::new(HashSet::new()));
+            let current_player = current_player.clone();
+            let tx = tx.clone();
+
+            spawn_blocking(move || {
+                let player_finder = PlayerFinder::new().expect("Failed to connect to D-Bus");
+
+                // D-Bus gives no event for new players,
+                // so we have to keep polling the player list
+                loop {
+                    let players = player_finder
+                        .find_all()
+                        .expect("Failed to connect to D-Bus");
+
+                    let mut players_list_val = lock!(players_list);
+                    for player in players {
+                        let identity = player.identity();
+
+                        if !players_list_val.contains(identity) {
+                            debug!("Adding MPRIS player '{identity}'");
+                            players_list_val.insert(identity.to_string());
+
+                            let status = player
+                                .get_playback_status()
+                                .expect("Failed to connect to D-Bus");
+
+                            {
+                                let mut current_player = lock!(current_player);
+
+                                if status == PlaybackStatus::Playing || current_player.is_none() {
+                                    debug!("Setting active player to '{identity}'");
+
+                                    current_player.replace(identity.to_string());
+                                    if let Err(err) = Self::send_update(&player, &tx) {
+                                        error!("{err:?}");
+                                    }
+                                }
+                            }
+
+                            Self::listen_player_events(
+                                identity.to_string(),
+                                players_list.clone(),
+                                current_player.clone(),
+                                tx.clone(),
+                            );
+                        }
+                    }
+
+                    // wait 1 second before re-checking players
+                    sleep(Duration::from_secs(1));
+                }
+            });
+        }
+
+        Self {
+            current_player,
+            tx,
+            _rx: rx,
+        }
+    }
+
+    fn listen_player_events(
+        player_id: String,
+        players: Arc<Mutex<HashSet<String>>>,
+        current_player: Arc<Mutex<Option<String>>>,
+        tx: Sender<PlayerUpdate>,
+    ) {
+        spawn_blocking(move || {
+            let player_finder = PlayerFinder::new()?;
+
+            if let Ok(player) = player_finder.find_by_name(&player_id) {
+                let identity = player.identity();
+
+                for event in player.events()? {
+                    trace!("Received player event from '{identity}': {event:?}");
+                    match event {
+                        Ok(Event::PlayerShutDown) => {
+                            lock!(current_player).take();
+                            lock!(players).remove(identity);
+                            break;
+                        }
+                        Ok(Event::Playing) => {
+                            lock!(current_player).replace(identity.to_string());
+
+                            if let Err(err) = Self::send_update(&player, &tx) {
+                                error!("{err:?}");
+                            }
+                        }
+                        Ok(_) => {
+                            let current_player = lock!(current_player);
+                            let current_player = current_player.as_ref();
+                            if let Some(current_player) = current_player {
+                                if current_player == identity {
+                                    if let Err(err) = Self::send_update(&player, &tx) {
+                                        error!("{err:?}");
+                                    }
+                                }
+                            }
+                        }
+                        Err(err) => error!("{err:?}"),
+                    }
+                }
+            }
+
+            Ok::<(), DBusError>(())
+        });
+    }
+
+    fn send_update(player: &Player, tx: &Sender<PlayerUpdate>) -> Result<()> {
+        debug!("Sending update using '{}'", player.identity());
+
+        let metadata = player.get_metadata()?;
+        let playback_status = player
+            .get_playback_status()
+            .unwrap_or(PlaybackStatus::Stopped);
+
+        let track_list = player.get_track_list();
+
+        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,
+            // so we can just assume next/prev will work by bodging the numbers
+            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,
+        };
+
+        let track = Track::from(metadata);
+
+        let player_update = PlayerUpdate::Update(Box::new(Some(track)), status);
+        send!(tx, player_update);
+
+        Ok(())
+    }
+
+    fn get_player(&self) -> Option<Player> {
+        let player_name = lock!(self.current_player);
+        let player_name = player_name.as_ref();
+
+        player_name.and_then(|player_name| {
+            let player_finder = PlayerFinder::new().expect("Failed to connect to D-Bus");
+            player_finder.find_by_name(player_name).ok()
+        })
+    }
+}
+
+macro_rules! command {
+    ($self:ident, $func:ident) => {
+        if let Some(player) = Self::get_player($self) {
+            player.$func()?;
+        } else {
+            error!("Could not find player");
+        }
+    };
+}
+
+impl MusicClient for Client {
+    fn play(&self) -> Result<()> {
+        command!(self, play);
+        Ok(())
+    }
+
+    fn pause(&self) -> Result<()> {
+        command!(self, pause);
+        Ok(())
+    }
+
+    fn next(&self) -> Result<()> {
+        command!(self, next);
+        Ok(())
+    }
+
+    fn prev(&self) -> Result<()> {
+        command!(self, previous);
+        Ok(())
+    }
+
+    fn set_volume_percent(&self, vol: u8) -> Result<()> {
+        if let Some(player) = Self::get_player(self) {
+            player.set_volume(vol as f64 / 100.0)?;
+        } else {
+            error!("Could not find player");
+        }
+        Ok(())
+    }
+
+    fn subscribe_change(&self) -> Receiver<PlayerUpdate> {
+        debug!("Creating new subscription");
+        let rx = self.tx.subscribe();
+
+        if let Some(player) = self.get_player() {
+            if let Err(err) = Self::send_update(&player, &self.tx) {
+                error!("{err:?}");
+            }
+        }
+
+        rx
+    }
+}
+
+pub fn get_client() -> Arc<Client> {
+    CLIENT.clone()
+}
+
+impl From<Metadata> for Track {
+    fn from(value: Metadata) -> Self {
+        const KEY_DATE: &str = "xesam:contentCreated";
+        const KEY_GENRE: &str = "xesam:genre";
+
+        Self {
+            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)
+                .map(std::string::ToString::to_string),
+            disc: value.disc_number().map(|disc| disc as u64),
+            genre: value
+                .get(KEY_GENRE)
+                .and_then(mpris::MetadataValue::as_str_array)
+                .and_then(|arr| arr.first().map(|val| (*val).to_string())),
+            track: value.track_number().map(|track| track as u64),
+            cover_path: value.art_url().map(|s| s.to_string()),
+        }
+    }
+}
+
+impl From<PlaybackStatus> for PlayerState {
+    fn from(value: PlaybackStatus) -> Self {
+        match value {
+            PlaybackStatus::Playing => Self::Playing,
+            PlaybackStatus::Paused => Self::Paused,
+            PlaybackStatus::Stopped => Self::Stopped,
+        }
+    }
+}

src/clients/system_tray.rs

@@ -0,0 +1,120 @@
+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 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::error;
+
+type Tray = BTreeMap<String, (Box<StatusNotifierItem>, Option<TrayMenu>)>;
+
+pub struct TrayEventReceiver {
+    tx: mpsc::Sender<NotifierItemCommand>,
+    b_tx: broadcast::Sender<NotifierItemMessage>,
+    _b_rx: broadcast::Receiver<NotifierItemMessage>,
+
+    tray: Arc<Mutex<Tray>>,
+}
+
+impl TrayEventReceiver {
+    async fn new() -> stray::error::Result<Self> {
+        let (tx, rx) = mpsc::channel(16);
+        let (b_tx, b_rx) = broadcast::channel(16);
+
+        let tray = StatusNotifierWatcher::new(rx).await?;
+        let mut host = tray.create_notifier_host("ironbar").await?;
+
+        let tray = Arc::new(Mutex::new(BTreeMap::new()));
+
+        {
+            let b_tx = b_tx.clone();
+            let tray = tray.clone();
+
+            spawn(async move {
+                while let Ok(message) = host.recv().await {
+                    send!(b_tx, message.clone());
+                    let mut tray = lock!(tray);
+                    match message {
+                        NotifierItemMessage::Update {
+                            address,
+                            item,
+                            menu,
+                        } => {
+                            tray.insert(address, (item, menu));
+                        }
+                        NotifierItemMessage::Remove { address } => {
+                            tray.remove(&address);
+                        }
+                    }
+                }
+
+                Ok::<(), broadcast::error::SendError<NotifierItemMessage>>(())
+            });
+        }
+
+        Ok(Self {
+            tx,
+            b_tx,
+            _b_rx: b_rx,
+            tray,
+        })
+    }
+
+    pub fn subscribe(
+        &self,
+    ) -> (
+        mpsc::Sender<NotifierItemCommand>,
+        broadcast::Receiver<NotifierItemMessage>,
+    ) {
+        let tx = self.tx.clone();
+        let b_rx = self.b_tx.subscribe();
+
+        let tray = lock!(self.tray).clone();
+        for (address, (item, menu)) in tray {
+            let update = NotifierItemMessage::Update {
+                address,
+                item,
+                menu,
+            };
+            send!(self.b_tx, update);
+        }
+
+        (tx, b_rx)
+    }
+}
+
+lazy_static! {
+    static ref CLIENT: AsyncOnce<TrayEventReceiver> = AsyncOnce::new(async {
+        const MAX_RETRIES: i32 = 10;
+
+        // sometimes this can fail
+        let mut retries = 0;
+
+        let value = loop {
+            retries += 1;
+
+            let tray = TrayEventReceiver::new().await;
+
+            match tray {
+                Ok(tray) => break Some(tray),
+                Err(err) => error!("{:?}", Report::new(err).wrap_err(format!("Failed to create StatusNotifierWatcher (attempt {retries})")))
+            }
+
+            if retries == MAX_RETRIES {
+                break None;
+            }
+        };
+
+        value.expect("Failed to create StatusNotifierWatcher")
+    });
+}
+
+pub async fn get_tray_event_client() -> &'static TrayEventReceiver {
+    CLIENT.get().await
+}

src/clients/wayland/client.rs

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

src/clients/wayland/mod.rs

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

src/clients/wayland/toplevel.rs

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

src/clients/wayland/toplevel_manager.rs

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

src/collection.rs

@@ -1,131 +0,0 @@
-use serde::Serialize;
-use std::slice::{Iter, IterMut};
-
-/// An ordered map.
-/// Internally this is just two vectors -
-/// one for keys and one for values.
-#[derive(Debug, Clone, Serialize)]
-pub struct Collection<TKey, TData> {
-    keys: Vec<TKey>,
-    values: Vec<TData>,
-}
-
-impl<TKey: PartialEq, TData> Collection<TKey, TData> {
-    pub const fn new() -> Self {
-        Self {
-            keys: vec![],
-            values: vec![],
-        }
-    }
-
-    pub fn insert(&mut self, key: TKey, value: TData) {
-        self.keys.push(key);
-        self.values.push(value);
-
-        assert_eq!(self.keys.len(), self.values.len());
-    }
-
-    pub fn get(&self, key: &TKey) -> Option<&TData> {
-        let index = self.keys.iter().position(|k| k == key);
-        match index {
-            Some(index) => self.values.get(index),
-            None => None,
-        }
-    }
-
-    pub fn get_mut(&mut self, key: &TKey) -> Option<&mut TData> {
-        let index = self.keys.iter().position(|k| k == key);
-        match index {
-            Some(index) => self.values.get_mut(index),
-            None => None,
-        }
-    }
-
-    pub fn remove(&mut self, key: &TKey) -> Option<TData> {
-        assert_eq!(self.keys.len(), self.values.len());
-
-        let index = self.keys.iter().position(|k| k == key);
-        if let Some(index) = index {
-            self.keys.remove(index);
-            Some(self.values.remove(index))
-        } else {
-            None
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.keys.len()
-    }
-
-    pub fn first(&self) -> Option<&TData> {
-        self.values.first()
-    }
-
-    pub fn as_slice(&self) -> &[TData] {
-        self.values.as_slice()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.keys.is_empty()
-    }
-
-    pub fn iter(&self) -> Iter<'_, TData> {
-        self.values.iter()
-    }
-
-    pub fn iter_mut(&mut self) -> IterMut<'_, TData> {
-        self.values.iter_mut()
-    }
-}
-
-impl<TKey: PartialEq, TData> From<(TKey, TData)> for Collection<TKey, TData> {
-    fn from((key, value): (TKey, TData)) -> Self {
-        let mut collection = Self::new();
-        collection.insert(key, value);
-        collection
-    }
-}
-
-impl<TKey: PartialEq, TData> FromIterator<(TKey, TData)> for Collection<TKey, TData> {
-    fn from_iter<T: IntoIterator<Item = (TKey, TData)>>(iter: T) -> Self {
-        let mut collection = Self::new();
-        for (key, value) in iter {
-            collection.insert(key, value);
-        }
-
-        collection
-    }
-}
-
-impl<'a, TKey: PartialEq, TData> IntoIterator for &'a Collection<TKey, TData> {
-    type Item = &'a TData;
-    type IntoIter = CollectionIntoIterator<'a, TKey, TData>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        CollectionIntoIterator {
-            collection: self,
-            index: 0,
-        }
-    }
-}
-
-pub struct CollectionIntoIterator<'a, TKey, TData> {
-    collection: &'a Collection<TKey, TData>,
-    index: usize,
-}
-
-impl<'a, TKey: PartialEq, TData> Iterator for CollectionIntoIterator<'a, TKey, TData> {
-    type Item = &'a TData;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let res = self.collection.values.get(self.index);
-        self.index += 1;
-        res
-    }
-}
-
-impl<TKey: PartialEq, TData> Default for Collection<TKey, TData> {
-    fn default() -> Self {
-        Self::new()
-    }
-}

src/config.rs

@@ -1,143 +0,0 @@
-use crate::modules::clock::ClockModule;
-use crate::modules::focused::FocusedModule;
-use crate::modules::launcher::LauncherModule;
-use crate::modules::mpd::MpdModule;
-use crate::modules::script::ScriptModule;
-use crate::modules::sysinfo::SysInfoModule;
-use crate::modules::tray::TrayModule;
-use crate::modules::workspaces::WorkspacesModule;
-use color_eyre::eyre::{Context, ContextCompat};
-use color_eyre::{eyre, Help, Report};
-use dirs::config_dir;
-use eyre::Result;
-use serde::Deserialize;
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::{env, fs};
-
-#[derive(Debug, Deserialize, Clone)]
-#[serde(tag = "type", rename_all = "kebab-case")]
-pub enum ModuleConfig {
-    Clock(ClockModule),
-    Mpd(MpdModule),
-    Tray(TrayModule),
-    Workspaces(WorkspacesModule),
-    SysInfo(SysInfoModule),
-    Launcher(LauncherModule),
-    Script(ScriptModule),
-    Focused(FocusedModule),
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[serde(untagged)]
-pub enum MonitorConfig {
-    Single(Config),
-    Multiple(Vec<Config>),
-}
-
-#[derive(Debug, Deserialize, Clone, PartialEq, Eq)]
-#[serde(rename_all = "kebab-case")]
-pub enum BarPosition {
-    Top,
-    Bottom,
-}
-
-impl Default for BarPosition {
-    fn default() -> Self {
-        Self::Bottom
-    }
-}
-
-#[derive(Debug, Deserialize, Clone, Default)]
-pub struct Config {
-    #[serde(default = "default_bar_position")]
-    pub position: BarPosition,
-    #[serde(default = "default_bar_height")]
-    pub height: i32,
-
-    pub left: Option<Vec<ModuleConfig>>,
-    pub center: Option<Vec<ModuleConfig>>,
-    pub right: Option<Vec<ModuleConfig>>,
-
-    pub monitors: Option<HashMap<String, MonitorConfig>>,
-}
-
-const fn default_bar_position() -> BarPosition {
-    BarPosition::Bottom
-}
-
-const fn default_bar_height() -> i32 {
-    42
-}
-
-impl Config {
-    pub fn load() -> Result<Self> {
-        let config_path = if let Ok(config_path) = env::var("IRONBAR_CONFIG") {
-            let path = PathBuf::from(config_path);
-            if path.exists() {
-                Ok(path)
-            } else {
-                Err(Report::msg("Specified config file does not exist")
-                    .note("Config file was specified using `IRONBAR_CONFIG` environment variable"))
-            }
-        } else {
-            Self::try_find_config()
-        }?;
-
-        Self::load_file(&config_path)
-    }
-
-    fn try_find_config() -> Result<PathBuf> {
-        let config_dir = config_dir().wrap_err("Failed to locate user config dir")?;
-
-        let extensions = vec!["json", "toml", "yaml", "yml", "corn"];
-
-        let file = extensions.into_iter().find_map(|extension| {
-            let full_path = config_dir
-                .join("ironbar")
-                .join(format!("config.{extension}"));
-
-            if Path::exists(&full_path) {
-                Some(full_path)
-            } else {
-                None
-            }
-        });
-
-        match file {
-            Some(file) => Ok(file),
-            None => Err(Report::msg("Could not find config file")),
-        }
-    }
-
-    fn load_file(path: &Path) -> Result<Self> {
-        let file = fs::read(path).wrap_err("Failed to read config file")?;
-        let extension = path
-            .extension()
-            .unwrap_or_default()
-            .to_str()
-            .unwrap_or_default();
-
-        match extension {
-            "json" => serde_json::from_slice(&file).wrap_err("Invalid JSON config"),
-            "toml" => toml::from_slice(&file).wrap_err("Invalid TOML config"),
-            "yaml" | "yml" => serde_yaml::from_slice(&file).wrap_err("Invalid YAML config"),
-            "corn" => {
-                // corn doesn't support deserialization yet
-                // so serialize the interpreted result then deserialize that
-                let file =
-                    String::from_utf8(file).wrap_err("Config file contains invalid UTF-8")?;
-                let config = cornfig::parse(&file).wrap_err("Invalid corn config")?.value;
-                Ok(serde_json::from_str(&serde_json::to_string(&config)?)?)
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-
-pub const fn default_false() -> bool {
-    false
-}
-pub const fn default_true() -> bool {
-    true
-}

src/config/impl.rs

@@ -0,0 +1,148 @@
+use super::{BarPosition, Config, MonitorConfig};
+use color_eyre::eyre::Result;
+use color_eyre::eyre::{ContextCompat, WrapErr};
+use color_eyre::{Help, Report};
+use dirs::config_dir;
+use gtk::Orientation;
+use serde::{Deserialize, Deserializer};
+use std::path::{Path, PathBuf};
+use std::{env, fs};
+use tracing::instrument;
+
+// Manually implement for better untagged enum error handling:
+// currently open pr: https://github.com/serde-rs/serde/pull/1544
+impl<'de> Deserialize<'de> for MonitorConfig {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let content =
+            <serde::__private::de::Content as serde::Deserialize>::deserialize(deserializer)?;
+
+        match <Config as serde::Deserialize>::deserialize(
+            serde::__private::de::ContentRefDeserializer::<D::Error>::new(&content),
+        ) {
+            Ok(config) => Ok(Self::Single(config)),
+            Err(outer) => match <Vec<Config> as serde::Deserialize>::deserialize(
+                serde::__private::de::ContentRefDeserializer::<D::Error>::new(&content),
+            ) {
+                Ok(config) => Ok(Self::Multiple(config)),
+                Err(inner) => {
+                    let report = Report::msg(format!(" multi-bar (c): {inner}").replace("An error occurred when deserializing: ", ""))
+                        .wrap_err(format!("single-bar (b): {outer}").replace("An error occurred when deserializing: ", ""))
+                        .wrap_err("An invalid config was found. The following errors were encountered:")
+                        .note("Both the single-bar (type b / error 1) and multi-bar (type c / error 2) config variants were tried. You can likely ignore whichever of these is not relevant to you.")
+                        .suggestion("Please see https://github.com/JakeStanger/ironbar/wiki/configuration-guide#2-pick-your-use-case for more info on the above");
+
+                    Err(serde::de::Error::custom(format!("{report:?}")))
+                }
+            },
+        }
+    }
+}
+
+impl BarPosition {
+    /// Gets the orientation the bar and widgets should use
+    /// based on this position.
+    pub fn get_orientation(self) -> Orientation {
+        if self == Self::Top || self == Self::Bottom {
+            Orientation::Horizontal
+        } else {
+            Orientation::Vertical
+        }
+    }
+
+    /// Gets the angle that label text should be displayed at
+    /// based on this position.
+    pub const fn get_angle(self) -> f64 {
+        match self {
+            Self::Top | Self::Bottom => 0.0,
+            Self::Left => 90.0,
+            Self::Right => 270.0,
+        }
+    }
+}
+
+impl Config {
+    /// Attempts to load the config file from file,
+    /// parse it and return a new instance of `Self`.
+    pub fn load() -> Result<Self> {
+        let config_path = env::var("IRONBAR_CONFIG").map_or_else(
+            |_| Self::try_find_config(),
+            |config_path| {
+                let path = PathBuf::from(config_path);
+                if path.exists() {
+                    Ok(path)
+                } else {
+                    Err(Report::msg(format!(
+                        "Specified config file does not exist: {}",
+                        path.display()
+                    ))
+                    .note("Config file was specified using `IRONBAR_CONFIG` environment variable"))
+                }
+            },
+        )?;
+
+        Self::load_file(&config_path)
+    }
+
+    /// Attempts to discover the location of the config file
+    /// by checking each valid format's extension.
+    ///
+    /// Returns the path of the first valid match, if any.
+    #[instrument]
+    fn try_find_config() -> Result<PathBuf> {
+        let config_dir = config_dir().wrap_err("Failed to locate user config dir")?;
+
+        let extensions = vec!["json", "toml", "yaml", "yml", "corn"];
+
+        let file = extensions.into_iter().find_map(|extension| {
+            let full_path = config_dir
+                .join("ironbar")
+                .join(format!("config.{extension}"));
+
+            if Path::exists(&full_path) {
+                Some(full_path)
+            } else {
+                None
+            }
+        });
+
+        file.map_or_else(
+            || {
+                Err(Report::msg("Could not find config file")
+                    .suggestion("Ironbar does not include a configuration out of the box")
+                    .suggestion("A guide on writing a config can be found on the wiki:")
+                    .suggestion("https://github.com/JakeStanger/ironbar/wiki/configuration-guide"))
+            },
+            Ok,
+        )
+    }
+
+    /// Loads the config file at the specified path
+    /// and parses it into `Self` based on its extension.
+    fn load_file(path: &Path) -> Result<Self> {
+        let file = fs::read(path).wrap_err("Failed to read config file")?;
+
+        let str = std::str::from_utf8(&file)?;
+
+        let extension = path
+            .extension()
+            .unwrap_or_default()
+            .to_str()
+            .unwrap_or_default();
+
+        match extension {
+            #[cfg(feature = "config+json")]
+            "json" => serde_json::from_str(str).wrap_err("Invalid JSON config"),
+            #[cfg(feature = "config+toml")]
+            "toml" => toml::from_str(str).wrap_err("Invalid TOML config"),
+            #[cfg(feature = "config+yaml")]
+            "yaml" | "yml" => serde_yaml::from_str(str).wrap_err("Invalid YAML config"),
+            #[cfg(feature = "config+corn")]
+            "corn" => libcorn::from_str(str).wrap_err("Invalid Corn config"),
+            _ => Err(Report::msg(format!("Unsupported config type: {extension}"))
+                .note("You may need to recompile with support if available")),
+        }
+    }
+}

src/config/mod.rs

@@ -0,0 +1,110 @@
+mod r#impl;
+mod truncate;
+
+#[cfg(feature = "clock")]
+use crate::modules::clock::ClockModule;
+use crate::modules::custom::CustomModule;
+use crate::modules::focused::FocusedModule;
+use crate::modules::launcher::LauncherModule;
+#[cfg(feature = "music")]
+use crate::modules::music::MusicModule;
+use crate::modules::script::ScriptModule;
+#[cfg(feature = "sys_info")]
+use crate::modules::sysinfo::SysInfoModule;
+#[cfg(feature = "tray")]
+use crate::modules::tray::TrayModule;
+#[cfg(feature = "workspaces")]
+use crate::modules::workspaces::WorkspacesModule;
+use crate::script::ScriptInput;
+use serde::Deserialize;
+use std::collections::HashMap;
+
+pub use self::truncate::{EllipsizeMode, TruncateMode};
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct CommonConfig {
+    pub show_if: Option<ScriptInput>,
+
+    pub on_click_left: Option<ScriptInput>,
+    pub on_click_right: Option<ScriptInput>,
+    pub on_click_middle: Option<ScriptInput>,
+    pub on_scroll_up: Option<ScriptInput>,
+    pub on_scroll_down: Option<ScriptInput>,
+
+    pub tooltip: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ModuleConfig {
+    #[cfg(feature = "clock")]
+    Clock(ClockModule),
+    Custom(CustomModule),
+    Focused(FocusedModule),
+    Launcher(LauncherModule),
+    #[cfg(feature = "music")]
+    Music(MusicModule),
+    Script(ScriptModule),
+    #[cfg(feature = "sys_info")]
+    SysInfo(SysInfoModule),
+    #[cfg(feature = "tray")]
+    Tray(TrayModule),
+    #[cfg(feature = "workspaces")]
+    Workspaces(WorkspacesModule),
+}
+
+#[derive(Debug, Clone)]
+pub enum MonitorConfig {
+    Single(Config),
+    Multiple(Vec<Config>),
+}
+
+#[derive(Debug, Deserialize, Copy, Clone, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum BarPosition {
+    Top,
+    Bottom,
+    Left,
+    Right,
+}
+
+impl Default for BarPosition {
+    fn default() -> Self {
+        Self::Bottom
+    }
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct Config {
+    #[serde(default = "default_bar_position")]
+    pub position: BarPosition,
+    #[serde(default = "default_true")]
+    pub anchor_to_edges: bool,
+    #[serde(default = "default_bar_height")]
+    pub height: i32,
+
+    /// GTK icon theme to use.
+    pub icon_theme: Option<String>,
+
+    pub start: Option<Vec<ModuleConfig>>,
+    pub center: Option<Vec<ModuleConfig>>,
+    pub end: Option<Vec<ModuleConfig>>,
+
+    pub monitors: Option<HashMap<String, MonitorConfig>>,
+}
+
+const fn default_bar_position() -> BarPosition {
+    BarPosition::Bottom
+}
+
+const fn default_bar_height() -> i32 {
+    42
+}
+
+pub const fn default_false() -> bool {
+    false
+}
+
+pub const fn default_true() -> bool {
+    true
+}

src/config/truncate.rs

@@ -0,0 +1,54 @@
+use gtk::pango::EllipsizeMode as GtkEllipsizeMode;
+use gtk::prelude::*;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Clone, Copy)]
+#[serde(rename_all = "snake_case")]
+pub enum EllipsizeMode {
+    Start,
+    Middle,
+    End,
+}
+
+impl From<EllipsizeMode> for GtkEllipsizeMode {
+    fn from(value: EllipsizeMode) -> Self {
+        match value {
+            EllipsizeMode::Start => Self::Start,
+            EllipsizeMode::Middle => Self::Middle,
+            EllipsizeMode::End => Self::End,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone, Copy)]
+#[serde(untagged)]
+pub enum TruncateMode {
+    Auto(EllipsizeMode),
+    MaxLength {
+        mode: EllipsizeMode,
+        length: Option<i32>,
+    },
+}
+
+impl TruncateMode {
+    const fn mode(&self) -> EllipsizeMode {
+        match self {
+            Self::MaxLength { mode, .. } | Self::Auto(mode) => *mode,
+        }
+    }
+
+    const fn length(&self) -> Option<i32> {
+        match self {
+            Self::Auto(_) => None,
+            Self::MaxLength { length, .. } => *length,
+        }
+    }
+
+    pub fn truncate_label(&self, label: &gtk::Label) {
+        label.set_ellipsize(self.mode().into());
+
+        if let Some(max_length) = self.length() {
+            label.set_max_width_chars(max_length);
+        }
+    }
+}

src/desktop_file.rs

@@ -0,0 +1,74 @@
+use std::collections::HashMap;
+use std::fs::File;
+use std::io;
+use std::io::BufRead;
+use std::path::PathBuf;
+use walkdir::WalkDir;
+
+/// Gets directories that should contain `.desktop` files
+/// and exist on the filesystem.
+fn find_application_dirs() -> Vec<PathBuf> {
+    let mut dirs = vec![PathBuf::from("/usr/share/applications")];
+    let user_dir = dirs::data_local_dir();
+
+    if let Some(mut user_dir) = user_dir {
+        user_dir.push("applications");
+        dirs.push(user_dir);
+    }
+
+    dirs.into_iter().filter(|dir| dir.exists()).collect()
+}
+
+/// Attempts to locate a `.desktop` file for an app id
+/// (or app class).
+///
+/// A simple case-insensitive check is performed on filename == `app_id`.
+pub fn find_desktop_file(app_id: &str) -> Option<PathBuf> {
+    let dirs = find_application_dirs();
+
+    for dir in dirs {
+        let mut walker = WalkDir::new(dir).max_depth(5).into_iter();
+
+        let entry = walker.find(|entry| match entry {
+            Ok(entry) => {
+                let file_name = entry.file_name().to_string_lossy().to_lowercase();
+                let test_name = format!("{}.desktop", app_id.to_lowercase());
+                file_name == test_name
+            }
+            _ => false,
+        });
+
+        if let Some(Ok(entry)) = entry {
+            let path = entry.path().to_owned();
+            return Some(path);
+        }
+    }
+
+    None
+}
+
+/// Parses a desktop file into a flat hashmap of keys/values.
+fn parse_desktop_file(path: PathBuf) -> io::Result<HashMap<String, String>> {
+    let file = File::open(path)?;
+    let lines = io::BufReader::new(file).lines();
+
+    let mut map = HashMap::new();
+
+    for line in lines.flatten() {
+        if let Some((key, value)) = line.split_once('=') {
+            map.insert(key.to_string(), value.to_string());
+        }
+    }
+
+    Ok(map)
+}
+
+/// Attempts to get the icon name from the app's `.desktop` file.
+pub fn get_desktop_icon_name(app_id: &str) -> Option<String> {
+    find_desktop_file(app_id).and_then(|file| {
+        let map = parse_desktop_file(file);
+        map.map_or(None, |map| {
+            map.get("Icon").map(std::string::ToString::to_string)
+        })
+    })
+}

src/dynamic_string.rs

@@ -0,0 +1,131 @@
+use crate::script::{OutputStream, Script};
+use crate::{lock, send};
+use gtk::prelude::*;
+use indexmap::IndexMap;
+use std::sync::{Arc, Mutex};
+use tokio::spawn;
+
+#[derive(Debug)]
+enum DynamicStringSegment {
+    Static(String),
+    Dynamic(Script),
+}
+
+pub struct DynamicString;
+
+impl DynamicString {
+    pub fn new<F>(input: &str, f: F) -> Self
+    where
+        F: FnMut(String) -> Continue + 'static,
+    {
+        let mut segments = vec![];
+
+        let mut chars = input.chars().collect::<Vec<_>>();
+        while !chars.is_empty() {
+            let char = &chars[..=1];
+
+            let (token, skip) = if let ['{', '{'] = char {
+                const SKIP_BRACKETS: usize = 4;
+
+                let str = chars
+                    .iter()
+                    .skip(2)
+                    .enumerate()
+                    .take_while(|(i, &c)| c != '}' && chars[i + 1] != '}')
+                    .map(|(_, c)| c)
+                    .collect::<String>();
+
+                let len = str.len();
+
+                (
+                    DynamicStringSegment::Dynamic(Script::from(str.as_str())),
+                    len + SKIP_BRACKETS,
+                )
+            } else {
+                let str = chars
+                    .iter()
+                    .enumerate()
+                    .take_while(|(i, &c)| !(c == '{' && chars[i + 1] == '{'))
+                    .map(|(_, c)| c)
+                    .collect::<String>();
+
+                let len = str.len();
+
+                (DynamicStringSegment::Static(str), len)
+            };
+
+            assert_ne!(skip, 0);
+
+            segments.push(token);
+            chars.drain(..skip);
+        }
+
+        let label_parts = Arc::new(Mutex::new(IndexMap::new()));
+        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
+
+        for (i, segment) in segments.into_iter().enumerate() {
+            match segment {
+                DynamicStringSegment::Static(str) => {
+                    lock!(label_parts).insert(i, str);
+                }
+                DynamicStringSegment::Dynamic(script) => {
+                    let tx = tx.clone();
+                    let label_parts = label_parts.clone();
+
+                    spawn(async move {
+                        script
+                            .run(|(out, _)| {
+                                if let OutputStream::Stdout(out) = out {
+                                    let mut label_parts = lock!(label_parts);
+
+                                    label_parts.insert(i, out);
+
+                                    let string = label_parts
+                                        .iter()
+                                        .map(|(_, part)| part.as_str())
+                                        .collect::<String>();
+
+                                    send!(tx, string);
+                                }
+                            })
+                            .await;
+                    });
+                }
+            }
+        }
+
+        // initialize
+        {
+            let label_parts = lock!(label_parts)
+                .iter()
+                .map(|(_, part)| part.as_str())
+                .collect::<String>();
+
+            send!(tx, label_parts);
+        }
+
+        rx.attach(None, f);
+
+        Self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test() {
+        // TODO: see if we can run gtk tests in ci
+        if gtk::init().is_ok() {
+            let label = gtk::Label::new(None);
+            DynamicString::new(
+                "Uptime: {{1000:uptime -p | cut -d ' ' -f2-}}",
+                move |string| {
+                    label.set_label(&string);
+                    Continue(true)
+                },
+            );
+        }
+    }
+}

src/error.rs

@@ -0,0 +1,13 @@
+#[repr(i32)]
+pub enum ExitCode {
+    GtkDisplay = 1,
+    CreateBars = 2,
+    Config = 3,
+}
+
+pub const ERR_OUTPUTS: &str = "GTK and Sway are reporting a different set of outputs - this is a severe bug and should never happen";
+pub const ERR_MUTEX_LOCK: &str = "Failed to get lock on Mutex";
+pub const ERR_READ_LOCK: &str = "Failed to get read lock";
+pub const ERR_WRITE_LOCK: &str = "Failed to get write lock";
+pub const ERR_CHANNEL_SEND: &str = "Failed to send message to channel";
+pub const ERR_CHANNEL_RECV: &str = "Failed to receive message from channel";

src/icon.rs

@@ -1,145 +0,0 @@
-use gtk::gdk_pixbuf::Pixbuf;
-use gtk::prelude::*;
-use gtk::{IconLookupFlags, IconTheme};
-use std::collections::HashMap;
-use std::fs::File;
-use std::io;
-use std::io::BufRead;
-use std::path::PathBuf;
-use walkdir::WalkDir;
-
-/// Gets directories that should contain `.desktop` files
-/// and exist on the filesystem.
-fn find_application_dirs() -> Vec<PathBuf> {
-    let mut dirs = vec![PathBuf::from("/usr/share/applications")];
-    let user_dir = dirs::data_local_dir();
-
-    if let Some(mut user_dir) = user_dir {
-        user_dir.push("applications");
-        dirs.push(user_dir);
-    }
-
-    dirs.into_iter().filter(|dir| dir.exists()).collect()
-}
-
-/// Attempts to locate a `.desktop` file for an app id
-/// (or app class).
-///
-/// A simple case-insensitive check is performed on filename == `app_id`.
-pub fn find_desktop_file(app_id: &str) -> Option<PathBuf> {
-    let dirs = find_application_dirs();
-
-    for dir in dirs {
-        let mut walker = WalkDir::new(dir).max_depth(5).into_iter();
-
-        let entry = walker.find(|entry| match entry {
-            Ok(entry) => {
-                let file_name = entry.file_name().to_string_lossy().to_lowercase();
-                let test_name = format!("{}.desktop", app_id.to_lowercase());
-                file_name == test_name
-            }
-            _ => false,
-        });
-
-        if let Some(Ok(entry)) = entry {
-            let path = entry.path().to_owned();
-            return Some(path);
-        }
-    }
-
-    None
-}
-
-/// Parses a desktop file into a flat hashmap of keys/values.
-fn parse_desktop_file(path: PathBuf) -> io::Result<HashMap<String, String>> {
-    let file = File::open(path)?;
-    let lines = io::BufReader::new(file).lines();
-
-    let mut map = HashMap::new();
-
-    for line in lines.flatten() {
-        if let Some((key, value)) = line.split_once('=') {
-            map.insert(key.to_string(), value.to_string());
-        }
-    }
-
-    Ok(map)
-}
-
-/// Attempts to get the icon name from the app's `.desktop` file.
-fn get_desktop_icon_name(app_id: &str) -> Option<String> {
-    match find_desktop_file(app_id) {
-        Some(file) => {
-            let map = parse_desktop_file(file);
-
-            match map {
-                Ok(map) => map.get("Icon").map(std::string::ToString::to_string),
-                Err(_) => None,
-            }
-        }
-        None => None,
-    }
-}
-
-enum IconLocation {
-    Theme(String),
-    File(PathBuf),
-}
-
-fn get_icon_location(theme: &IconTheme, app_id: &str, size: i32) -> Option<IconLocation> {
-    let has_icon = theme
-        .lookup_icon(app_id, size, IconLookupFlags::empty())
-        .is_some();
-
-    if has_icon {
-        return Some(IconLocation::Theme(app_id.to_string()));
-    }
-
-    let is_steam_game = app_id.starts_with("steam_app_");
-    if is_steam_game {
-        let steam_id: String = app_id.chars().skip("steam_app_".len()).collect();
-
-        return match dirs::data_dir() {
-            Some(dir) => {
-                let path = dir.join(format!(
-                    "icons/hicolor/32x32/apps/steam_icon_{}.png",
-                    steam_id
-                ));
-
-                return Some(IconLocation::File(path));
-            }
-            None => None,
-        };
-    }
-
-    let icon_name = get_desktop_icon_name(app_id);
-    if let Some(icon_name) = icon_name {
-        let is_path = PathBuf::from(&icon_name).exists();
-
-        return if is_path {
-            Some(IconLocation::File(PathBuf::from(icon_name)))
-        } else {
-            return Some(IconLocation::Theme(icon_name));
-        };
-    }
-
-    None
-}
-
-/// Gets the icon associated with an app.
-pub fn get_icon(theme: &IconTheme, app_id: &str, size: i32) -> Option<Pixbuf> {
-    let icon_location = get_icon_location(theme, app_id, size);
-
-    match icon_location {
-        Some(IconLocation::Theme(icon_name)) => {
-            let icon = theme.load_icon(&icon_name, size, IconLookupFlags::FORCE_SIZE);
-
-            match icon {
-                Ok(icon) => icon,
-                Err(_) => None,
-            }
-        }
-        Some(IconLocation::File(path)) => Pixbuf::from_file_at_scale(path, size, size, true).ok(),
-        None => None,
-    }
-}

src/image/gtk.rs

@@ -0,0 +1,50 @@
+use super::ImageProvider;
+use gtk::prelude::*;
+use gtk::{Button, IconTheme, Image, Label, Orientation};
+use tracing::error;
+
+#[cfg(any(feature = "music", feature = "workspaces"))]
+pub fn new_icon_button(input: &str, icon_theme: &IconTheme, size: i32) -> Button {
+    let button = Button::new();
+
+    if ImageProvider::is_definitely_image_input(input) {
+        let image = Image::new();
+        match ImageProvider::parse(input, icon_theme, size)
+            .and_then(|provider| provider.load_into_image(image.clone()))
+        {
+            Ok(_) => {
+                button.set_image(Some(&image));
+                button.set_always_show_image(true);
+            }
+            Err(err) => {
+                error!("{err:?}");
+                button.set_label(input);
+            }
+        }
+    } else {
+        button.set_label(input);
+    }
+
+    button
+}
+
+#[cfg(feature = "music")]
+pub fn new_icon_label(input: &str, icon_theme: &IconTheme, size: i32) -> gtk::Box {
+    let container = gtk::Box::new(Orientation::Horizontal, 0);
+
+    if ImageProvider::is_definitely_image_input(input) {
+        let image = Image::new();
+        container.add(&image);
+
+        if let Err(err) = ImageProvider::parse(input, icon_theme, size)
+            .and_then(|provider| provider.load_into_image(image))
+        {
+            error!("{err:?}");
+        }
+    } else {
+        let label = Label::new(Some(input));
+        container.add(&label);
+    }
+
+    container
+}

src/image/mod.rs

@@ -0,0 +1,7 @@
+#[cfg(any(feature = "music", feature = "workspaces"))]
+mod gtk;
+mod provider;
+
+#[cfg(any(feature = "music", feature = "workspaces"))]
+pub use self::gtk::*;
+pub use provider::ImageProvider;

src/image/provider.rs

@@ -0,0 +1,199 @@
+use crate::desktop_file::get_desktop_icon_name;
+use cfg_if::cfg_if;
+use color_eyre::{Help, Report, Result};
+use gtk::gdk_pixbuf::Pixbuf;
+use gtk::prelude::*;
+use gtk::{IconLookupFlags, IconTheme};
+use std::path::{Path, PathBuf};
+
+cfg_if!(
+    if #[cfg(feature = "http")] {
+        use crate::send;
+        use gtk::gio::{Cancellable, MemoryInputStream};
+        use tokio::spawn;
+        use tracing::error;
+    }
+);
+
+#[derive(Debug)]
+enum ImageLocation<'a> {
+    Icon {
+        name: String,
+        theme: &'a IconTheme,
+    },
+    Local(PathBuf),
+    Steam(String),
+    #[cfg(feature = "http")]
+    Remote(reqwest::Url),
+}
+
+pub struct ImageProvider<'a> {
+    location: ImageLocation<'a>,
+    size: i32,
+}
+
+impl<'a> ImageProvider<'a> {
+    /// Attempts to parse the image input to find its location.
+    /// Errors if no valid location type can be found.
+    ///
+    /// 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, size: i32) -> Result<Self> {
+        let location = Self::get_location(input, theme, size)?;
+        Ok(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://")
+    }
+
+    fn get_location(input: &str, theme: &'a IconTheme, size: i32) -> Result<ImageLocation<'a>> {
+        let (input_type, input_name) = input
+            .split_once(':')
+            .map_or((None, input), |(t, n)| (Some(t), n));
+
+        match input_type {
+            Some(input_type) if input_type == "icon" => Ok(ImageLocation::Icon {
+                name: input_name.to_string(),
+                theme,
+            }),
+            Some(input_type) if input_type == "file" => Ok(ImageLocation::Local(PathBuf::from(
+                input_name[2..].to_string(),
+            ))),
+            #[cfg(feature = "http")]
+            Some(input_type) if input_type == "http" || input_type == "https" => {
+                Ok(ImageLocation::Remote(input.parse()?))
+            }
+            None if input.starts_with("steam_app_") => Ok(ImageLocation::Steam(
+                input_name.chars().skip("steam_app_".len()).collect(),
+            )),
+            None if theme
+                .lookup_icon(input, size, IconLookupFlags::empty())
+                .is_some() =>
+            {
+                Ok(ImageLocation::Icon {
+                    name: input_name.to_string(),
+                    theme,
+                })
+            }
+            Some(input_type) => Err(Report::msg(format!("Unsupported image type: {input_type}"))
+                .note("You may need to recompile with support if available")),
+            None if PathBuf::from(input_name).is_file() => {
+                Ok(ImageLocation::Local(PathBuf::from(input_name)))
+            }
+            None => get_desktop_icon_name(input_name).map_or_else(
+                || Err(Report::msg("Unknown image type")),
+                |input| Self::get_location(&input, theme, size),
+            ),
+        }
+    }
+
+    /// Attempts to fetch the image from the location
+    /// and load it into the provided `GTK::Image` widget.
+    pub fn load_into_image(&self, image: gtk::Image) -> Result<()> {
+        // handle remote locations async to avoid blocking UI thread while downloading
+        #[cfg(feature = "http")]
+        if let ImageLocation::Remote(url) = &self.location {
+            let url = url.clone();
+            let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
+
+            spawn(async move {
+                let bytes = Self::get_bytes_from_http(url).await;
+                if let Ok(bytes) = bytes {
+                    send!(tx, bytes);
+                }
+            });
+
+            {
+                let size = self.size;
+                rx.attach(None, move |bytes| {
+                    let stream = MemoryInputStream::from_bytes(&bytes);
+                    let pixbuf = Pixbuf::from_stream_at_scale(
+                        &stream,
+                        size,
+                        size,
+                        true,
+                        Some(&Cancellable::new()),
+                    );
+
+                    match pixbuf {
+                        Ok(pixbuf) => image.set_pixbuf(Some(&pixbuf)),
+                        Err(err) => error!("{err:?}"),
+                    }
+
+                    Continue(false)
+                });
+            }
+        } else {
+            self.load_into_image_sync(image)?;
+        };
+
+        #[cfg(not(feature = "http"))]
+        self.load_into_image_sync(image)?;
+
+        Ok(())
+    }
+
+    fn load_into_image_sync(&self, image: gtk::Image) -> Result<()> {
+        let pixbuf = match &self.location {
+            ImageLocation::Icon { name, theme } => self.get_from_icon(name, theme),
+            ImageLocation::Local(path) => self.get_from_file(path),
+            ImageLocation::Steam(steam_id) => self.get_from_steam_id(steam_id),
+            #[cfg(feature = "http")]
+            _ => unreachable!(), // handled above
+        }?;
+
+        image.set_pixbuf(Some(&pixbuf));
+
+        Ok(())
+    }
+
+    /// Attempts to get a `Pixbuf` from the GTK icon theme.
+    fn get_from_icon(&self, name: &str, theme: &IconTheme) -> Result<Pixbuf> {
+        let pixbuf = match theme.lookup_icon(name, self.size, IconLookupFlags::empty()) {
+            Some(_) => theme.load_icon(name, self.size, IconLookupFlags::FORCE_SIZE),
+            None => Ok(None),
+        }?;
+
+        pixbuf.map_or_else(
+            || Err(Report::msg("Icon theme does not contain icon '{name}'")),
+            Ok,
+        )
+    }
+
+    /// Attempts to get a `Pixbuf` from a local file.
+    fn get_from_file(&self, path: &Path) -> Result<Pixbuf> {
+        let pixbuf = Pixbuf::from_file_at_scale(path, self.size, self.size, true)?;
+        Ok(pixbuf)
+    }
+
+    /// Attempts to get a `Pixbuf` from a local file,
+    /// using the Steam game ID to look it up.
+    fn get_from_steam_id(&self, steam_id: &str) -> Result<Pixbuf> {
+        // TODO: Can we load this from icon theme with app id `steam_icon_{}`?
+        let path = dirs::data_dir().map_or_else(
+            || Err(Report::msg("Missing XDG data dir")),
+            |dir| {
+                Ok(dir.join(format!(
+                    "icons/hicolor/32x32/apps/steam_icon_{steam_id}.png"
+                )))
+            },
+        )?;
+
+        self.get_from_file(&path)
+    }
+
+    /// Attempts to get `Bytes` from an HTTP resource asynchronously.
+    #[cfg(feature = "http")]
+    async fn get_bytes_from_http(url: reqwest::Url) -> Result<glib::Bytes> {
+        let bytes = reqwest::get(url).await?.bytes().await?;
+        Ok(glib::Bytes::from_owned(bytes))
+    }
+}

src/logging.rs

@@ -1,7 +1,8 @@
 use color_eyre::Result;
 use dirs::data_dir;
-use std::env;
+use std::{env, panic};
 use strip_ansi_escapes::Writer;
+use tracing::error;
 use tracing_appender::non_blocking::{NonBlocking, WorkerGuard};
 use tracing_error::ErrorLayer;
 use tracing_subscriber::fmt::{Layer, MakeWriter};
@@ -26,11 +27,43 @@ impl<'a> MakeWriter<'a> for MakeFileWriter {
     }
 }
 
-pub fn install_tracing() -> Result<WorkerGuard> {
+pub fn install_logging() -> Result<WorkerGuard> {
+    // Disable backtraces by default
+    if env::var("RUST_LIB_BACKTRACE").is_err() {
+        env::set_var("RUST_LIB_BACKTRACE", "0");
+    }
+
+    // keep guard in scope
+    // otherwise file logging drops
+    let guard = install_tracing()?;
+
+    let hook_builder = color_eyre::config::HookBuilder::default();
+    let (panic_hook, eyre_hook) = hook_builder.into_hooks();
+
+    eyre_hook.install()?;
+
+    // custom hook allows tracing_appender to capture panics
+    panic::set_hook(Box::new(move |panic_info| {
+        error!("{}", panic_hook.panic_report(panic_info));
+    }));
+
+    Ok(guard)
+}
+
+/// Installs tracing into the current application.
+///
+/// The returned `WorkerGuard` must remain in scope
+/// for the lifetime of the application for logging to file to work.
+fn install_tracing() -> Result<WorkerGuard> {
+    const DEFAULT_LOG: &str = "info";
+    const DEFAULT_FILE_LOG: &str = "warn";
+
     let fmt_layer = fmt::layer().with_target(true);
-    let filter_layer = EnvFilter::try_from_default_env().or_else(|_| EnvFilter::try_new("info"))?;
-    let file_filter_layer =
-        EnvFilter::try_from_default_env().or_else(|_| EnvFilter::try_new("warn"))?;
+    let filter_layer =
+        EnvFilter::try_from_env("IRONBAR_LOG").or_else(|_| EnvFilter::try_new(DEFAULT_LOG))?;
+
+    let file_filter_layer = EnvFilter::try_from_env("IRONBAR_FILE_LOG")
+        .or_else(|_| EnvFilter::try_new(DEFAULT_FILE_LOG))?;
 
     let log_path = data_dir().unwrap_or(env::current_dir()?).join("ironbar");
 

src/macros.rs

@@ -0,0 +1,89 @@
+/// Sends a message on an asynchronous `Sender` using `send()`
+/// Panics if the message cannot be sent.
+///
+/// Usage:
+///
+/// ```rs
+/// send_async!(tx, "my message");
+/// ```
+#[macro_export]
+macro_rules! send_async {
+    ($tx:expr, $msg:expr) => {
+        $tx.send($msg).await.expect($crate::error::ERR_CHANNEL_SEND)
+    };
+}
+
+/// Sends a message on an synchronous `Sender` using `send()`
+/// Panics if the message cannot be sent.
+///
+/// Usage:
+///
+/// ```rs
+/// send!(tx, "my message");
+/// ```
+#[macro_export]
+macro_rules! send {
+    ($tx:expr, $msg:expr) => {
+        $tx.send($msg).expect($crate::error::ERR_CHANNEL_SEND)
+    };
+}
+
+/// Sends a message on an synchronous `Sender` using `try_send()`
+/// Panics if the message cannot be sent.
+///
+/// Usage:
+///
+/// ```rs
+/// try_send!(tx, "my message");
+/// ```
+#[macro_export]
+macro_rules! try_send {
+    ($tx:expr, $msg:expr) => {
+        $tx.try_send($msg).expect($crate::error::ERR_CHANNEL_SEND)
+    };
+}
+
+/// Locks a `Mutex`.
+/// Panics if the `Mutex` cannot be locked.
+///
+/// Usage:
+///
+/// ```rs
+/// let mut val = lock!(my_mutex);
+/// ```
+#[macro_export]
+macro_rules! lock {
+    ($mutex:expr) => {
+        $mutex.lock().expect($crate::error::ERR_MUTEX_LOCK)
+    };
+}
+
+/// Gets a read lock on a `RwLock`.
+/// Panics if the `RwLock` cannot be locked.
+///
+/// Usage:
+///
+/// ```rs
+/// let val = read_lock!(my_rwlock);
+/// ```
+#[macro_export]
+macro_rules! read_lock {
+    ($rwlock:expr) => {
+        $rwlock.read().expect($crate::error::ERR_READ_LOCK)
+    };
+}
+
+/// Gets a write lock on a `RwLock`.
+/// Panics if the `RwLock` cannot be locked.
+///
+/// Usage:
+///
+/// ```rs
+/// let mut val = write_lock!(my_rwlock);
+/// ```
+#[macro_export]
+macro_rules! write_lock {
+    ($rwlock:expr) => {
+        $rwlock.write().expect($crate::error::ERR_WRITE_LOCK)
+    };
+}

src/main.rs

@@ -1,91 +1,94 @@
 mod bar;
-mod collection;
+mod bridge_channel;
+mod clients;
 mod config;
-mod icon;
+mod desktop_file;
+mod dynamic_string;
+mod error;
+mod image;
 mod logging;
+mod macros;
 mod modules;
 mod popup;
+mod script;
 mod style;
-mod sway;
 
 use crate::bar::create_bar;
 use crate::config::{Config, MonitorConfig};
 use crate::style::load_css;
-use crate::sway::{get_client_error, SwayOutput};
 use color_eyre::eyre::Result;
 use color_eyre::Report;
 use dirs::config_dir;
 use gtk::gdk::Display;
 use gtk::prelude::*;
 use gtk::Application;
-use ksway::client::Client;
-use ksway::IpcCommand;
 use std::env;
+use std::future::Future;
+use std::path::PathBuf;
 use std::process::exit;
+use tokio::runtime::Handle;
+use tokio::task::block_in_place;
 
-use crate::logging::install_tracing;
+use crate::error::ExitCode;
+use clients::wayland::{self, WaylandClient};
 use tracing::{debug, error, info};
 
+const GTK_APP_ID: &str = "dev.jstanger.ironbar";
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    // Disable backtraces by default
-    if env::var("RUST_LIB_BACKTRACE").is_err() {
-        env::set_var("RUST_LIB_BACKTRACE", "0");
-    }
-
-    // keep guard in scope
-    // otherwise file logging drops
-    let _guard = install_tracing()?;
-
-    color_eyre::install()?;
+    let _guard = logging::install_logging();
 
     info!("Ironbar version {}", VERSION);
     info!("Starting application");
 
-    let app = Application::builder()
-        .application_id("dev.jstanger.ironbar")
-        .build();
+    let wayland_client = wayland::get_client().await;
+
+    let app = Application::builder().application_id(GTK_APP_ID).build();
 
     app.connect_activate(move |app| {
-        let display = match Display::default() {
-            Some(display) => display,
-            None => {
+        let display = Display::default().map_or_else(
+            || {
                 let report = Report::msg("Failed to get default GTK display");
                 error!("{:?}", report);
-                exit(1)
-            }
-        };
+                exit(ExitCode::GtkDisplay as i32)
+            },
+            |display| display,
+        );
 
         let config = match Config::load() {
             Ok(config) => config,
             Err(err) => {
                 error!("{:?}", err);
-                Config::default()
+                exit(ExitCode::Config as i32)
             }
         };
         debug!("Loaded config file");
 
-        if let Err(err) = create_bars(app, &display, &config) {
+        if let Err(err) = create_bars(app, &display, wayland_client, &config) {
             error!("{:?}", err);
-            exit(2);
+            exit(ExitCode::CreateBars as i32);
         }
 
         debug!("Created bars");
 
-        let style_path = match config_dir() {
-            Some(dir) => dir.join("ironbar").join("style.css"),
-            None => {
-                let report = Report::msg("Failed to locate user config dir");
-                error!("{:?}", report);
-                exit(3);
-            }
-        };
+        let style_path = env::var("IRONBAR_CSS").ok().map_or_else(
+            || {
+                config_dir().map_or_else(
+                    || {
+                        let report = Report::msg("Failed to locate user config dir");
+                        error!("{:?}", report);
+                        exit(ExitCode::CreateBars as i32);
+                    },
+                    |dir| dir.join("ironbar").join("style.css"),
+                )
+            },
+            PathBuf::from,
+        );
 
         if style_path.exists() {
             load_css(style_path);
-            debug!("Loaded CSS watcher file");
         }
     });
 
@@ -96,35 +99,44 @@ async fn main() -> Result<()> {
     Ok(())
 }
 
-fn create_bars(app: &Application, display: &Display, config: &Config) -> Result<()> {
-    let mut sway_client = match Client::connect() {
-        Ok(client) => Ok(client),
-        Err(err) => Err(get_client_error(err)),
-    }?;
+/// Creates each of the bars across each of the (configured) outputs.
+fn create_bars(
+    app: &Application,
+    display: &Display,
+    wl: &WaylandClient,
+    config: &Config,
+) -> Result<()> {
+    let outputs = wl.outputs.as_slice();
 
-    let outputs = match sway_client.ipc(IpcCommand::GetOutputs) {
-        Ok(outputs) => Ok(outputs),
-        Err(err) => Err(get_client_error(err)),
-    }?;
-
-    let outputs = serde_json::from_slice::<Vec<SwayOutput>>(&outputs)?;
+    debug!("Received {} outputs from Wayland", outputs.len());
+    debug!("Outputs: {:?}", outputs);
 
     let num_monitors = display.n_monitors();
 
     for i in 0..num_monitors {
-        let monitor = display.monitor(i).ok_or_else(|| Report::msg("GTK and Sway are reporting a different number of outputs - this is a severe bug and should never happen"))?;
-        let monitor_name = &outputs.get(i as usize).ok_or_else(|| Report::msg("GTK and Sway are reporting a different set of outputs - this is a severe bug and should never happen"))?.name;
+        let monitor = display
+            .monitor(i)
+            .ok_or_else(|| Report::msg(error::ERR_OUTPUTS))?;
+        let output = outputs
+            .get(i as usize)
+            .ok_or_else(|| Report::msg(error::ERR_OUTPUTS))?;
+        let monitor_name = &output.name;
 
         config.monitors.as_ref().map_or_else(
-            || create_bar(app, &monitor, monitor_name, config.clone()),
+            || {
+                info!("Creating bar on '{}'", monitor_name);
+                create_bar(app, &monitor, monitor_name, config.clone())
+            },
             |config| {
                 let config = config.get(monitor_name);
                 match &config {
                     Some(MonitorConfig::Single(config)) => {
+                        info!("Creating bar on '{}'", monitor_name);
                         create_bar(app, &monitor, monitor_name, config.clone())
                     }
                     Some(MonitorConfig::Multiple(configs)) => {
                         for config in configs {
+                            info!("Creating bar on '{}'", monitor_name);
                             create_bar(app, &monitor, monitor_name, config.clone())?;
                         }
 
@@ -138,3 +150,17 @@ fn create_bars(app: &Application, display: &Display, config: &Config) -> Result<
 
     Ok(())
 }
+
+/// Blocks on a `Future` until it resolves.
+///
+/// This is not an `async` operation
+/// so can be used outside of an async function.
+///
+/// Do note it must be called from within a Tokio runtime still.
+///
+/// Use sparingly! Prefer async functions wherever possible.
+///
+/// TODO: remove all instances of this once async trait funcs are stable
+pub fn await_sync<F: Future>(f: F) -> F::Output {
+    block_in_place(|| Handle::current().block_on(f))
+}

src/modules/clock.rs

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

src/modules/clock/mod.rs

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

src/modules/clock/popup.rs

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

src/modules/custom.rs

@@ -0,0 +1,309 @@
+use crate::config::CommonConfig;
+use crate::dynamic_string::DynamicString;
+use crate::image::ImageProvider;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::popup::{ButtonGeometry, Popup};
+use crate::script::Script;
+use crate::{send_async, try_send};
+use color_eyre::{Report, Result};
+use gtk::prelude::*;
+use gtk::{Button, IconTheme, Label, Orientation};
+use serde::Deserialize;
+use tokio::spawn;
+use tokio::sync::mpsc::{Receiver, Sender};
+use tracing::{debug, error};
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct CustomModule {
+    /// Container class name
+    class: Option<String>,
+    /// Widgets to add to the bar container
+    bar: Vec<Widget>,
+    /// Widgets to add to the popup container
+    popup: Option<Vec<Widget>>,
+
+    #[serde(flatten)]
+    pub common: Option<CommonConfig>,
+}
+
+/// Attempts to parse an `Orientation` from `String`
+fn try_get_orientation(orientation: &str) -> Result<Orientation> {
+    match orientation.to_lowercase().as_str() {
+        "horizontal" | "h" => Ok(Orientation::Horizontal),
+        "vertical" | "v" => Ok(Orientation::Vertical),
+        _ => Err(Report::msg("Invalid orientation string in config")),
+    }
+}
+
+/// Widget attributes
+#[derive(Debug, Deserialize, Clone)]
+pub struct Widget {
+    /// Type of GTK widget to add
+    #[serde(rename = "type")]
+    widget_type: WidgetType,
+    widgets: Option<Vec<Widget>>,
+    label: Option<String>,
+    name: Option<String>,
+    class: Option<String>,
+    on_click: Option<String>,
+    orientation: Option<String>,
+    src: Option<String>,
+    size: Option<i32>,
+}
+
+/// Supported GTK widget types
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum WidgetType {
+    Box,
+    Label,
+    Button,
+    Image,
+}
+
+impl Widget {
+    /// Creates this widget and adds it to the parent container
+    fn add_to(
+        self,
+        parent: &gtk::Box,
+        tx: Sender<ExecEvent>,
+        bar_orientation: Orientation,
+        icon_theme: &IconTheme,
+    ) {
+        match self.widget_type {
+            WidgetType::Box => parent.add(&self.into_box(&tx, bar_orientation, icon_theme)),
+            WidgetType::Label => parent.add(&self.into_label()),
+            WidgetType::Button => parent.add(&self.into_button(tx, bar_orientation)),
+            WidgetType::Image => parent.add(&self.into_image(icon_theme)),
+        }
+    }
+
+    /// Creates a `gtk::Box` from this widget
+    fn into_box(
+        self,
+        tx: &Sender<ExecEvent>,
+        bar_orientation: Orientation,
+        icon_theme: &IconTheme,
+    ) -> gtk::Box {
+        let mut builder = gtk::Box::builder();
+
+        if let Some(name) = self.name {
+            builder = builder.name(&name);
+        }
+
+        if let Some(orientation) = self.orientation {
+            builder = builder
+                .orientation(try_get_orientation(&orientation).unwrap_or(Orientation::Horizontal));
+        }
+
+        let container = builder.build();
+
+        if let Some(class) = self.class {
+            container.style_context().add_class(&class);
+        }
+
+        if let Some(widgets) = self.widgets {
+            for widget in widgets {
+                widget.add_to(&container, tx.clone(), bar_orientation, icon_theme);
+            }
+        }
+
+        container
+    }
+
+    /// Creates a `gtk::Label` from this widget
+    fn into_label(self) -> Label {
+        let mut builder = Label::builder().use_markup(true);
+
+        if let Some(name) = self.name {
+            builder = builder.name(&name);
+        }
+
+        let label = builder.build();
+
+        if let Some(class) = self.class {
+            label.style_context().add_class(&class);
+        }
+
+        let text = self.label.map_or_else(String::new, |text| text);
+
+        {
+            let label = label.clone();
+            DynamicString::new(&text, move |string| {
+                label.set_label(&string);
+                Continue(true)
+            });
+        }
+
+        label
+    }
+
+    /// Creates a `gtk::Button` from this widget
+    fn into_button(self, tx: Sender<ExecEvent>, bar_orientation: Orientation) -> Button {
+        let mut builder = Button::builder();
+
+        if let Some(name) = self.name {
+            builder = builder.name(&name);
+        }
+
+        let button = builder.build();
+
+        if let Some(text) = self.label {
+            let label = Label::new(None);
+            label.set_use_markup(true);
+            label.set_markup(&text);
+            button.add(&label);
+        }
+
+        if let Some(class) = self.class {
+            button.style_context().add_class(&class);
+        }
+
+        if let Some(exec) = self.on_click {
+            button.connect_clicked(move |button| {
+                try_send!(
+                    tx,
+                    ExecEvent {
+                        cmd: exec.clone(),
+                        geometry: Popup::button_pos(button, bar_orientation),
+                    }
+                );
+            });
+        }
+
+        button
+    }
+
+    fn into_image(self, icon_theme: &IconTheme) -> gtk::Image {
+        let mut builder = gtk::Image::builder();
+
+        if let Some(name) = self.name {
+            builder = builder.name(&name);
+        }
+
+        let gtk_image = builder.build();
+
+        if let Some(src) = self.src {
+            let size = self.size.unwrap_or(32);
+            if let Err(err) = ImageProvider::parse(&src, icon_theme, size)
+                .and_then(|image| image.load_into_image(gtk_image.clone()))
+            {
+                error!("{err:?}");
+            }
+        }
+
+        if let Some(class) = self.class {
+            gtk_image.style_context().add_class(&class);
+        }
+
+        gtk_image
+    }
+}
+
+#[derive(Debug)]
+pub struct ExecEvent {
+    cmd: String,
+    geometry: ButtonGeometry,
+}
+
+impl Module<gtk::Box> for CustomModule {
+    type SendMessage = ();
+    type ReceiveMessage = ExecEvent;
+
+    fn name() -> &'static str {
+        "custom"
+    }
+
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        mut rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        spawn(async move {
+            while let Some(event) = rx.recv().await {
+                if event.cmd.starts_with('!') {
+                    let script = Script::from(&event.cmd[1..]);
+
+                    debug!("executing command: '{}'", script.cmd);
+                    // TODO: Migrate to use script.run
+                    if let Err(err) = script.get_output().await {
+                        error!("{err:?}");
+                    }
+                } else if event.cmd == "popup:toggle" {
+                    send_async!(tx, ModuleUpdateEvent::TogglePopup(event.geometry));
+                } else if event.cmd == "popup:open" {
+                    send_async!(tx, ModuleUpdateEvent::OpenPopup(event.geometry));
+                } else if event.cmd == "popup:close" {
+                    send_async!(tx, ModuleUpdateEvent::ClosePopup);
+                } else {
+                    error!("Received invalid command: '{}'", event.cmd);
+                }
+            }
+        });
+
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<gtk::Box>> {
+        let orientation = info.bar_position.get_orientation();
+        let container = gtk::Box::builder().orientation(orientation).build();
+
+        if let Some(ref class) = self.class {
+            container.style_context().add_class(class);
+        }
+
+        self.bar.clone().into_iter().for_each(|widget| {
+            widget.add_to(
+                &container,
+                context.controller_tx.clone(),
+                orientation,
+                info.icon_theme,
+            );
+        });
+
+        let popup = self.into_popup(context.controller_tx, context.popup_rx, info);
+
+        Ok(ModuleWidget {
+            widget: container,
+            popup,
+        })
+    }
+
+    fn into_popup(
+        self,
+        tx: Sender<Self::ReceiveMessage>,
+        _rx: glib::Receiver<Self::SendMessage>,
+        info: &ModuleInfo,
+    ) -> Option<gtk::Box>
+    where
+        Self: Sized,
+    {
+        let container = gtk::Box::builder().name("popup-custom").build();
+
+        if let Some(class) = self.class {
+            container
+                .style_context()
+                .add_class(format!("popup-{class}").as_str());
+        }
+
+        if let Some(popup) = self.popup {
+            for widget in popup {
+                widget.add_to(
+                    &container,
+                    tx.clone(),
+                    Orientation::Horizontal,
+                    info.icon_theme,
+                );
+            }
+        }
+
+        container.show_all();
+
+        Some(container)
+    }
+}

src/modules/focused.rs

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

src/modules/launcher/item.rs

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

src/modules/launcher/mod.rs

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

src/modules/launcher/open_state.rs

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

src/modules/launcher/popup.rs

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

src/modules/mod.rs

@@ -4,22 +4,28 @@
 ///
 /// Clicking the widget opens a popup containing the current time
 /// with second-level precision and a calendar.
+#[cfg(feature = "clock")]
 pub mod clock;
+pub mod custom;
 pub mod focused;
 pub mod launcher;
-pub mod mpd;
+#[cfg(feature = "music")]
+pub mod music;
 pub mod script;
+#[cfg(feature = "sys_info")]
 pub mod sysinfo;
+#[cfg(feature = "tray")]
 pub mod tray;
+#[cfg(feature = "workspaces")]
 pub mod workspaces;
 
 use crate::config::BarPosition;
+use crate::popup::ButtonGeometry;
 use color_eyre::Result;
-/// Shamelessly stolen from here:
-/// <https://github.com/zeroeightysix/rustbar/blob/master/src/modules/module.rs>
 use glib::IsA;
 use gtk::gdk::Monitor;
-use gtk::{Application, Widget};
+use gtk::{Application, IconTheme, Widget};
+use tokio::sync::mpsc;
 
 #[derive(Clone)]
 pub enum ModuleLocation {
@@ -27,20 +33,72 @@ pub enum ModuleLocation {
     Center,
     Right,
 }
-
 pub struct ModuleInfo<'a> {
     pub app: &'a Application,
     pub location: ModuleLocation,
-    pub bar_position: &'a BarPosition,
+    pub bar_position: BarPosition,
     pub monitor: &'a Monitor,
     pub output_name: &'a str,
+    pub icon_theme: &'a IconTheme,
+}
+
+#[derive(Debug)]
+pub enum ModuleUpdateEvent<T> {
+    /// Sends an update to the module UI
+    Update(T),
+    /// Toggles the open state of the popup.
+    TogglePopup(ButtonGeometry),
+    /// Force sets the popup open.
+    /// Takes the button X position and width.
+    OpenPopup(ButtonGeometry),
+    /// Force sets the popup closed.
+    ClosePopup,
+}
+
+pub struct WidgetContext<TSend, TReceive> {
+    pub id: usize,
+    pub tx: mpsc::Sender<ModuleUpdateEvent<TSend>>,
+    pub controller_tx: mpsc::Sender<TReceive>,
+    pub widget_rx: glib::Receiver<TSend>,
+    pub popup_rx: glib::Receiver<TSend>,
+}
+
+pub struct ModuleWidget<W: IsA<Widget>> {
+    pub widget: W,
+    pub popup: Option<gtk::Box>,
 }
 
 pub trait Module<W>
 where
     W: IsA<Widget>,
 {
-    /// Consumes the module config
-    /// and produces a GTK widget of type `W`
-    fn into_widget(self, info: &ModuleInfo) -> Result<W>;
+    type SendMessage;
+    type ReceiveMessage;
+
+    fn name() -> &'static str;
+
+    fn spawn_controller(
+        &self,
+        info: &ModuleInfo,
+        tx: mpsc::Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        rx: mpsc::Receiver<Self::ReceiveMessage>,
+    ) -> Result<()>;
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<W>>;
+
+    fn into_popup(
+        self,
+        _tx: mpsc::Sender<Self::ReceiveMessage>,
+        _rx: glib::Receiver<Self::SendMessage>,
+        _info: &ModuleInfo,
+    ) -> Option<gtk::Box>
+    where
+        Self: Sized,
+    {
+        None
+    }
 }

src/modules/mpd/client.rs

@@ -1,77 +0,0 @@
-use mpd_client::commands::responses::Status;
-use mpd_client::raw::MpdProtocolError;
-use mpd_client::{Client, Connection};
-use std::path::PathBuf;
-use std::time::Duration;
-use tokio::net::{TcpStream, UnixStream};
-use tokio::spawn;
-use tokio::time::sleep;
-
-pub async fn wait_for_connection(
-    hosts: Vec<String>,
-    interval: Duration,
-    max_retries: Option<usize>,
-) -> Option<Client> {
-    let mut retries = 0;
-
-    spawn(async move {
-        let max_retries = max_retries.unwrap_or(usize::MAX);
-        loop {
-            if retries == max_retries {
-                break None;
-            }
-
-            if let Some(conn) = try_get_mpd_conn(&hosts).await {
-                break Some(conn.0);
-            }
-
-            retries += 1;
-            sleep(interval).await;
-        }
-    })
-    .await
-    .expect("Error occurred while handling tasks")
-}
-
-/// Cycles through each MPD host and
-/// returns the first one which connects,
-/// or none if there are none
-async fn try_get_mpd_conn(hosts: &[String]) -> Option<Connection> {
-    for host in hosts {
-        let connection = if is_unix_socket(host) {
-            connect_unix(host).await
-        } else {
-            connect_tcp(host).await
-        };
-
-        if let Ok(connection) = connection {
-            return Some(connection);
-        }
-    }
-
-    None
-}
-
-fn is_unix_socket(host: &str) -> bool {
-    PathBuf::from(host).is_file()
-}
-
-async fn connect_unix(host: &str) -> Result<Connection, MpdProtocolError> {
-    let connection = UnixStream::connect(host).await?;
-    Client::connect(connection).await
-}
-
-async fn connect_tcp(host: &str) -> Result<Connection, MpdProtocolError> {
-    let connection = TcpStream::connect(host).await?;
-    Client::connect(connection).await
-}
-
-/// Gets the duration of the current song
-pub fn get_duration(status: &Status) -> Option<u64> {
-    status.duration.map(|duration| duration.as_secs())
-}
-
-/// Gets the elapsed time of the current song
-pub fn get_elapsed(status: &Status) -> Option<u64> {
-    status.elapsed.map(|duration| duration.as_secs())
-}

src/modules/mpd/mod.rs

@@ -1,245 +0,0 @@
-mod client;
-mod popup;
-
-use self::popup::Popup;
-use crate::modules::mpd::client::{get_duration, get_elapsed, wait_for_connection};
-use crate::modules::mpd::popup::{MpdPopup, PopupEvent};
-use crate::modules::{Module, ModuleInfo};
-use color_eyre::Result;
-use dirs::{audio_dir, home_dir};
-use glib::Continue;
-use gtk::prelude::*;
-use gtk::{Button, Orientation};
-use mpd_client::commands::responses::{PlayState, Song, Status};
-use mpd_client::{commands, Tag};
-use regex::Regex;
-use serde::Deserialize;
-use std::path::PathBuf;
-use std::time::Duration;
-use tokio::spawn;
-use tokio::sync::mpsc;
-use tokio::time::sleep;
-use tracing::error;
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct MpdModule {
-    #[serde(default = "default_socket")]
-    host: String,
-    #[serde(default = "default_format")]
-    format: String,
-    #[serde(default = "default_icon_play")]
-    icon_play: Option<String>,
-    #[serde(default = "default_icon_pause")]
-    icon_pause: Option<String>,
-
-    #[serde(default = "default_music_dir")]
-    music_dir: PathBuf,
-}
-
-fn default_socket() -> String {
-    String::from("localhost:6600")
-}
-
-fn default_format() -> String {
-    String::from("{icon}  {title} / {artist}")
-}
-
-#[allow(clippy::unnecessary_wraps)]
-fn default_icon_play() -> Option<String> {
-    Some(String::from(""))
-}
-
-#[allow(clippy::unnecessary_wraps)]
-fn default_icon_pause() -> Option<String> {
-    Some(String::from(""))
-}
-
-fn default_music_dir() -> PathBuf {
-    audio_dir().unwrap_or_else(|| home_dir().map(|dir| dir.join("Music")).unwrap_or_default())
-}
-
-/// Attempts to read the first value for a tag
-/// (since the MPD client returns a vector of tags, or None)
-pub fn try_get_first_tag(vec: Option<&Vec<String>>) -> Option<&str> {
-    match vec {
-        Some(vec) => vec.first().map(String::as_str),
-        None => None,
-    }
-}
-
-/// Formats a duration given in seconds
-/// in hh:mm format
-fn format_time(time: u64) -> String {
-    let minutes = (time / 60) % 60;
-    let seconds = time % 60;
-
-    format!("{:0>2}:{:0>2}", minutes, seconds)
-}
-
-/// Extracts the formatting tokens from a formatting string
-fn get_tokens(re: &Regex, format_string: &str) -> Vec<String> {
-    re.captures_iter(format_string)
-        .map(|caps| caps[1].to_string())
-        .collect::<Vec<_>>()
-}
-
-enum Event {
-    Open,
-    Update(Box<Option<(Song, Status, String)>>),
-}
-
-impl Module<Button> for MpdModule {
-    fn into_widget(self, info: &ModuleInfo) -> Result<Button> {
-        let re = Regex::new(r"\{([\w-]+)}")?;
-        let tokens = get_tokens(&re, self.format.as_str());
-
-        let button = Button::new();
-
-        let (ui_tx, mut ui_rx) = mpsc::channel(32);
-
-        let popup = Popup::new(
-            "popup-mpd",
-            info.app,
-            info.monitor,
-            Orientation::Horizontal,
-            info.bar_position,
-        );
-        let mpd_popup = MpdPopup::new(popup, ui_tx);
-
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-        let click_tx = tx.clone();
-
-        let music_dir = self.music_dir.clone();
-
-        button.connect_clicked(move |_| {
-            click_tx
-                .send(Event::Open)
-                .expect("Failed to send popup open event");
-        });
-
-        let host = self.host.clone();
-        let host2 = self.host.clone();
-        spawn(async move {
-            let client = wait_for_connection(vec![host], Duration::from_secs(1), None)
-                .await
-                .expect("Unexpected error when trying to connect to MPD server");
-
-            loop {
-                let current_song = client.command(commands::CurrentSong).await;
-                let status = client.command(commands::Status).await;
-
-                if let (Ok(Some(song)), Ok(status)) = (current_song, status) {
-                    let string = self
-                        .replace_tokens(self.format.as_str(), &tokens, &song.song, &status)
-                        .await;
-
-                    tx.send(Event::Update(Box::new(Some((song.song, status, string)))))
-                        .expect("Failed to send update event");
-                } else {
-                    tx.send(Event::Update(Box::new(None)))
-                        .expect("Failed to send update event");
-                }
-
-                sleep(Duration::from_secs(1)).await;
-            }
-        });
-
-        spawn(async move {
-            let client = wait_for_connection(vec![host2], Duration::from_secs(1), None)
-                .await
-                .expect("Unexpected error when trying to connect to MPD server");
-
-            while let Some(event) = ui_rx.recv().await {
-                let res = match event {
-                    PopupEvent::Previous => client.command(commands::Previous).await,
-                    PopupEvent::Toggle => match client.command(commands::Status).await {
-                        Ok(status) => match status.state {
-                            PlayState::Playing => client.command(commands::SetPause(true)).await,
-                            PlayState::Paused => client.command(commands::SetPause(false)).await,
-                            PlayState::Stopped => Ok(()),
-                        },
-                        Err(err) => Err(err),
-                    },
-                    PopupEvent::Next => client.command(commands::Next).await,
-                };
-
-                if let Err(err) = res {
-                    error!("Failed to send command to MPD server: {:?}", err);
-                }
-            }
-        });
-
-        {
-            let button = button.clone();
-
-            rx.attach(None, move |event| {
-                match event {
-                    Event::Open => {
-                        mpd_popup.popup.show(&button);
-                    }
-                    Event::Update(mut msg) => {
-                        if let Some((song, status, string)) = msg.take() {
-                            mpd_popup.update(&song, &status, music_dir.as_path());
-
-                            button.set_label(&string);
-                            button.show();
-                        } else {
-                            button.hide();
-                        }
-                    }
-                }
-
-                Continue(true)
-            });
-        };
-
-        Ok(button)
-    }
-}
-
-impl MpdModule {
-    /// Replaces each of the formatting tokens in the formatting string
-    /// with actual data pulled from MPD
-    async fn replace_tokens(
-        &self,
-        format_string: &str,
-        tokens: &Vec<String>,
-        song: &Song,
-        status: &Status,
-    ) -> String {
-        let mut compiled_string = format_string.to_string();
-        for token in tokens {
-            let value = self.get_token_value(song, status, token).await;
-            compiled_string =
-                compiled_string.replace(format!("{{{}}}", token).as_str(), value.as_str());
-        }
-        compiled_string
-    }
-
-    /// Converts a string format token value
-    /// into its respective MPD value.
-    pub async fn get_token_value(&self, song: &Song, status: &Status, token: &str) -> String {
-        let s = match token {
-            "icon" => {
-                let icon = match status.state {
-                    PlayState::Stopped => None,
-                    PlayState::Playing => self.icon_play.as_ref(),
-                    PlayState::Paused => self.icon_pause.as_ref(),
-                };
-                icon.map(String::as_str)
-            }
-            "title" => song.title(),
-            "album" => try_get_first_tag(song.tags.get(&Tag::Album)),
-            "artist" => try_get_first_tag(song.tags.get(&Tag::Artist)),
-            "date" => try_get_first_tag(song.tags.get(&Tag::Date)),
-            "disc" => try_get_first_tag(song.tags.get(&Tag::Disc)),
-            "genre" => try_get_first_tag(song.tags.get(&Tag::Genre)),
-            "track" => try_get_first_tag(song.tags.get(&Tag::Track)),
-            "duration" => return get_duration(status).map(format_time).unwrap_or_default(),
-
-            "elapsed" => return get_elapsed(status).map(format_time).unwrap_or_default(),
-            _ => Some(token),
-        };
-        s.unwrap_or_default().to_string()
-    }
-}

src/modules/mpd/popup.rs

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

src/modules/music/config.rs

@@ -0,0 +1,140 @@
+use crate::config::{CommonConfig, TruncateMode};
+use dirs::{audio_dir, home_dir};
+use serde::Deserialize;
+use std::path::PathBuf;
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct Icons {
+    /// Icon to display when playing.
+    #[serde(default = "default_icon_play")]
+    pub(crate) play: String,
+
+    /// Icon to display when paused.
+    #[serde(default = "default_icon_pause")]
+    pub(crate) pause: String,
+
+    /// Icon to display for previous button.
+    #[serde(default = "default_icon_prev")]
+    pub(crate) prev: String,
+
+    /// Icon to display for next button.
+    #[serde(default = "default_icon_next")]
+    pub(crate) next: String,
+
+    /// Icon to display under volume slider
+    #[serde(default = "default_icon_volume")]
+    pub(crate) volume: String,
+
+    /// Icon to display nex to track title
+    #[serde(default = "default_icon_track")]
+    pub(crate) track: String,
+
+    /// Icon to display nex to album name
+    #[serde(default = "default_icon_album")]
+    pub(crate) album: String,
+
+    /// Icon to display nex to artist name
+    #[serde(default = "default_icon_artist")]
+    pub(crate) artist: String,
+}
+
+impl Default for Icons {
+    fn default() -> Self {
+        Self {
+            pause: default_icon_pause(),
+            play: default_icon_play(),
+            prev: default_icon_prev(),
+            next: default_icon_next(),
+            volume: default_icon_volume(),
+            track: default_icon_track(),
+            album: default_icon_album(),
+            artist: default_icon_artist(),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone, Copy)]
+#[serde(rename_all = "snake_case")]
+pub enum PlayerType {
+    Mpd,
+    Mpris,
+}
+
+impl Default for PlayerType {
+    fn default() -> Self {
+        Self::Mpris
+    }
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct MusicModule {
+    /// Type of player to connect to
+    #[serde(default)]
+    pub(crate) player_type: PlayerType,
+
+    /// Format of current song info to display on the bar.
+    #[serde(default = "default_format")]
+    pub(crate) format: String,
+
+    /// Player state icons
+    #[serde(default)]
+    pub(crate) icons: Icons,
+
+    // -- MPD --
+    /// TCP or Unix socket address.
+    #[serde(default = "default_socket")]
+    pub(crate) host: String,
+    /// Path to root of music directory.
+    #[serde(default = "default_music_dir")]
+    pub(crate) music_dir: PathBuf,
+
+    // -- Common --
+    pub(crate) truncate: Option<TruncateMode>,
+
+    #[serde(flatten)]
+    pub common: Option<CommonConfig>,
+}
+
+fn default_socket() -> String {
+    String::from("localhost:6600")
+}
+
+fn default_format() -> String {
+    String::from("{title} / {artist}")
+}
+
+fn default_icon_play() -> String {
+    String::from("")
+}
+
+fn default_icon_pause() -> String {
+    String::from("")
+}
+
+fn default_icon_prev() -> String {
+    String::from("\u{f9ad}")
+}
+
+fn default_icon_next() -> String {
+    String::from("\u{f9ac}")
+}
+
+fn default_icon_volume() -> String {
+    String::from("墳")
+}
+
+fn default_icon_track() -> String {
+    String::from("\u{f886}")
+}
+
+fn default_icon_album() -> String {
+    String::from("\u{f524}")
+}
+
+fn default_icon_artist() -> String {
+    String::from("\u{fd01}")
+}
+
+fn default_music_dir() -> PathBuf {
+    audio_dir().unwrap_or_else(|| home_dir().map(|dir| dir.join("Music")).unwrap_or_default())
+}

src/modules/music/mod.rs

@@ -0,0 +1,465 @@
+mod config;
+
+use crate::clients::music::{self, MusicClient, PlayerState, PlayerUpdate, Status, Track};
+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;
+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;
+
+pub use self::config::MusicModule;
+use self::config::PlayerType;
+
+#[derive(Debug)]
+pub enum PlayerCommand {
+    Previous,
+    Play,
+    Pause,
+    Next,
+    Volume(u8),
+}
+
+/// Formats a duration given in seconds
+/// in hh:mm format
+fn format_time(duration: Duration) -> String {
+    let time = duration.as_secs();
+    let minutes = (time / 60) % 60;
+    let seconds = time % 60;
+
+    format!("{minutes:0>2}:{seconds:0>2}")
+}
+
+/// Extracts the formatting tokens from a formatting string
+fn get_tokens(re: &Regex, format_string: &str) -> Vec<String> {
+    re.captures_iter(format_string)
+        .map(|caps| caps[1].to_string())
+        .collect::<Vec<_>>()
+}
+
+#[derive(Clone, Debug)]
+pub struct SongUpdate {
+    song: Track,
+    status: Status,
+    display_string: String,
+}
+
+async fn get_client(
+    player_type: PlayerType,
+    host: &str,
+    music_dir: PathBuf,
+) -> Box<Arc<dyn MusicClient>> {
+    match player_type {
+        PlayerType::Mpd => music::get_client(music::ClientType::Mpd { host, music_dir }),
+        PlayerType::Mpris => music::get_client(music::ClientType::Mpris {}),
+    }
+    .await
+}
+
+impl Module<Button> for MusicModule {
+    type SendMessage = Option<SongUpdate>;
+    type ReceiveMessage = PlayerCommand;
+
+    fn name() -> &'static str {
+        "music"
+    }
+
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        mut rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        let format = self.format.clone();
+
+        let re = Regex::new(r"\{([\w-]+)}")?;
+        let tokens = get_tokens(&re, self.format.as_str());
+
+        // receive player updates
+        {
+            let player_type = self.player_type;
+            let host = self.host.clone();
+            let music_dir = self.music_dir.clone();
+
+            spawn(async move {
+                loop {
+                    let mut rx = {
+                        let client = get_client(player_type, &host, music_dir.clone()).await;
+                        client.subscribe_change()
+                    };
+
+                    while let Ok(update) = rx.recv().await {
+                        match update {
+                            PlayerUpdate::Update(track, status) => match *track {
+                                Some(track) => {
+                                    let display_string =
+                                        replace_tokens(format.as_str(), &tokens, &track, &status);
+
+                                    let update = SongUpdate {
+                                        song: track,
+                                        status,
+                                        display_string,
+                                    };
+
+                                    send_async!(tx, ModuleUpdateEvent::Update(Some(update)));
+                                }
+                                None => send_async!(tx, ModuleUpdateEvent::Update(None)),
+                            },
+                            PlayerUpdate::Disconnect => break,
+                        }
+                    }
+                }
+            });
+        }
+
+        // listen to ui events
+        {
+            let player_type = self.player_type;
+            let host = self.host.clone();
+            let music_dir = self.music_dir.clone();
+
+            spawn(async move {
+                while let Some(event) = rx.recv().await {
+                    let client = get_client(player_type, &host, music_dir.clone()).await;
+                    let res = match event {
+                        PlayerCommand::Previous => client.prev(),
+                        PlayerCommand::Play => client.play(),
+                        PlayerCommand::Pause => client.pause(),
+                        PlayerCommand::Next => client.next(),
+                        PlayerCommand::Volume(vol) => client.set_volume_percent(vol), // .unwrap_or_else(|_| error!("Failed to update player volume")),
+                    };
+
+                    if let Err(err) = res {
+                        error!("Failed to send command to server: {:?}", err);
+                    }
+                }
+            });
+        }
+
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<Button>> {
+        let button = Button::new();
+        let button_contents = gtk::Box::new(Orientation::Horizontal, 5);
+        button.add(&button_contents);
+
+        let icon_play = new_icon_label(&self.icons.play, info.icon_theme, 24);
+        let icon_pause = new_icon_label(&self.icons.pause, info.icon_theme, 24);
+        let label = Label::new(None);
+
+        label.set_angle(info.bar_position.get_angle());
+
+        if let Some(truncate) = self.truncate {
+            truncate.truncate_label(&label);
+        }
+
+        button_contents.add(&icon_pause);
+        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(Popup::button_pos(button, orientation,))
+                );
+            });
+        }
+
+        {
+            let button = button.clone();
+            let tx = context.tx.clone();
+
+            context.widget_rx.attach(None, move |mut event| {
+                if let Some(event) = event.take() {
+                    label.set_label(&event.display_string);
+
+                    match event.status.state {
+                        PlayerState::Playing => {
+                            icon_play.show();
+                            icon_pause.hide();
+                        }
+                        PlayerState::Paused => {
+                            icon_pause.show();
+                            icon_play.hide();
+                        }
+                        PlayerState::Stopped => {
+                            button.hide();
+                        }
+                    }
+
+                    button.show();
+                } else {
+                    button.hide();
+                    try_send!(tx, ModuleUpdateEvent::ClosePopup);
+                }
+
+                Continue(true)
+            });
+        };
+
+        let popup = self.into_popup(context.controller_tx, context.popup_rx, info);
+
+        Ok(ModuleWidget {
+            widget: button,
+            popup,
+        })
+    }
+
+    fn into_popup(
+        self,
+        tx: Sender<Self::ReceiveMessage>,
+        rx: glib::Receiver<Self::SendMessage>,
+        info: &ModuleInfo,
+    ) -> Option<gtk::Box> {
+        let icon_theme = info.icon_theme;
+
+        let container = gtk::Box::builder()
+            .orientation(Orientation::Horizontal)
+            .spacing(10)
+            .name("popup-music")
+            .build();
+
+        let album_image = gtk::Image::builder()
+            .width_request(128)
+            .height_request(128)
+            .name("album-art")
+            .build();
+
+        let icons = self.icons;
+
+        let info_box = gtk::Box::new(Orientation::Vertical, 10);
+        let title_label = IconLabel::new(&icons.track, None, icon_theme);
+        let album_label = IconLabel::new(&icons.album, None, icon_theme);
+        let artist_label = IconLabel::new(&icons.artist, None, icon_theme);
+
+        title_label.container.set_widget_name("title");
+        album_label.container.set_widget_name("album");
+        artist_label.container.set_widget_name("artist");
+
+        info_box.add(&title_label.container);
+        info_box.add(&album_label.container);
+        info_box.add(&artist_label.container);
+
+        let controls_box = gtk::Box::builder().name("controls").build();
+
+        let btn_prev = new_icon_button(&icons.prev, icon_theme, 24);
+        btn_prev.set_widget_name("btn-prev");
+
+        let btn_play = new_icon_button(&icons.play, icon_theme, 24);
+        btn_play.set_widget_name("btn-play");
+
+        let btn_pause = new_icon_button(&icons.pause, icon_theme, 24);
+        btn_pause.set_widget_name("btn-pause");
+
+        let btn_next = new_icon_button(&icons.next, icon_theme, 24);
+        btn_next.set_widget_name("btn-next");
+
+        controls_box.add(&btn_prev);
+        controls_box.add(&btn_play);
+        controls_box.add(&btn_pause);
+        controls_box.add(&btn_next);
+
+        info_box.add(&controls_box);
+
+        let volume_box = gtk::Box::builder()
+            .orientation(Orientation::Vertical)
+            .spacing(5)
+            .name("volume")
+            .build();
+
+        let volume_slider = Scale::with_range(Orientation::Vertical, 0.0, 100.0, 5.0);
+        volume_slider.set_inverted(true);
+        volume_slider.set_widget_name("slider");
+
+        let volume_icon = new_icon_label(&icons.volume, icon_theme, 24);
+        volume_icon.style_context().add_class("icon");
+
+        volume_box.pack_start(&volume_slider, true, true, 0);
+        volume_box.pack_end(&volume_icon, false, false, 0);
+
+        container.add(&album_image);
+        container.add(&info_box);
+        container.add(&volume_box);
+
+        let tx_prev = tx.clone();
+        btn_prev.connect_clicked(move |_| {
+            try_send!(tx_prev, PlayerCommand::Previous);
+        });
+
+        let tx_play = tx.clone();
+        btn_play.connect_clicked(move |_| {
+            try_send!(tx_play, PlayerCommand::Play);
+        });
+
+        let tx_pause = tx.clone();
+        btn_pause.connect_clicked(move |_| {
+            try_send!(tx_pause, PlayerCommand::Pause);
+        });
+
+        let tx_next = tx.clone();
+        btn_next.connect_clicked(move |_| {
+            try_send!(tx_next, PlayerCommand::Next);
+        });
+
+        let tx_vol = tx;
+        volume_slider.connect_change_value(move |_, _, val| {
+            try_send!(tx_vol, PlayerCommand::Volume(val as u8));
+            Inhibit(false)
+        });
+
+        container.show_all();
+
+        {
+            let icon_theme = icon_theme.clone();
+
+            let mut prev_cover = None;
+            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 = match new_cover
+                            .map(|cover_path| ImageProvider::parse(&cover_path, &icon_theme, 128))
+                        {
+                            Some(Ok(image)) => image.load_into_image(album_image.clone()),
+                            Some(Err(err)) => {
+                                album_image.set_from_pixbuf(None);
+                                Err(err)
+                            }
+                            None => {
+                                album_image.set_from_pixbuf(None);
+                                Ok(())
+                            }
+                        };
+                        if let Err(err) = res {
+                            error!("{err:?}");
+                        }
+                    }
+
+                    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)
+            });
+        }
+
+        Some(container)
+    }
+}
+
+/// 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,
+    status: &Status,
+) -> String {
+    let mut compiled_string = format_string.to_string();
+    for token in tokens {
+        let value = get_token_value(song, status, token);
+        compiled_string = compiled_string.replace(format!("{{{token}}}").as_str(), value.as_str());
+    }
+    compiled_string
+}
+
+/// Converts a string format token value
+/// into its respective value.
+fn get_token_value(song: &Track, status: &Status, token: &str) -> String {
+    match token {
+        "title" => song.title.clone(),
+        "album" => song.album.clone(),
+        "artist" => song.artist.clone(),
+        "date" => song.date.clone(),
+        "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()
+}
+
+#[derive(Clone, Debug)]
+struct IconLabel {
+    label: Label,
+    container: gtk::Box,
+}
+
+impl IconLabel {
+    fn new(icon_input: &str, label: Option<&str>, icon_theme: &IconTheme) -> Self {
+        let container = gtk::Box::new(Orientation::Horizontal, 5);
+
+        let icon = new_icon_label(icon_input, icon_theme, 32);
+        let label = Label::new(label);
+
+        icon.style_context().add_class("icon");
+        label.style_context().add_class("label");
+
+        container.add(&icon);
+        container.add(&label);
+
+        Self { label, container }
+    }
+}

src/modules/script.rs

@@ -1,18 +1,33 @@
-use crate::modules::{Module, ModuleInfo};
-use color_eyre::{eyre::Report, eyre::Result, eyre::WrapErr, Section};
+use crate::config::CommonConfig;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::script::{OutputStream, Script, ScriptMode};
+use crate::try_send;
+use color_eyre::{Help, Report, Result};
 use gtk::prelude::*;
 use gtk::Label;
 use serde::Deserialize;
-use std::process::Command;
 use tokio::spawn;
-use tokio::time::sleep;
-use tracing::{error, instrument};
+use tokio::sync::mpsc::{Receiver, Sender};
+use tracing::error;
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct ScriptModule {
-    path: String,
+    /// Path to script to execute.
+    cmd: String,
+    /// Script execution mode
+    #[serde(default = "default_mode")]
+    mode: ScriptMode,
+    /// Time in milliseconds between executions.
     #[serde(default = "default_interval")]
     interval: u64,
+
+    #[serde(flatten)]
+    pub common: Option<CommonConfig>,
+}
+
+/// `Mode::Poll`
+const fn default_mode() -> ScriptMode {
+    ScriptMode::Poll
 }
 
 /// 5000ms
@@ -20,58 +35,69 @@ const fn default_interval() -> u64 {
     5000
 }
 
+impl From<&ScriptModule> for Script {
+    fn from(module: &ScriptModule) -> Self {
+        Self {
+            mode: module.mode,
+            cmd: module.cmd.clone(),
+            interval: module.interval,
+        }
+    }
+}
+
 impl Module<Label> for ScriptModule {
-    fn into_widget(self, _info: &ModuleInfo) -> Result<Label> {
-        let label = Label::builder().use_markup(true).build();
+    type SendMessage = String;
+    type ReceiveMessage = ();
+
+    fn name() -> &'static str {
+        "script"
+    }
+
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        _rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        let script: Script = self.into();
 
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
         spawn(async move {
-            loop {
-                match self.run_script() {
-                    Ok(stdout) => tx.send(stdout).expect("Failed to send stdout"),
-                    Err(err) => error!("{:?}", err),
-                }
-
-                sleep(tokio::time::Duration::from_millis(self.interval)).await;
-            }
+            script.run(move |(out, _)| match out {
+               OutputStream::Stdout(stdout) => {
+                   try_send!(tx, ModuleUpdateEvent::Update(stdout));
+               },
+               OutputStream::Stderr(stderr) => {
+                   error!("{:?}", Report::msg(stderr)
+                                    .wrap_err("Watched script error:")
+                                    .suggestion("Check the path to your script")
+                                    .suggestion("Check the script for errors")
+                                    .suggestion("If you expect the script to write to stderr, consider redirecting its output to /dev/null to suppress these messages"));
+               }
+           }).await;
         });
 
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<Label>> {
+        let label = Label::builder().use_markup(true).build();
+        label.set_angle(info.bar_position.get_angle());
+
         {
             let label = label.clone();
-            rx.attach(None, move |s| {
-                label.set_label(s.as_str());
+            context.widget_rx.attach(None, move |s| {
+                label.set_markup(s.as_str());
                 Continue(true)
             });
         }
 
-        Ok(label)
-    }
-}
-
-impl ScriptModule {
-    #[instrument]
-    fn run_script(&self) -> Result<String> {
-        let output = Command::new("sh")
-            .arg("-c")
-            .arg(&self.path)
-            .output()
-            .wrap_err("Failed to get script output")?;
-
-        if output.status.success() {
-            let stdout = String::from_utf8(output.stdout)
-                .map(|output| output.trim().to_string())
-                .wrap_err("Script stdout not valid UTF-8")?;
-
-            Ok(stdout)
-        } else {
-            let stderr = String::from_utf8(output.stderr)
-                .map(|output| output.trim().to_string())
-                .wrap_err("Script stderr not valid UTF-8")?;
-
-            Err(Report::msg(stderr)
-                .wrap_err("Script returned non-zero error code")
-                .suggestion("Check the path to your script")
-                .suggestion("Check the script for errors"))
-        }
+        Ok(ModuleWidget {
+            widget: label,
+            popup: None,
+        })
     }
 }

src/modules/sysinfo.rs

@@ -1,76 +1,397 @@
-use crate::modules::{Module, ModuleInfo};
+use crate::config::CommonConfig;
+use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
+use crate::send_async;
 use color_eyre::Result;
 use gtk::prelude::*;
-use gtk::{Label, Orientation};
+use gtk::Label;
 use regex::{Captures, Regex};
 use serde::Deserialize;
 use std::collections::HashMap;
-use sysinfo::{CpuExt, System, SystemExt};
+use std::time::Duration;
+use sysinfo::{ComponentExt, CpuExt, DiskExt, NetworkExt, RefreshKind, System, SystemExt};
 use tokio::spawn;
+use tokio::sync::mpsc;
+use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::time::sleep;
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct SysInfoModule {
+    /// List of formatting strings.
     format: Vec<String>,
+    /// Number of seconds between refresh
+    #[serde(default = "Interval::default")]
+    interval: Interval,
+
+    #[serde(flatten)]
+    pub common: Option<CommonConfig>,
+}
+
+#[derive(Debug, Deserialize, Copy, Clone)]
+pub struct Intervals {
+    #[serde(default = "default_interval")]
+    memory: u64,
+    #[serde(default = "default_interval")]
+    cpu: u64,
+    #[serde(default = "default_interval")]
+    temps: u64,
+    #[serde(default = "default_interval")]
+    disks: u64,
+    #[serde(default = "default_interval")]
+    networks: u64,
+    #[serde(default = "default_interval")]
+    system: u64,
+}
+
+#[derive(Debug, Deserialize, Copy, Clone)]
+#[serde(untagged)]
+pub enum Interval {
+    All(u64),
+    Individual(Intervals),
+}
+
+impl Default for Interval {
+    fn default() -> Self {
+        Self::All(default_interval())
+    }
+}
+
+impl Interval {
+    const fn memory(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.memory,
+        }
+    }
+
+    const fn cpu(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.cpu,
+        }
+    }
+
+    const fn temps(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.temps,
+        }
+    }
+
+    const fn disks(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.disks,
+        }
+    }
+
+    const fn networks(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.networks,
+        }
+    }
+
+    const fn system(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.system,
+        }
+    }
+}
+
+const fn default_interval() -> u64 {
+    5
+}
+
+#[derive(Debug)]
+enum RefreshType {
+    Memory,
+    Cpu,
+    Temps,
+    Disks,
+    Network,
+    System,
 }
 
 impl Module<gtk::Box> for SysInfoModule {
-    fn into_widget(self, _info: &ModuleInfo) -> Result<gtk::Box> {
-        let re = Regex::new(r"\{([\w-]+)}")?;
+    type SendMessage = HashMap<String, String>;
+    type ReceiveMessage = ();
 
-        let container = gtk::Box::new(Orientation::Horizontal, 10);
+    fn name() -> &'static str {
+        "sysinfo"
+    }
+
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        _rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        let interval = self.interval;
+
+        let refresh_kind = RefreshKind::everything()
+            .without_processes()
+            .without_users_list();
+
+        let mut sys = System::new_with_specifics(refresh_kind);
+        sys.refresh_components_list();
+        sys.refresh_disks_list();
+        sys.refresh_networks_list();
+
+        let (refresh_tx, mut refresh_rx) = mpsc::channel(16);
+
+        macro_rules! spawn_refresh {
+            ($refresh_type:expr, $func:ident) => {{
+                let tx = refresh_tx.clone();
+                spawn(async move {
+                    loop {
+                        send_async!(tx, $refresh_type);
+                        sleep(Duration::from_secs(interval.$func())).await;
+                    }
+                });
+            }};
+        }
+
+        spawn_refresh!(RefreshType::Memory, memory);
+        spawn_refresh!(RefreshType::Cpu, cpu);
+        spawn_refresh!(RefreshType::Temps, temps);
+        spawn_refresh!(RefreshType::Disks, disks);
+        spawn_refresh!(RefreshType::Network, networks);
+        spawn_refresh!(RefreshType::System, system);
+
+        spawn(async move {
+            let mut format_info = HashMap::new();
+
+            while let Some(refresh) = refresh_rx.recv().await {
+                match refresh {
+                    RefreshType::Memory => refresh_memory_tokens(&mut format_info, &mut sys),
+                    RefreshType::Cpu => refresh_cpu_tokens(&mut format_info, &mut sys),
+                    RefreshType::Temps => refresh_temp_tokens(&mut format_info, &mut sys),
+                    RefreshType::Disks => refresh_disk_tokens(&mut format_info, &mut sys),
+                    RefreshType::Network => {
+                        refresh_network_tokens(&mut format_info, &mut sys, interval.networks());
+                    }
+                    RefreshType::System => refresh_system_tokens(&mut format_info, &sys),
+                };
+
+                send_async!(tx, ModuleUpdateEvent::Update(format_info.clone()));
+            }
+        });
+
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<gtk::Box>> {
+        let re = Regex::new(r"\{([^}]+)}")?;
+
+        let container = gtk::Box::new(info.bar_position.get_orientation(), 10);
 
         let mut labels = Vec::new();
 
         for format in &self.format {
-            let label = Label::builder().label(format).name("item").build();
+            let label = Label::builder()
+                .label(format)
+                .use_markup(true)
+                .name("item")
+                .build();
+            label.set_angle(info.bar_position.get_angle());
             container.add(&label);
             labels.push(label);
         }
 
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-        spawn(async move {
-            let mut sys = System::new_all();
-
-            loop {
-                sys.refresh_all();
-
-                let mut format_info = HashMap::new();
-
-                let actual_used_memory = sys.total_memory() - sys.available_memory();
-                let memory_percent = actual_used_memory as f64 / sys.total_memory() as f64 * 100.0;
-
-                let cpu_percent = sys.global_cpu_info().cpu_usage();
-
-                // TODO: Add remaining format info
-
-                format_info.insert("memory-percent", format!("{:0>2.0}", memory_percent));
-                format_info.insert("cpu-percent", format!("{:0>2.0}", cpu_percent));
-
-                tx.send(format_info)
-                    .expect("Failed to send system info map");
-
-                sleep(tokio::time::Duration::from_secs(1)).await;
-            }
-        });
-
         {
             let formats = self.format;
-            rx.attach(None, move |info| {
+            context.widget_rx.attach(None, move |info| {
                 for (format, label) in formats.iter().zip(labels.clone()) {
-                    let format_compiled = re.replace(format, |caps: &Captures| {
+                    let format_compiled = re.replace_all(format, |caps: &Captures| {
                         info.get(&caps[1])
                             .unwrap_or(&caps[0].to_string())
                             .to_string()
                     });
 
-                    label.set_text(format_compiled.as_ref());
+                    label.set_markup(format_compiled.as_ref());
                 }
 
                 Continue(true)
             });
         }
 
-        Ok(container)
+        Ok(ModuleWidget {
+            widget: container,
+            popup: None,
+        })
     }
 }
+
+fn refresh_memory_tokens(format_info: &mut HashMap<String, String>, sys: &mut System) {
+    sys.refresh_memory();
+
+    let total_memory = sys.total_memory();
+    let available_memory = sys.available_memory();
+
+    let actual_used_memory = total_memory - available_memory;
+    let memory_percent = actual_used_memory as f64 / total_memory as f64 * 100.0;
+
+    format_info.insert(
+        String::from("memory_free"),
+        (bytes_to_gigabytes(available_memory)).to_string(),
+    );
+    format_info.insert(
+        String::from("memory_used"),
+        (bytes_to_gigabytes(actual_used_memory)).to_string(),
+    );
+    format_info.insert(
+        String::from("memory_total"),
+        (bytes_to_gigabytes(total_memory)).to_string(),
+    );
+    format_info.insert(
+        String::from("memory_percent"),
+        format!("{memory_percent:0>2.0}"),
+    );
+
+    let used_swap = sys.used_swap();
+    let total_swap = sys.total_swap();
+
+    format_info.insert(
+        String::from("swap_free"),
+        (bytes_to_gigabytes(sys.free_swap())).to_string(),
+    );
+    format_info.insert(
+        String::from("swap_used"),
+        (bytes_to_gigabytes(used_swap)).to_string(),
+    );
+    format_info.insert(
+        String::from("swap_total"),
+        (bytes_to_gigabytes(total_swap)).to_string(),
+    );
+    format_info.insert(
+        String::from("swap_percent"),
+        format!("{:0>2.0}", used_swap as f64 / total_swap as f64 * 100.0),
+    );
+}
+
+fn refresh_cpu_tokens(format_info: &mut HashMap<String, String>, sys: &mut System) {
+    sys.refresh_cpu();
+
+    let cpu_info = sys.global_cpu_info();
+    let cpu_percent = cpu_info.cpu_usage();
+
+    format_info.insert(String::from("cpu_percent"), format!("{cpu_percent:0>2.0}"));
+}
+
+fn refresh_temp_tokens(format_info: &mut HashMap<String, String>, sys: &mut System) {
+    sys.refresh_components();
+
+    let components = sys.components();
+    for component in components {
+        let key = component.label().replace(' ', "-");
+        let temp = component.temperature();
+
+        format_info.insert(format!("temp_c:{key}"), format!("{temp:.0}"));
+        format_info.insert(format!("temp_f:{key}"), format!("{:.0}", c_to_f(temp)));
+    }
+}
+
+fn refresh_disk_tokens(format_info: &mut HashMap<String, String>, sys: &mut System) {
+    sys.refresh_disks();
+
+    for disk in sys.disks() {
+        // replace braces to avoid conflict with regex
+        let key = disk
+            .mount_point()
+            .to_str()
+            .map(|s| s.replace(['{', '}'], ""));
+
+        if let Some(key) = key {
+            let total = disk.total_space();
+            let available = disk.available_space();
+            let used = total - available;
+
+            format_info.insert(
+                format!("disk_free:{key}"),
+                bytes_to_gigabytes(available).to_string(),
+            );
+
+            format_info.insert(
+                format!("disk_used:{key}"),
+                bytes_to_gigabytes(used).to_string(),
+            );
+
+            format_info.insert(
+                format!("disk_total:{key}"),
+                bytes_to_gigabytes(total).to_string(),
+            );
+
+            format_info.insert(
+                format!("disk_percent:{key}"),
+                format!("{:0>2.0}", used as f64 / total as f64 * 100.0),
+            );
+        }
+    }
+}
+
+fn refresh_network_tokens(
+    format_info: &mut HashMap<String, String>,
+    sys: &mut System,
+    interval: u64,
+) {
+    sys.refresh_networks();
+
+    for (iface, network) in sys.networks() {
+        format_info.insert(
+            format!("net_down:{iface}"),
+            format!("{:0>2.0}", bytes_to_megabits(network.received()) / interval),
+        );
+
+        format_info.insert(
+            format!("net_up:{iface}"),
+            format!(
+                "{:0>2.0}",
+                bytes_to_megabits(network.transmitted()) / interval
+            ),
+        );
+    }
+}
+
+fn refresh_system_tokens(format_info: &mut HashMap<String, String>, sys: &System) {
+    // no refresh required for these tokens
+
+    let load_average = sys.load_average();
+    format_info.insert(String::from("load_average:1"), load_average.one.to_string());
+
+    format_info.insert(
+        String::from("load_average:5"),
+        load_average.five.to_string(),
+    );
+
+    format_info.insert(
+        String::from("load_average:15"),
+        load_average.fifteen.to_string(),
+    );
+
+    let uptime = Duration::from_secs(sys.uptime()).as_secs();
+    let hours = uptime / 3600;
+    format_info.insert(
+        String::from("uptime"),
+        format!("{:0>2}:{:0>2}", hours, (uptime % 3600) / 60),
+    );
+}
+
+/// Converts celsius to fahrenheit.
+fn c_to_f(c: f32) -> f32 {
+    c * 9.0 / 5.0 + 32.0
+}
+
+const fn bytes_to_gigabytes(b: u64) -> u64 {
+    const BYTES_IN_GIGABYTE: u64 = 1_000_000_000;
+    b / BYTES_IN_GIGABYTE
+}
+
+const fn bytes_to_megabits(b: u64) -> u64 {
+    const BYTES_IN_MEGABIT: u64 = 125_000;
+    b / BYTES_IN_MEGABIT
+}

src/modules/tray.rs

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

src/modules/workspaces.rs

@@ -1,148 +1,273 @@
-use crate::modules::{Module, ModuleInfo};
-use crate::sway::{SwayClient, Workspace, WorkspaceEvent};
+use crate::clients::compositor::{Compositor, WorkspaceUpdate};
+use crate::config::CommonConfig;
+use crate::image::new_icon_button;
+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, Orientation};
-use ksway::{IpcCommand, IpcEvent};
+use gtk::{Button, IconTheme};
 use serde::Deserialize;
+use std::cmp::Ordering;
 use std::collections::HashMap;
 use tokio::spawn;
-use tokio::sync::mpsc;
-use tokio::task::spawn_blocking;
-use tracing::error;
+use tokio::sync::mpsc::{Receiver, Sender};
+use tracing::trace;
+
+#[derive(Debug, Deserialize, Clone, Copy, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum SortOrder {
+    /// Shows workspaces in the order they're added
+    Added,
+    /// Shows workspaces in numeric order.
+    /// Named workspaces are added to the end in alphabetical order.
+    Alphanumeric,
+}
+
+impl Default for SortOrder {
+    fn default() -> Self {
+        Self::Alphanumeric
+    }
+}
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct WorkspacesModule {
+    /// Map of actual workspace names to custom names.
     name_map: Option<HashMap<String, String>>,
 
+    /// Whether to display buttons for all monitors.
     #[serde(default = "crate::config::default_false")]
     all_monitors: bool,
+
+    #[serde(default)]
+    sort: SortOrder,
+
+    #[serde(flatten)]
+    pub common: Option<CommonConfig>,
 }
 
-impl Workspace {
-    fn as_button(&self, name_map: &HashMap<String, String>, tx: &mpsc::Sender<String>) -> Button {
-        let button = Button::builder()
-            .label(name_map.get(self.name.as_str()).unwrap_or(&self.name))
-            .build();
+/// Creates a button from a workspace
+fn create_button(
+    name: &str,
+    focused: bool,
+    name_map: &HashMap<String, String>,
+    icon_theme: &IconTheme,
+    tx: &Sender<String>,
+) -> Button {
+    let label = name_map.get(name).map_or(name, String::as_str);
 
-        let style_context = button.style_context();
-        style_context.add_class("item");
+    let button = new_icon_button(label, icon_theme, 32);
+    button.set_widget_name(name);
 
-        if self.focused {
-            style_context.add_class("focused");
+    let style_context = button.style_context();
+    style_context.add_class("item");
+
+    if focused {
+        style_context.add_class("focused");
+    }
+
+    {
+        let tx = tx.clone();
+        let name = name.to_string();
+        button.connect_clicked(move |_item| {
+            try_send!(tx, name.clone());
+        });
+    }
+
+    button
+}
+
+fn reorder_workspaces(container: &gtk::Box) {
+    let mut buttons = container
+        .children()
+        .into_iter()
+        .map(|child| (child.widget_name().to_string(), child))
+        .collect::<Vec<_>>();
+
+    buttons.sort_by(|(label_a, _), (label_b, _a)| {
+        match (label_a.parse::<i32>(), label_b.parse::<i32>()) {
+            (Ok(a), Ok(b)) => a.cmp(&b),
+            (Ok(_), Err(_)) => Ordering::Less,
+            (Err(_), Ok(_)) => Ordering::Greater,
+            (Err(_), Err(_)) => label_a.cmp(label_b),
         }
+    });
 
-        {
-            let tx = tx.clone();
-            let name = self.name.clone();
-            button.connect_clicked(move |_item| {
-                tx.try_send(name.clone())
-                    .expect("Failed to send workspace click event");
-            });
-        }
-
-        button
+    for (i, (_, button)) in buttons.into_iter().enumerate() {
+        container.reorder_child(&button, i as i32);
     }
 }
 
 impl Module<gtk::Box> for WorkspacesModule {
-    fn into_widget(self, info: &ModuleInfo) -> Result<gtk::Box> {
-        let mut sway = SwayClient::connect()?;
+    type SendMessage = WorkspaceUpdate;
+    type ReceiveMessage = String;
 
-        let container = gtk::Box::new(Orientation::Horizontal, 0);
+    fn name() -> &'static str {
+        "workspaces"
+    }
 
-        let workspaces = {
-            let raw = sway.ipc(IpcCommand::GetWorkspaces)?;
-            let workspaces = serde_json::from_slice::<Vec<Workspace>>(&raw)?;
+    fn spawn_controller(
+        &self,
+        _info: &ModuleInfo,
+        tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
+        mut rx: Receiver<Self::ReceiveMessage>,
+    ) -> Result<()> {
+        // Subscribe & send events
+        spawn(async move {
+            let mut srx = {
+                let client =
+                    Compositor::get_workspace_client().expect("Failed to get workspace client");
+                client.subscribe_workspace_change()
+            };
 
-            if self.all_monitors {
-                workspaces
-            } else {
-                workspaces
-                    .into_iter()
-                    .filter(|workspace| workspace.output == info.output_name)
-                    .collect()
-            }
-        };
+            trace!("Set up Sway workspace subscription");
 
-        let name_map = self.name_map.unwrap_or_default();
-
-        let mut button_map: HashMap<String, Button> = HashMap::new();
-
-        let (ui_tx, mut ui_rx) = mpsc::channel(32);
-
-        for workspace in workspaces {
-            let item = workspace.as_button(&name_map, &ui_tx);
-            container.add(&item);
-            button_map.insert(workspace.name, item);
-        }
-
-        let srx = sway.subscribe(vec![IpcEvent::Workspace])?;
-        let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
-
-        spawn_blocking(move || loop {
-            while let Ok((_, payload)) = srx.try_recv() {
-                match serde_json::from_slice::<WorkspaceEvent>(&payload) {
-                    Ok(payload) => tx.send(payload).expect("Failed to send workspace event"),
-                    Err(err) => error!("{:?}", err),
-                }
-            }
-
-            if let Err(err) = sway.poll() {
-                error!("{:?}", err);
+            while let Ok(payload) = srx.recv().await {
+                send_async!(tx, ModuleUpdateEvent::Update(payload));
             }
         });
 
-        {
-            let menubar = container.clone();
-            let output_name = info.output_name.to_string();
-            rx.attach(None, move |event| {
-                match event.change.as_str() {
-                    "focus" => {
-                        let old = event.old.and_then(|old| button_map.get(&old.name));
-                        if let Some(old) = old {
-                            old.style_context().remove_class("focused");
-                        }
-
-                        let new = event.current.and_then(|new| button_map.get(&new.name));
-                        if let Some(new) = new {
-                            new.style_context().add_class("focused");
-                        }
-                    }
-                    "init" => {
-                        if let Some(workspace) = event.current {
-                            if self.all_monitors || workspace.output == output_name {
-                                let item = workspace.as_button(&name_map, &ui_tx);
-
-                                item.show();
-                                menubar.add(&item);
-                                button_map.insert(workspace.name, item);
-                            }
-                        }
-                    }
-                    "empty" => {
-                        if let Some(workspace) = event.current {
-                            if let Some(item) = button_map.get(&workspace.name) {
-                                menubar.remove(item);
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-
-                Continue(true)
-            });
-        }
-
+        // Change workspace focus
         spawn(async move {
-            let mut sway = SwayClient::connect()?;
-            while let Some(name) = ui_rx.recv().await {
-                sway.run(format!("workspace {}", name))?;
+            trace!("Setting up UI event handler");
+
+            while let Some(name) = rx.recv().await {
+                let client =
+                    Compositor::get_workspace_client().expect("Failed to get workspace client");
+                client.focus(name)?;
             }
 
             Ok::<(), Report>(())
         });
 
-        Ok(container)
+        Ok(())
+    }
+
+    fn into_widget(
+        self,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        info: &ModuleInfo,
+    ) -> Result<ModuleWidget<gtk::Box>> {
+        let container = gtk::Box::new(info.bar_position.get_orientation(), 0);
+
+        let name_map = self.name_map.unwrap_or_default();
+
+        let mut button_map: HashMap<String, Button> = HashMap::new();
+
+        {
+            let container = container.clone();
+            let output_name = info.output_name.to_string();
+            let icon_theme = info.icon_theme.clone();
+
+            // keep track of whether init event has fired previously
+            // since it fires for every workspace subscriber
+            let mut has_initialized = false;
+
+            context.widget_rx.attach(None, move |event| {
+                match event {
+                    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,
+                                        &context.controller_tx,
+                                    );
+                                    container.add(&item);
+
+                                    button_map.insert(workspace.name, item);
+                                }
+                            }
+
+                            if self.sort == SortOrder::Alphanumeric {
+                                reorder_workspaces(&container);
+                            }
+
+                            container.show_all();
+                            has_initialized = true;
+                        }
+                    }
+                    WorkspaceUpdate::Focus { old, new } => {
+                        let old = button_map.get(&old);
+                        if let Some(old) = old {
+                            old.style_context().remove_class("focused");
+                        }
+
+                        let new = button_map.get(&new);
+                        if let Some(new) = new {
+                            new.style_context().add_class("focused");
+                        }
+                    }
+                    WorkspaceUpdate::Add(workspace) => {
+                        if self.all_monitors || workspace.monitor == output_name {
+                            let name = workspace.name;
+                            let item = create_button(
+                                &name,
+                                workspace.focused,
+                                &name_map,
+                                &icon_theme,
+                                &context.controller_tx,
+                            );
+
+                            container.add(&item);
+                            if self.sort == SortOrder::Alphanumeric {
+                                reorder_workspaces(&container);
+                            }
+
+                            item.show();
+
+                            if !name.is_empty() {
+                                button_map.insert(name, item);
+                            }
+                        }
+                    }
+                    WorkspaceUpdate::Move(workspace) => {
+                        if !self.all_monitors {
+                            if workspace.monitor == output_name {
+                                let name = workspace.name;
+                                let item = create_button(
+                                    &name,
+                                    workspace.focused,
+                                    &name_map,
+                                    &icon_theme,
+                                    &context.controller_tx,
+                                );
+
+                                container.add(&item);
+
+                                if self.sort == SortOrder::Alphanumeric {
+                                    reorder_workspaces(&container);
+                                }
+
+                                item.show();
+
+                                if !name.is_empty() {
+                                    button_map.insert(name, item);
+                                }
+                            } else if let Some(item) = button_map.get(&workspace.name) {
+                                container.remove(item);
+                            }
+                        }
+                    }
+                    WorkspaceUpdate::Remove(workspace) => {
+                        let button = button_map.get(&workspace);
+                        if let Some(item) = button {
+                            container.remove(item);
+                        }
+                    }
+                    WorkspaceUpdate::Update(_) => {}
+                };
+
+                Continue(true)
+            });
+        }
+
+        Ok(ModuleWidget {
+            widget: container,
+            popup: None,
+        })
     }
 }

src/popup.rs

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

src/script.rs

@@ -0,0 +1,355 @@
+use crate::send_async;
+use color_eyre::eyre::WrapErr;
+use color_eyre::{Report, Result};
+use serde::Deserialize;
+use std::fmt::{Display, Formatter};
+use std::process::Stdio;
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::process::Command;
+use tokio::sync::mpsc;
+use tokio::time::sleep;
+use tokio::{select, spawn};
+use tracing::{error, warn};
+
+#[derive(Debug, Deserialize, Clone)]
+#[serde(untagged)]
+pub enum ScriptInput {
+    String(String),
+    Struct(Script),
+}
+
+#[derive(Debug, Deserialize, Clone, Copy, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum ScriptMode {
+    Poll,
+    Watch,
+}
+
+#[derive(Debug, Clone)]
+pub enum OutputStream {
+    Stdout(String),
+    Stderr(String),
+}
+
+impl From<&str> for ScriptMode {
+    fn from(str: &str) -> Self {
+        match str {
+            "poll" | "p" => Self::Poll,
+            "watch" | "w" => Self::Watch,
+            _ => {
+                warn!("Invalid script mode: '{str}', falling back to polling");
+                Self::Poll
+            }
+        }
+    }
+}
+
+impl Default for ScriptMode {
+    fn default() -> Self {
+        Self::Poll
+    }
+}
+
+impl Display for ScriptMode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Poll => "poll",
+                Self::Watch => "watch",
+            }
+        )
+    }
+}
+
+impl ScriptMode {
+    fn try_parse(str: &str) -> Result<Self> {
+        match str {
+            "poll" | "p" => Ok(Self::Poll),
+            "watch" | "w" => Ok(Self::Watch),
+            _ => Err(Report::msg(format!("Invalid script mode: {str}"))),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct Script {
+    #[serde(default = "ScriptMode::default")]
+    pub(crate) mode: ScriptMode,
+    pub cmd: String,
+    #[serde(default = "default_interval")]
+    pub(crate) interval: u64,
+}
+
+const fn default_interval() -> u64 {
+    5000
+}
+
+impl Default for Script {
+    fn default() -> Self {
+        Self {
+            mode: ScriptMode::default(),
+            interval: default_interval(),
+            cmd: String::new(),
+        }
+    }
+}
+
+impl From<ScriptInput> for Script {
+    fn from(input: ScriptInput) -> Self {
+        match input {
+            ScriptInput::String(string) => Self::from(string.as_str()),
+            ScriptInput::Struct(script) => script,
+        }
+    }
+}
+
+#[derive(Debug)]
+enum ScriptInputToken {
+    Mode(ScriptMode),
+    Interval(u64),
+    Cmd(String),
+    Colon,
+}
+
+impl From<&str> for Script {
+    fn from(str: &str) -> Self {
+        let mut script = Self::default();
+        let mut tokens = vec![];
+
+        let mut chars = str.chars().collect::<Vec<_>>();
+        while !chars.is_empty() {
+            let char = chars[0];
+
+            let (token, skip) = match char {
+                ':' => (ScriptInputToken::Colon, 1),
+                // interval
+                '0'..='9' => {
+                    let interval_str = chars
+                        .iter()
+                        .take_while(|c| c.is_ascii_digit())
+                        .collect::<String>();
+
+                    let interval = interval_str.parse::<u64>().unwrap_or_else(|_| {
+                        warn!("Received invalid interval in script string. Falling back to default `5000ms`.");
+                        5000
+                    });
+                    (ScriptInputToken::Interval(interval), interval_str.len())
+                }
+                // watching or polling
+                'w' | 'p' => {
+                    let mode_str = chars.iter().take_while(|&c| c != &':').collect::<String>();
+                    let len = mode_str.len();
+
+                    let token = ScriptMode::try_parse(&mode_str)
+                        .map_or(ScriptInputToken::Cmd(mode_str), |mode| {
+                            ScriptInputToken::Mode(mode)
+                        });
+
+                    (token, len)
+                }
+                _ => {
+                    let cmd_str = chars.iter().take_while(|_| true).collect::<String>();
+                    let len = cmd_str.len();
+                    (ScriptInputToken::Cmd(cmd_str), len)
+                }
+            };
+
+            tokens.push(token);
+            chars.drain(..skip);
+        }
+
+        for token in tokens {
+            match token {
+                ScriptInputToken::Mode(mode) => script.mode = mode,
+                ScriptInputToken::Interval(interval) => script.interval = interval,
+                ScriptInputToken::Cmd(cmd) => script.cmd = cmd,
+                ScriptInputToken::Colon => {}
+            }
+        }
+
+        script
+    }
+}
+
+impl Script {
+    pub fn new_polling(input: ScriptInput) -> Self {
+        let mut script = Self::from(input);
+        script.mode = ScriptMode::Poll;
+        script
+    }
+
+    pub async fn run<F>(&self, callback: F)
+    where
+        F: Fn((OutputStream, bool)),
+    {
+        loop {
+            match self.mode {
+                ScriptMode::Poll => match self.get_output().await {
+                    Ok(output) => callback(output),
+                    Err(err) => error!("{err:?}"),
+                },
+                ScriptMode::Watch => match self.spawn().await {
+                    Ok(mut rx) => {
+                        while let Some(msg) = rx.recv().await {
+                            callback((msg, true));
+                        }
+                    }
+                    Err(err) => error!("{err:?}"),
+                },
+            };
+
+            sleep(tokio::time::Duration::from_millis(self.interval)).await;
+        }
+    }
+
+    /// Attempts to execute a given command,
+    /// waiting for it to finish.
+    /// If the command returns status 0,
+    /// the `stdout` is returned.
+    /// Otherwise, an `Err` variant
+    /// containing the `stderr` is returned.
+    pub async fn get_output(&self) -> Result<(OutputStream, bool)> {
+        let output = Command::new("sh")
+            .args(["-c", &self.cmd])
+            .output()
+            .await
+            .wrap_err("Failed to get script output")?;
+
+        if output.status.success() {
+            let stdout = String::from_utf8(output.stdout)
+                .map(|output| output.trim().to_string())
+                .wrap_err("Script stdout not valid UTF-8")?;
+
+            Ok((OutputStream::Stdout(stdout), true))
+        } else {
+            let stderr = String::from_utf8(output.stderr)
+                .map(|output| output.trim().to_string())
+                .wrap_err("Script stderr not valid UTF-8")?;
+
+            Ok((OutputStream::Stderr(stderr), false))
+        }
+    }
+
+    pub async fn spawn(&self) -> Result<mpsc::Receiver<OutputStream>> {
+        let mut handle = Command::new("sh")
+            .args(["-c", &self.cmd])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .stdin(Stdio::null())
+            .spawn()?;
+
+        let mut stdout_lines = BufReader::new(
+            handle
+                .stdout
+                .take()
+                .expect("Failed to take script handle stdout"),
+        )
+        .lines();
+
+        let mut stderr_lines = BufReader::new(
+            handle
+                .stderr
+                .take()
+                .expect("Failed to take script handle stderr"),
+        )
+        .lines();
+
+        let (tx, rx) = mpsc::channel(32);
+
+        spawn(async move {
+            loop {
+                select! {
+                    _ = handle.wait() => break,
+                    Ok(Some(line)) = stdout_lines.next_line() => {
+                        send_async!(tx, OutputStream::Stdout(line));
+                    }
+                    Ok(Some(line)) = stderr_lines.next_line() => {
+                        send_async!(tx, OutputStream::Stderr(line));
+                    }
+                }
+            }
+        });
+
+        Ok(rx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_basic() {
+        let cmd = "echo 'hello'";
+        let script = Script::from(cmd);
+
+        assert_eq!(script.cmd, cmd);
+        assert_eq!(script.interval, default_interval());
+        assert_eq!(script.mode, ScriptMode::default());
+    }
+
+    #[test]
+    fn test_parse_full() {
+        let cmd = "echo 'hello'";
+        let mode = ScriptMode::Watch;
+        let interval = 300;
+
+        let full_cmd = format!("{mode}:{interval}:{cmd}");
+        let script = Script::from(full_cmd.as_str());
+
+        assert_eq!(script.cmd, cmd);
+        assert_eq!(script.mode, mode);
+        assert_eq!(script.interval, interval);
+    }
+
+    #[test]
+    fn test_parse_interval_and_cmd() {
+        let cmd = "echo 'hello'";
+        let interval = 300;
+
+        let full_cmd = format!("{interval}:{cmd}");
+        let script = Script::from(full_cmd.as_str());
+
+        assert_eq!(script.cmd, cmd);
+        assert_eq!(script.interval, interval);
+        assert_eq!(script.mode, ScriptMode::default());
+    }
+
+    #[test]
+    fn test_parse_mode_and_cmd() {
+        let cmd = "echo 'hello'";
+        let mode = ScriptMode::Watch;
+
+        let full_cmd = format!("{mode}:{cmd}");
+        let script = Script::from(full_cmd.as_str());
+
+        assert_eq!(script.cmd, cmd);
+        assert_eq!(script.interval, default_interval());
+        assert_eq!(script.mode, mode);
+    }
+
+    #[test]
+    fn test_parse_cmd_with_colon() {
+        let cmd = "uptime | awk '{print \"Uptime: \" $1}'";
+        let script = Script::from(cmd);
+
+        assert_eq!(script.cmd, cmd);
+        assert_eq!(script.interval, default_interval());
+        assert_eq!(script.mode, ScriptMode::default());
+    }
+
+    #[test]
+    fn test_no_cmd() {
+        let mode = ScriptMode::Watch;
+        let interval = 300;
+
+        let full_cmd = format!("{mode}:{interval}");
+        let script = Script::from(full_cmd.as_str());
+
+        assert_eq!(script.cmd, ""); // TODO: Probably better handle this case
+        assert_eq!(script.interval, interval);
+        assert_eq!(script.mode, mode);
+    }
+}

src/style.rs

@@ -1,48 +1,59 @@
+use crate::send;
 use color_eyre::{Help, Report};
 use glib::Continue;
 use gtk::prelude::CssProviderExt;
 use gtk::{gdk, gio, CssProvider, StyleContext};
-use notify::{DebouncedEvent, RecursiveMode, Watcher};
+use notify::event::{DataChange, ModifyKind};
+use notify::{recommended_watcher, Event, EventKind, RecursiveMode, Result, Watcher};
 use std::path::PathBuf;
-use std::sync::mpsc;
 use std::time::Duration;
 use tokio::spawn;
-use tracing::{error, info};
+use tokio::time::sleep;
+use tracing::{debug, error, info};
 
+/// Attempts to load CSS file at the given path
+/// and attach if to the current GTK application.
+///
+/// Installs a file watcher and reloads CSS when
+/// write changes are detected on the file.
 pub fn load_css(style_path: PathBuf) {
     let provider = CssProvider::new();
 
-    if let Err(err) = provider.load_from_file(&gio::File::for_path(&style_path)) {
-        error!("{:?}", Report::new(err)
+    match provider.load_from_file(&gio::File::for_path(&style_path)) {
+        Ok(()) => debug!("Loaded css from '{}'", style_path.display()),
+        Err(err) => error!("{:?}", Report::new(err)
                     .wrap_err("Failed to load CSS")
                     .suggestion("Check the CSS file for errors")
                     .suggestion("GTK CSS uses a subset of the full CSS spec and many properties are not available. Ensure you are not using any unsupported property.")
-                );
-    }
+                )
+    };
 
     let screen = gdk::Screen::default().expect("Failed to get default GTK screen");
     StyleContext::add_provider_for_screen(&screen, &provider, 800);
 
-    let (watcher_tx, watcher_rx) = mpsc::channel::<DebouncedEvent>();
     let (tx, rx) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);
 
     spawn(async move {
-        match notify::watcher(watcher_tx, Duration::from_millis(500)) {
-            Ok(mut watcher) => {
-                watcher
-                    .watch(&style_path, RecursiveMode::NonRecursive)
-                    .expect("Unexpected error when attempting to watch CSS");
-
-                loop {
-                    if let Ok(DebouncedEvent::Write(path)) = watcher_rx.recv() {
-                        tx.send(path).expect("Failed to send style changed message");
-                    }
+        let mut watcher = recommended_watcher(move |res: Result<Event>| match res {
+            Ok(event) if event.kind == EventKind::Modify(ModifyKind::Data(DataChange::Any)) => {
+                debug!("{event:?}");
+                if let Some(path) = event.paths.first() {
+                    send!(tx, path.clone());
                 }
             }
-            Err(err) => error!(
-                "{:?}",
-                Report::new(err).wrap_err("Failed to start CSS watcher")
-            ),
+            Err(e) => error!("Error occurred when watching stylesheet: {:?}", e),
+            _ => {}
+        })
+        .expect("Failed to create CSS file watcher");
+
+        watcher
+            .watch(&style_path, RecursiveMode::NonRecursive)
+            .expect("Failed to start CSS file watcher");
+        debug!("Installed CSS file watcher on '{}'", style_path.display());
+
+        // avoid watcher from dropping
+        loop {
+            sleep(Duration::from_secs(1)).await;
         }
     });
 

src/sway/mod.rs

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

src/sway/node.rs

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