fixup! modules/custom: Allow json fields as format specifiers

modules/custom: Allow json fields as format specifiers
Merge pull request #2429 from khaneliman/hyprland-urgent
2023-12-21 10:22:59 +01:00 · 2023-09-07 02:49:43 +02:00 · 2023-08-30 07:57:11 +02:00 · 2023-08-24 17:00:40 +02:00 · 2023-08-23 12:52:29 -05:00 · 2023-08-23 12:14:35 -05:00
240 changed files with 18209 additions and 4670 deletions
--- a/.clang-format
+++ b/.clang-format
@ -1,6 +1,5 @@
 ---
 BasedOnStyle: Google
-AlignConsecutiveDeclarations: true
-BinPackArguments: false
+AlignConsecutiveDeclarations: false
 ColumnLimit: 100
 ...
--- a/.envrc.sample
+++ b/.envrc.sample
@ -0,0 +1 @@
+use flake
--- a/.github/workflows/freebsd.yml
+++ b/.github/workflows/freebsd.yml
@ -4,20 +4,26 @@ on: [ push, pull_request ]

 jobs:
  clang:
-    runs-on: macos-latest # until https://github.com/actions/runner/issues/385
+    # Run actions in a FreeBSD VM on the macos-12 runner
+    # https://github.com/actions/runner/issues/385 - for FreeBSD runner support
+    # https://github.com/actions/virtual-environments/issues/4060 - for lack of VirtualBox on MacOS 11 runners
+    runs-on: macos-12
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
    - name: Test in FreeBSD VM
-      uses: vmactions/freebsd-vm@v0.1.4 # aka FreeBSD 12.2
+      uses: vmactions/freebsd-vm@v0
      with:
+        mem: 2048
        usesh: true
        prepare: |
          export CPPFLAGS=-isystem/usr/local/include LDFLAGS=-L/usr/local/lib # sndio
          sed -i '' 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
          pkg install -y git #  subprojects/date
-          pkg install -y evdev-proto gtk-layer-shell gtkmm30 jsoncpp libdbusmenu \
-            libevdev libfmt libmpdclient libudev-devd meson pkgconf pulseaudio \
-            scdoc sndio spdlog
+          pkg install -y catch evdev-proto gtk-layer-shell gtkmm30 jsoncpp \
+            libdbusmenu libevdev libfmt libmpdclient libudev-devd meson \
+            pkgconf pulseaudio scdoc sndio spdlog wayland-protocols upower \
+            libinotify
        run: |
          meson build -Dman-pages=enabled
          ninja -C build
+          meson test -C build --no-rebuild --print-errorlogs --suite waybar
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@ -0,0 +1,14 @@
+name: Linter
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: DoozyX/clang-format-lint-action@v0.13
+      with:
+        source: '.'
+        extensions: 'h,cpp,c'
+        clangFormatVersion: 12
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@ -12,14 +12,21 @@ jobs:
          - debian
          - fedora
          - opensuse
+          - gentoo
+        cpp_std: [c++20]
+        include:
+          - distro: fedora
+            cpp_std: c++20

    runs-on: ubuntu-latest
    container:
      image: alexays/waybar:${{ matrix.distro }}

    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - name: configure
-        run: meson -Dman-pages=enabled build
+        run: meson -Dman-pages=enabled -Dcpp_std=${{matrix.cpp_std}} build
      - name: build
        run: ninja -C build
+      - name: test
+        run: make test
--- a/.gitignore
+++ b/.gitignore
@ -2,6 +2,8 @@
 *~
 vgcore.*
 /.vscode
+/.idea
+/.cache
 *.swp
 packagecache
 /subprojects/**/
@ -41,3 +43,4 @@ packagecache
 *.exe
 *.out
 *.app
+/.direnv/
--- a/Dockerfiles/alpine
+++ b/Dockerfiles/alpine
@ -2,4 +2,4 @@

 FROM alpine:latest

-RUN apk add --no-cache git meson alpine-sdk libinput-dev wayland-dev wayland-protocols mesa-dev libxkbcommon-dev eudev-dev pixman-dev gtkmm3-dev jsoncpp-dev pugixml-dev libnl3-dev pulseaudio-dev libmpdclient-dev sndio-dev scdoc libxkbcommon
+RUN apk add --no-cache git meson alpine-sdk libinput-dev wayland-dev wayland-protocols mesa-dev libxkbcommon-dev eudev-dev pixman-dev gtkmm3-dev jsoncpp-dev pugixml-dev libnl3-dev pulseaudio-dev libmpdclient-dev sndio-dev scdoc libxkbcommon tzdata playerctl-dev
--- a/Dockerfiles/archlinux
+++ b/Dockerfiles/archlinux
@ -3,4 +3,5 @@
 FROM archlinux:base-devel

 RUN pacman -Syu --noconfirm && \
-    pacman -S git meson base-devel libinput wayland wayland-protocols pixman libxkbcommon mesa gtkmm3 jsoncpp pugixml scdoc libpulse libdbusmenu-gtk3 libmpdclient gobject-introspection --noconfirm libxkbcommon
+    pacman -S --noconfirm git meson base-devel libinput wayland wayland-protocols pixman libxkbcommon mesa gtkmm3 jsoncpp pugixml scdoc libpulse libdbusmenu-gtk3 libmpdclient gobject-introspection libxkbcommon playerctl iniparser fftw && \
+    sed -Ei 's/#(en_(US|GB)\.UTF)/\1/' /etc/locale.gen && locale-gen
--- a/Dockerfiles/debian
+++ b/Dockerfiles/debian
@ -3,5 +3,5 @@
 FROM debian:sid

 RUN apt-get update && \
-    apt-get install -y build-essential meson ninja-build git pkg-config libinput10 libpugixml-dev libinput-dev wayland-protocols libwayland-client0 libwayland-cursor0 libwayland-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libxkbcommon-dev libudev-dev libpixman-1-dev libgtkmm-3.0-dev libjsoncpp-dev scdoc libdbusmenu-gtk3-dev libnl-3-dev libnl-genl-3-dev libpulse-dev libmpdclient-dev gobject-introspection libgirepository1.0-dev libxkbcommon-dev libxkbregistry-dev libxkbregistry0 && \
+    apt-get install -y build-essential meson ninja-build git pkg-config libinput10 libpugixml-dev libinput-dev wayland-protocols libwayland-client0 libwayland-cursor0 libwayland-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libxkbcommon-dev libudev-dev libpixman-1-dev libgtkmm-3.0-dev libjsoncpp-dev scdoc libdbusmenu-gtk3-dev libnl-3-dev libnl-genl-3-dev libpulse-dev libmpdclient-dev gobject-introspection libgirepository1.0-dev libxkbcommon-dev libxkbregistry-dev libxkbregistry0 libplayerctl-dev && \
    apt-get clean
--- a/Dockerfiles/fedora
+++ b/Dockerfiles/fedora
@ -2,11 +2,33 @@

 FROM fedora:latest

-RUN dnf install -y @c-development git-core meson scdoc 'pkgconfig(date)' \
-    'pkgconfig(dbusmenu-gtk3-0.4)' 'pkgconfig(fmt)' 'pkgconfig(gdk-pixbuf-2.0)' \
-    'pkgconfig(gio-unix-2.0)' 'pkgconfig(gtk-layer-shell-0)' 'pkgconfig(gtkmm-3.0)' \
-    'pkgconfig(jsoncpp)' 'pkgconfig(libinput)' 'pkgconfig(libmpdclient)' \
-    'pkgconfig(libnl-3.0)' 'pkgconfig(libnl-genl-3.0)' 'pkgconfig(libpulse)' \
-    'pkgconfig(libudev)' 'pkgconfig(pugixml)' 'pkgconfig(sigc++-2.0)' 'pkgconfig(spdlog)' \
-    'pkgconfig(wayland-client)' 'pkgconfig(wayland-cursor)' 'pkgconfig(wayland-protocols)' 'pkgconfig(xkbregistry)' && \
+RUN dnf install -y @c-development \
+    git-core glibc-langpack-en meson scdoc \
+    'pkgconfig(catch2)' \
+    'pkgconfig(date)' \
+    'pkgconfig(dbusmenu-gtk3-0.4)' \
+    'pkgconfig(fmt)' \
+    'pkgconfig(gdk-pixbuf-2.0)' \
+    'pkgconfig(gio-unix-2.0)' \
+    'pkgconfig(gtk-layer-shell-0)' \
+    'pkgconfig(gtkmm-3.0)' \
+    'pkgconfig(jack)' \
+    'pkgconfig(jsoncpp)' \
+    'pkgconfig(libevdev)' \
+    'pkgconfig(libinput)' \
+    'pkgconfig(libmpdclient)' \
+    'pkgconfig(libnl-3.0)' \
+    'pkgconfig(libnl-genl-3.0)' \
+    'pkgconfig(libpulse)' \
+    'pkgconfig(libudev)' \
+    'pkgconfig(playerctl)' \
+    'pkgconfig(pugixml)' \
+    'pkgconfig(sigc++-2.0)' \
+    'pkgconfig(spdlog)' \
+    'pkgconfig(upower-glib)' \
+    'pkgconfig(wayland-client)' \
+    'pkgconfig(wayland-cursor)' \
+    'pkgconfig(wayland-protocols)' \
+    'pkgconfig(wireplumber-0.4)' \
+    'pkgconfig(xkbregistry)' && \
    dnf clean all -y
--- a/Dockerfiles/gentoo
+++ b/Dockerfiles/gentoo
@ -0,0 +1,11 @@
+# vim: ft=Dockerfile
+
+FROM gentoo/stage3:latest
+
+RUN export FEATURES="-ipc-sandbox -network-sandbox -pid-sandbox -sandbox -usersandbox" && \
+		emerge --sync && \
+		eselect news read --quiet new 1>/dev/null 2>&1 && \
+		emerge --verbose --update --deep --with-bdeps=y --backtrack=30 --newuse @world && \
+		USE="wayland gtk3 gtk -doc X pulseaudio minimal" emerge dev-vcs/git dev-libs/wayland dev-libs/wayland-protocols =dev-cpp/gtkmm-3.24.6 x11-libs/libxkbcommon \
+		x11-libs/gtk+:3 dev-libs/libdbusmenu dev-libs/libnl sys-power/upower media-libs/libpulse dev-libs/libevdev media-libs/libmpdclient \
+		media-sound/sndio gui-libs/gtk-layer-shell app-text/scdoc media-sound/playerctl dev-libs/iniparser sci-libs/fftw
--- a/Dockerfiles/opensuse
+++ b/Dockerfiles/opensuse
@ -6,4 +6,4 @@ RUN zypper -n up && \
    zypper addrepo https://download.opensuse.org/repositories/X11:Wayland/openSUSE_Tumbleweed/X11:Wayland.repo | echo 'a' && \
    zypper -n refresh && \
    zypper -n install -t pattern devel_C_C++ && \
-    zypper -n install git meson clang libinput10 libinput-devel pugixml-devel libwayland-client0 libwayland-cursor0 wayland-protocols-devel wayland-devel Mesa-libEGL-devel Mesa-libGLESv2-devel libgbm-devel libxkbcommon-devel libudev-devel libpixman-1-0-devel gtkmm3-devel jsoncpp-devel libxkbregistry-devel scdoc
+    zypper -n install git meson clang libinput10 libinput-devel pugixml-devel libwayland-client0 libwayland-cursor0 wayland-protocols-devel wayland-devel Mesa-libEGL-devel Mesa-libGLESv2-devel libgbm-devel libxkbcommon-devel libudev-devel libpixman-1-0-devel gtkmm3-devel jsoncpp-devel libxkbregistry-devel scdoc playerctl-devel
--- a/7
+++ b/7
@ -16,5 +16,12 @@ install: build
 run: build
 	./build/waybar

+debug-run: build-debug
+	./build/waybar --log-level debug
+
+test:
+	meson test -C build --no-rebuild --verbose --suite waybar
+.PHONY: test
+
 clean:
 	rm -rf build
--- a/README.md
+++ b/README.md
@ -1,26 +1,32 @@
-# Waybar [![Travis](https://travis-ci.org/Alexays/Waybar.svg?branch=master)](https://travis-ci.org/Alexays/Waybar) [![Licence](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) [![Paypal Donate](https://img.shields.io/badge/Donate-Paypal-2244dd.svg)](https://paypal.me/ARouillard)<br>![Waybar](https://raw.githubusercontent.com/alexays/waybar/master/preview-2.png)
+# Waybar [![Licence](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) [![Paypal Donate](https://img.shields.io/badge/Donate-Paypal-2244dd.svg)](https://paypal.me/ARouillard)<br>![Waybar](https://raw.githubusercontent.com/alexays/waybar/master/preview-2.png)

 > Highly customizable Wayland bar for Sway and Wlroots based compositors.<br>
-> Available in Arch [community](https://www.archlinux.org/packages/community/x86_64/waybar/) or
-[AUR](https://aur.archlinux.org/packages/waybar-git/), [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar), and [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=waybar)<br>
+> Available in Arch [extra](https://www.archlinux.org/packages/extra/x86_64/waybar/) or
+[AUR](https://aur.archlinux.org/packages/waybar-git/), [Gentoo](https://packages.gentoo.org/packages/gui-apps/waybar), [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar), and [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=waybar).<br>
 > *Waybar [examples](https://github.com/Alexays/Waybar/wiki/Examples)*

 #### Current features
 - Sway (Workspaces, Binding mode, Focused window name)
+- River (Mapping mode, Tags, Focused window name)
+- Hyprland (Focused window name)
+- DWL (Tags) [requires dwl ipc patch](https://github.com/djpohly/dwl/wiki/ipc)
 - Tray [#21](https://github.com/Alexays/Waybar/issues/21)
 - Local time
 - Battery
+- UPower
 - Network
 - Bluetooth
 - Pulseaudio
+- Wireplumber
 - Disk
 - Memory
 - Cpu load average
 - Temperature
 - MPD
 - Custom scripts
+- Custom image
 - Multiple output configuration
- And much more customizations
+- And many more customizations

 #### Configuration and Styling

@ -69,6 +75,8 @@ libdbusmenu-gtk3 [Tray module]
 libmpdclient [MPD module]
 libsndio [sndio module]
 libevdev [KeyboardState module]
+xkbregistry
+upower [UPower battery module]
 ```

 **Build dependencies**
@ -80,7 +88,7 @@ scdoc
 wayland-protocols
 ```

-On Ubuntu you can install all the relevant dependencies using this command (tested with 19.10 and 20.04):
+On Ubuntu, you can install all the relevant dependencies using this command (tested with 19.10 and 20.04):

 ```
 sudo apt install \
@ -101,12 +109,15 @@ sudo apt install \
  libsigc++-2.0-dev \
  libspdlog-dev \
  libwayland-dev \
-  scdoc
+  scdoc \
+  upower \
+  libxkbregistry-dev
 ```


-Contributions welcome! - have fun :)<br>
-The style guidelines is [Google's](https://google.github.io/styleguide/cppguide.html)
+Contributions welcome!<br>
+Have fun :)<br>
+The style guidelines are [Google's](https://google.github.io/styleguide/cppguide.html)

 ## License

--- a/default.nix
+++ b/default.nix
@ -0,0 +1,10 @@
+(import
+  (
+    let lock = builtins.fromJSON (builtins.readFile ./flake.lock); in
+    fetchTarball {
+      url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
+      sha256 = lock.nodes.flake-compat.locked.narHash;
+    }
+  )
+  { src = ./.; }
+).defaultNix
--- a/flake.lock
+++ b/flake.lock
@ -0,0 +1,129 @@
+{
+  "nodes": {
+    "devshell": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1692523566,
+        "narHash": "sha256-VDJDihK6jNebVw9y3qKCVD6+6QaC/x8kxZzL4MaIPPY=",
+        "owner": "numtide",
+        "repo": "devshell",
+        "rev": "d208c58e2f7afef838add5f18a9936b12a71d695",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "devshell",
+        "type": "github"
+      }
+    },
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1673956053,
+        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems_2"
+      },
+      "locked": {
+        "lastModified": 1689068808,
+        "narHash": "sha256-6ixXo3wt24N/melDWjq70UuHQLxGV8jZvooRanIHXw0=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "919d646de7be200f3bf08cb76ae1f09402b6f9b4",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1677383253,
+        "narHash": "sha256-UfpzWfSxkfXHnb4boXZNaKsAcUrZT9Hw+tao1oZxd08=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "9952d6bc395f5841262b006fbace8dd7e143b634",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1692638711,
+        "narHash": "sha256-J0LgSFgJVGCC1+j5R2QndadWI1oumusg6hCtYAzLID4=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "91a22f76cd1716f9d0149e8a5c68424bb691de15",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "devshell": "devshell",
+        "flake-compat": "flake-compat",
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs_2"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_2": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
--- a/flake.nix
+++ b/flake.nix
@ -0,0 +1,89 @@
+{
+  description = "Highly customizable Wayland bar for Sway and Wlroots based compositors.";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    devshell.url = "github:numtide/devshell";
+    flake-utils.url = "github:numtide/flake-utils";
+    flake-compat = {
+      url = "github:edolstra/flake-compat";
+      flake = false;
+    };
+  };
+
+  outputs = { self, flake-utils, devshell, nixpkgs, flake-compat }:
+    let
+      inherit (nixpkgs) lib;
+      genSystems = lib.genAttrs [
+        "x86_64-linux"
+      ];
+
+      pkgsFor = genSystems (system:
+        import nixpkgs {
+          inherit system;
+        });
+
+      mkDate = longDate: (lib.concatStringsSep "-" [
+        (builtins.substring 0 4 longDate)
+        (builtins.substring 4 2 longDate)
+        (builtins.substring 6 2 longDate)
+      ]);
+    in
+    {
+      overlays.default = final: prev: {
+        waybar = final.callPackage ./nix/default.nix {
+          version = prev.waybar.version + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
+        };
+      };
+      packages = genSystems
+        (system:
+          (self.overlays.default pkgsFor.${system} pkgsFor.${system})
+          // {
+            default = self.packages.${system}.waybar;
+          });
+    } //
+    flake-utils.lib.eachDefaultSystem (system: {
+      devShell =
+        let pkgs = import nixpkgs {
+          inherit system;
+
+          overlays = [ devshell.overlays.default ];
+        };
+        in
+        pkgs.devshell.mkShell {
+          imports = [ "${pkgs.devshell.extraModulesDir}/language/c.nix" ];
+
+          devshell.packages = with pkgs; [
+            clang-tools
+            gdb
+            # from nativeBuildInputs
+            gnumake
+            meson
+            ninja
+            pkg-config
+            scdoc
+          ] ++ (map lib.getDev [
+            # from buildInputs
+            wayland wlroots gtkmm3 libsigcxx jsoncpp spdlog gtk-layer-shell howard-hinnant-date libxkbcommon
+            # optional dependencies
+            gobject-introspection glib playerctl python3.pkgs.pygobject3
+            libevdev libinput libjack2 libmpdclient playerctl libnl
+            libpulseaudio sndio sway libdbusmenu-gtk3 udev upower wireplumber
+
+            # from propagated build inputs?
+            at-spi2-atk atkmm cairo cairomm catch2 fmt_8 fontconfig
+            gdk-pixbuf glibmm gtk3 harfbuzz pango pangomm wayland-protocols
+          ]);
+
+          env = with pkgs; [
+            { name = "CPLUS_INCLUDE_PATH"; prefix = "$DEVSHELL_DIR/include"; }
+            { name = "PKG_CONFIG_PATH"; prefix = "$DEVSHELL_DIR/lib/pkgconfig"; }
+            { name = "PKG_CONFIG_PATH"; prefix = "$DEVSHELL_DIR/share/pkgconfig"; }
+            { name = "PATH"; prefix = "${wayland.bin}/bin"; }
+            { name = "LIBRARY_PATH"; prefix = "${lib.getLib sndio}/lib"; }
+            { name = "LIBRARY_PATH"; prefix = "${lib.getLib zlib}/lib"; }
+            { name = "LIBRARY_PATH"; prefix = "${lib.getLib howard-hinnant-date}/lib"; }
+          ];
+        };
+    });
+}
--- a/include/AAppIconLabel.hpp
+++ b/include/AAppIconLabel.hpp
@ -0,0 +1,27 @@
+#pragma once
+
+#include <gtkmm/box.h>
+#include <gtkmm/image.h>
+
+#include "AIconLabel.hpp"
+
+namespace waybar {
+
+class AAppIconLabel : public AIconLabel {
+ public:
+  AAppIconLabel(const Json::Value &config, const std::string &name, const std::string &id,
+                const std::string &format, uint16_t interval = 0, bool ellipsize = false,
+                bool enable_click = false, bool enable_scroll = false);
+  virtual ~AAppIconLabel() = default;
+  auto update() -> void override;
+
+ protected:
+  void updateAppIconName(const std::string &app_identifier,
+                         const std::string &alternative_app_identifier);
+  void updateAppIcon();
+  unsigned app_icon_size_{24};
+  bool update_app_icon_{true};
+  std::string app_icon_name_;
+};
+
+}  // namespace waybar
--- a/include/AIconLabel.hpp
+++ b/include/AIconLabel.hpp
@ -0,0 +1,25 @@
+#pragma once
+
+#include <gtkmm/box.h>
+#include <gtkmm/image.h>
+
+#include "ALabel.hpp"
+
+namespace waybar {
+
+class AIconLabel : public ALabel {
+ public:
+  AIconLabel(const Json::Value &config, const std::string &name, const std::string &id,
+             const std::string &format, uint16_t interval = 0, bool ellipsize = false,
+             bool enable_click = false, bool enable_scroll = false);
+  virtual ~AIconLabel() = default;
+  auto update() -> void override;
+
+ protected:
+  Gtk::Image image_;
+  Gtk::Box box_;
+
+  bool iconEnabled() const;
+};
+
+}  // namespace waybar
--- a/include/ALabel.hpp
+++ b/include/ALabel.hpp
@ -3,6 +3,7 @@
 #include <glibmm/markup.h>
 #include <gtkmm/label.h>
 #include <json/json.h>
+
 #include "AModule.hpp"

 namespace waybar {
@ -10,9 +11,10 @@ namespace waybar {
 class ALabel : public AModule {
 public:
  ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
-         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false, bool enable_scroll = false);
+         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
+         bool enable_scroll = false);
  virtual ~ALabel() = default;
-  virtual auto        update() -> void;
+  auto update() -> void override;
  virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
  virtual std::string getIcon(uint16_t, const std::vector<std::string> &alts, uint16_t max = 0);

@ -23,7 +25,7 @@ class ALabel : public AModule {
  bool alt_ = false;
  std::string default_format_;

-  virtual bool        handleToggle(GdkEventButton *const &e);
+  bool handleToggle(GdkEventButton *const &e) override;
  virtual std::string getState(uint8_t value, bool lesser = false);
 };

--- a/include/AModule.hpp
+++ b/include/AModule.hpp
@ -11,15 +11,20 @@ namespace waybar {

 class AModule : public IModule {
 public:
-  AModule(const Json::Value &, const std::string &, const std::string &, bool enable_click = false,
-          bool enable_scroll = false);
  virtual ~AModule();
-  virtual auto update() -> void;
-  virtual      operator Gtk::Widget &();
+  auto update() -> void override;
+  virtual auto refresh(int) -> void{};
+  operator Gtk::Widget &() override;
+  auto doAction(const std::string &name) -> void override;

  Glib::Dispatcher dp;

 protected:
+  // Don't need to make an object directly
+  // Derived classes are able to use it
+  AModule(const Json::Value &, const std::string &, const std::string &, bool enable_click = false,
+          bool enable_scroll = false);
+
  enum SCROLL_DIR { NONE, UP, DOWN, LEFT, RIGHT };

  SCROLL_DIR getScrollDir(GdkEventScroll *e);
@ -36,6 +41,23 @@ class AModule : public IModule {
  std::vector<int> pid_;
  gdouble distance_scrolled_y_;
  gdouble distance_scrolled_x_;
+  std::map<std::string, std::string> eventActionMap_;
+  static const inline std::map<std::pair<uint, GdkEventType>, std::string> eventMap_{
+      {std::make_pair(1, GdkEventType::GDK_BUTTON_PRESS), "on-click"},
+      {std::make_pair(1, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click"},
+      {std::make_pair(1, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click"},
+      {std::make_pair(2, GdkEventType::GDK_BUTTON_PRESS), "on-click-middle"},
+      {std::make_pair(2, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-middle"},
+      {std::make_pair(2, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-middle"},
+      {std::make_pair(3, GdkEventType::GDK_BUTTON_PRESS), "on-click-right"},
+      {std::make_pair(3, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-right"},
+      {std::make_pair(3, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-right"},
+      {std::make_pair(8, GdkEventType::GDK_BUTTON_PRESS), "on-click-backward"},
+      {std::make_pair(8, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-backward"},
+      {std::make_pair(8, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-backward"},
+      {std::make_pair(9, GdkEventType::GDK_BUTTON_PRESS), "on-click-forward"},
+      {std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-forward"},
+      {std::make_pair(9, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-forward"}};
 };

 }  // namespace waybar
--- a/include/IModule.hpp
+++ b/include/IModule.hpp
@ -9,6 +9,7 @@ class IModule {
  virtual ~IModule() = default;
  virtual auto update() -> void = 0;
  virtual operator Gtk::Widget&() = 0;
+  virtual auto doAction(const std::string& name) -> void = 0;
 };

 }  // namespace waybar
--- a/include/bar.hpp
+++ b/include/bar.hpp
@ -8,6 +8,9 @@
 #include <gtkmm/window.h>
 #include <json/json.h>

+#include <memory>
+#include <vector>
+
 #include "AModule.hpp"
 #include "xdg-output-unstable-v1-client-protocol.h"

@ -36,6 +39,19 @@ struct bar_margins {
  int left = 0;
 };

+struct bar_mode {
+  bar_layer layer;
+  bool exclusive;
+  bool passthrough;
+  bool visible;
+};
+
+#ifdef HAVE_SWAY
+namespace modules::sway {
+class BarIpcClient;
+}
+#endif  // HAVE_SWAY
+
 class BarSurface {
 protected:
  BarSurface() = default;
@ -54,10 +70,16 @@ class BarSurface {

 class Bar {
 public:
+  using bar_mode_map = std::map<std::string_view, struct bar_mode>;
+  static const bar_mode_map PRESET_MODES;
+  static const std::string_view MODE_DEFAULT;
+  static const std::string_view MODE_INVISIBLE;
+
  Bar(struct waybar_output *w_output, const Json::Value &);
  Bar(const Bar &) = delete;
-  ~Bar() = default;
+  ~Bar();

+  void setMode(const std::string_view &);
  void setVisible(bool visible);
  void toggle();
  void handleSignal(int);
@ -65,27 +87,39 @@ class Bar {
  struct waybar_output *output;
  Json::Value config;
  struct wl_surface *surface;
-  bool                  exclusive = true;
  bool visible = true;
  bool vertical = false;
  Gtk::Window window;

+#ifdef HAVE_SWAY
+  std::string bar_id;
+#endif
+
 private:
  void onMap(GdkEventAny *);
  auto setupWidgets() -> void;
-  void getModules(const Factory &, const std::string &);
+  void getModules(const Factory &, const std::string &, Gtk::Box *);
  void setupAltFormatKeyForModule(const std::string &module_name);
  void setupAltFormatKeyForModuleList(const char *module_list_name);
+  void setMode(const bar_mode &);
+
+  /* Copy initial set of modes to allow customization */
+  bar_mode_map configured_modes = PRESET_MODES;
+  std::string last_mode_{MODE_DEFAULT};

  std::unique_ptr<BarSurface> surface_impl_;
-  bar_layer                                     layer_;
  Gtk::Box left_;
  Gtk::Box center_;
  Gtk::Box right_;
  Gtk::Box box_;
-  std::vector<std::unique_ptr<waybar::AModule>> modules_left_;
-  std::vector<std::unique_ptr<waybar::AModule>> modules_center_;
-  std::vector<std::unique_ptr<waybar::AModule>> modules_right_;
+  std::vector<std::shared_ptr<waybar::AModule>> modules_left_;
+  std::vector<std::shared_ptr<waybar::AModule>> modules_center_;
+  std::vector<std::shared_ptr<waybar::AModule>> modules_right_;
+#ifdef HAVE_SWAY
+  using BarIpcClient = modules::sway::BarIpcClient;
+  std::unique_ptr<BarIpcClient> _ipc_client;
+#endif
+  std::vector<std::shared_ptr<waybar::AModule>> modules_all_;
 };

 }  // namespace waybar
--- a/include/client.hpp
+++ b/include/client.hpp
@ -3,11 +3,10 @@
 #include <fmt/format.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkwayland.h>
-#include <unistd.h>
 #include <wayland-client.h>
-#include <wordexp.h>

 #include "bar.hpp"
+#include "config.hpp"

 struct zwlr_layer_shell_v1;
 struct zwp_idle_inhibitor_v1;
@ -29,18 +28,14 @@ class Client {
  struct zxdg_output_manager_v1 *xdg_output_manager = nullptr;
  struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr;
  std::vector<std::unique_ptr<Bar>> bars;
+  Config config;
+  std::string bar_id;

 private:
  Client() = default;
-  std::tuple<const std::string, const std::string> getConfigs(const std::string &config,
-                                                              const std::string &style) const;
+  const std::string getStyle(const std::string &style);
  void bindInterfaces();
-  const std::string        getValidPath(const std::vector<std::string> &paths) const;
  void handleOutput(struct waybar_output &output);
-  bool                     isValidOutput(const Json::Value &config, struct waybar_output &output);
-  auto                     setupConfig(const std::string &config_file, int depth) -> void;
-  auto                     resolveConfigIncludes(Json::Value &config, int depth) -> void;
-  auto                     mergeConfig(Json::Value &a_config_, Json::Value &b_config_) -> void;
  auto setupCss(const std::string &css_file) -> void;
  struct waybar_output &getOutput(void *);
  std::vector<Json::Value> getOutputConfigs(struct waybar_output &output);
@ -55,7 +50,6 @@ class Client {
  void handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor);
  void handleDeferredMonitorRemoval(Glib::RefPtr<Gdk::Monitor> monitor);

-  Json::Value                     config_;
  Glib::RefPtr<Gtk::StyleContext> style_context_;
  Glib::RefPtr<Gtk::CssProvider> css_provider_;
  std::list<struct waybar_output> outputs_;
--- a/include/config.hpp
+++ b/include/config.hpp
@ -0,0 +1,40 @@
+#pragma once
+
+#include <json/json.h>
+
+#include <optional>
+#include <string>
+
+#ifndef SYSCONFDIR
+#define SYSCONFDIR "/etc"
+#endif
+
+namespace waybar {
+
+class Config {
+ public:
+  static const std::vector<std::string> CONFIG_DIRS;
+  static const char *CONFIG_PATH_ENV;
+
+  /* Try to find any of provided names in the supported set of config directories */
+  static std::optional<std::string> findConfigPath(
+      const std::vector<std::string> &names, const std::vector<std::string> &dirs = CONFIG_DIRS);
+
+  Config() = default;
+
+  void load(const std::string &config);
+
+  Json::Value &getConfig() { return config_; }
+
+  std::vector<Json::Value> getOutputConfigs(const std::string &name, const std::string &identifier);
+
+ private:
+  void setupConfig(Json::Value &dst, const std::string &config_file, int depth);
+  void resolveConfigIncludes(Json::Value &config, int depth);
+  void mergeConfig(Json::Value &a_config_, Json::Value &b_config_);
+
+  std::string config_file_;
+
+  Json::Value config_;
+};
+}  // namespace waybar
--- a/include/factory.hpp
+++ b/include/factory.hpp
@ -1,24 +1,39 @@
 #pragma once

 #include <json/json.h>
-#ifdef HAVE_LIBDATE
+#if defined(HAVE_CHRONO_TIMEZONES) || defined(HAVE_LIBDATE)
 #include "modules/clock.hpp"
 #else
 #include "modules/simpleclock.hpp"
 #endif
 #ifdef HAVE_SWAY
+#include "modules/sway/language.hpp"
 #include "modules/sway/mode.hpp"
+#include "modules/sway/scratchpad.hpp"
 #include "modules/sway/window.hpp"
 #include "modules/sway/workspaces.hpp"
-#include "modules/sway/language.hpp"
 #endif
 #ifdef HAVE_WLR
 #include "modules/wlr/taskbar.hpp"
+#include "modules/wlr/workspace_manager.hpp"
 #endif
 #ifdef HAVE_RIVER
+#include "modules/river/layout.hpp"
+#include "modules/river/mode.hpp"
 #include "modules/river/tags.hpp"
+#include "modules/river/window.hpp"
 #endif
-#if defined(__linux__) && !defined(NO_FILESYSTEM)
+#ifdef HAVE_DWL
+#include "modules/dwl/tags.hpp"
+#endif
+#ifdef HAVE_HYPRLAND
+#include "modules/hyprland/backend.hpp"
+#include "modules/hyprland/language.hpp"
+#include "modules/hyprland/submap.hpp"
+#include "modules/hyprland/window.hpp"
+#include "modules/hyprland/workspaces.hpp"
+#endif
+#if defined(__FreeBSD__) || (defined(__linux__) && !defined(NO_FILESYSTEM))
 #include "modules/battery.hpp"
 #endif
 #if defined(HAVE_CPU_LINUX) || defined(HAVE_CPU_BSD)
@ -32,6 +47,9 @@
 #ifdef HAVE_DBUSMENU
 #include "modules/sni/tray.hpp"
 #endif
+#ifdef HAVE_MPRIS
+#include "modules/mpris/mpris.hpp"
+#endif
 #ifdef HAVE_LIBNL
 #include "modules/network.hpp"
 #endif
@ -41,6 +59,12 @@
 #ifdef HAVE_LIBEVDEV
 #include "modules/keyboard_state.hpp"
 #endif
+#ifdef HAVE_GAMEMODE
+#include "modules/gamemode.hpp"
+#endif
+#ifdef HAVE_UPOWER
+#include "modules/upower/upower.hpp"
+#endif
 #ifdef HAVE_LIBPULSE
 #include "modules/pulseaudio.hpp"
 #endif
@ -50,14 +74,24 @@
 #ifdef HAVE_LIBSNDIO
 #include "modules/sndio.hpp"
 #endif
+#ifdef HAVE_GIO_UNIX
+#include "modules/bluetooth.hpp"
+#include "modules/inhibitor.hpp"
+#endif
+#ifdef HAVE_LIBJACK
+#include "modules/jack.hpp"
+#endif
+#ifdef HAVE_LIBWIREPLUMBER
+#include "modules/wireplumber.hpp"
+#endif
+#ifdef HAVE_LIBCAVA
+#include "modules/cava.hpp"
+#endif
 #include "bar.hpp"
 #include "modules/custom.hpp"
+#include "modules/image.hpp"
 #include "modules/temperature.hpp"
-#if defined(__linux__)
-#  ifdef WANT_RFKILL
-#    include "modules/bluetooth.hpp"
-#  endif
-#endif
+#include "modules/user.hpp"

 namespace waybar {

--- a/include/group.hpp
+++ b/include/group.hpp
@ -0,0 +1,22 @@
+#pragma once
+
+#include <gtkmm/box.h>
+#include <gtkmm/widget.h>
+#include <json/json.h>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "factory.hpp"
+
+namespace waybar {
+
+class Group : public AModule {
+ public:
+  Group(const std::string&, const std::string&, const Json::Value&, bool);
+  ~Group() = default;
+  auto update() -> void override;
+  operator Gtk::Widget&() override;
+  Gtk::Box box;
+};
+
+}  // namespace waybar
--- a/include/modules/backlight.hpp
+++ b/include/modules/backlight.hpp
@ -6,6 +6,7 @@
 #include <vector>

 #include "ALabel.hpp"
+#include "giomm/dbusproxy.h"
 #include "util/json.hpp"
 #include "util/sleeper_thread.hpp"

@ -18,12 +19,14 @@ class Backlight : public ALabel {
  class BacklightDev {
   public:
    BacklightDev() = default;
-    BacklightDev(std::string name, int actual, int max);
+    BacklightDev(std::string name, int actual, int max, bool powered);
    std::string_view name() const;
    int get_actual() const;
    void set_actual(int actual);
    int get_max() const;
    void set_max(int max);
+    bool get_powered() const;
+    void set_powered(bool powered);
    friend inline bool operator==(const BacklightDev &lhs, const BacklightDev &rhs) {
      return lhs.name_ == rhs.name_ && lhs.actual_ == rhs.actual_ && lhs.max_ == rhs.max_;
    }
@ -32,12 +35,13 @@ class Backlight : public ALabel {
    std::string name_;
    int actual_ = 1;
    int max_ = 1;
+    bool powered_ = true;
  };

 public:
  Backlight(const std::string &, const Json::Value &);
-  ~Backlight();
-  auto update() -> void;
+  virtual ~Backlight();
+  auto update() -> void override;

 private:
  template <class ForwardIt>
@ -47,6 +51,8 @@ class Backlight : public ALabel {
  template <class ForwardIt, class Inserter>
  static void enumerate_devices(ForwardIt first, ForwardIt last, Inserter inserter, udev *udev);

+  bool handleScroll(GdkEventScroll *e) override;
+
  const std::string preferred_device_;
  static constexpr int EPOLL_MAX_EVENTS = 16;

@ -57,5 +63,7 @@ class Backlight : public ALabel {
  std::vector<BacklightDev> devices_;
  // thread must destruct before shared data
  util::SleeperThread udev_thread_;
+
+  Glib::RefPtr<Gio::DBus::Proxy> login_proxy_;
 };
 }  // namespace waybar::modules
--- a/include/modules/battery.hpp
+++ b/include/modules/battery.hpp
@ -6,11 +6,15 @@
 #include <filesystem>
 #endif
 #include <fmt/format.h>
+#if defined(__linux__)
 #include <sys/inotify.h>
+#endif
+
 #include <algorithm>
 #include <fstream>
 #include <string>
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

@ -25,8 +29,8 @@ namespace fs = std::filesystem;
 class Battery : public ALabel {
 public:
  Battery(const std::string&, const Json::Value&);
-  ~Battery();
-  auto update() -> void;
+  virtual ~Battery();
+  auto update() -> void override;

 private:
  static inline const fs::path data_dir_ = "/sys/class/power_supply/";
@ -44,6 +48,7 @@ class Battery : public ALabel {
  int global_watch_fd_;
  std::mutex battery_list_mutex_;
  std::string old_status_;
+  bool warnFirstTime_{true};

  util::SleeperThread thread_;
  util::SleeperThread thread_battery_update_;
--- a/include/modules/bluetooth.hpp
+++ b/include/modules/bluetooth.hpp
@ -1,18 +1,80 @@
 #pragma once

 #include "ALabel.hpp"
+#ifdef WANT_RFKILL
 #include "util/rfkill.hpp"
+#endif
+#include <gio/gio.h>
+
+#include <optional>
+#include <string>
+#include <vector>

 namespace waybar::modules {

 class Bluetooth : public ALabel {
+  struct ControllerInfo {
+    std::string path;
+    std::string address;
+    std::string address_type;
+    // std::string name; // just use alias instead
+    std::string alias;
+    bool powered;
+    bool discoverable;
+    bool pairable;
+    bool discovering;
+  };
+
+  // NOTE: there are some properties that not all devices provide
+  struct DeviceInfo {
+    std::string path;
+    std::string paired_controller;
+    std::string address;
+    std::string address_type;
+    // std::optional<std::string> name; // just use alias instead
+    std::string alias;
+    std::optional<std::string> icon;
+    bool paired;
+    bool trusted;
+    bool blocked;
+    bool connected;
+    bool services_resolved;
+    // NOTE: experimental feature in bluez
+    std::optional<unsigned char> battery_percentage;
+  };
+
 public:
  Bluetooth(const std::string&, const Json::Value&);
-  ~Bluetooth() = default;
-  auto update() -> void;
+  virtual ~Bluetooth() = default;
+  auto update() -> void override;

 private:
+  static auto onInterfaceAddedOrRemoved(GDBusObjectManager*, GDBusObject*, GDBusInterface*,
+                                        gpointer) -> void;
+  static auto onInterfaceProxyPropertiesChanged(GDBusObjectManagerClient*, GDBusObjectProxy*,
+                                                GDBusProxy*, GVariant*, const gchar* const*,
+                                                gpointer) -> void;
+
+  auto getDeviceBatteryPercentage(GDBusObject*) -> std::optional<unsigned char>;
+  auto getDeviceProperties(GDBusObject*, DeviceInfo&) -> bool;
+  auto getControllerProperties(GDBusObject*, ControllerInfo&) -> bool;
+
+  // Returns std::nullopt if no controller could be found
+  auto findCurController() -> std::optional<ControllerInfo>;
+  auto findConnectedDevices(const std::string&, std::vector<DeviceInfo>&) -> void;
+
+#ifdef WANT_RFKILL
  util::Rfkill rfkill_;
+#endif
+  const std::unique_ptr<GDBusObjectManager, void (*)(GDBusObjectManager*)> manager_;
+
+  std::string state_;
+  std::optional<ControllerInfo> cur_controller_;
+  std::vector<DeviceInfo> connected_devices_;
+  DeviceInfo cur_focussed_device_;
+  std::string device_enumerate_;
+
+  std::vector<std::string> device_preference_;
 };

 }  // namespace waybar::modules
--- a/include/modules/cava.hpp
+++ b/include/modules/cava.hpp
@ -0,0 +1,46 @@
+#pragma once
+
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+extern "C" {
+#include <cava/common.h>
+}
+
+namespace waybar::modules {
+using namespace std::literals::chrono_literals;
+
+class Cava final : public ALabel {
+ public:
+  Cava(const std::string&, const Json::Value&);
+  virtual ~Cava();
+  auto update() -> void override;
+  auto doAction(const std::string& name) -> void override;
+
+ private:
+  util::SleeperThread thread_;
+  util::SleeperThread thread_fetch_input_;
+
+  struct error_s error_ {};          // cava errors
+  struct config_params prm_ {};      // cava parameters
+  struct audio_raw audio_raw_ {};    // cava handled raw audio data(is based on audio_data)
+  struct audio_data audio_data_ {};  // cava audio data
+  struct cava_plan* plan_;           //{new cava_plan{}};
+  // Cava API to read audio source
+  ptr input_source_;
+  // Delay to handle audio source
+  std::chrono::milliseconds frame_time_milsec_{1s};
+  // Text to display
+  std::string text_{""};
+  int rePaint_{1};
+  std::chrono::seconds fetch_input_delay_{4};
+  std::chrono::seconds suspend_silence_delay_{0};
+  bool silence_{false};
+  int sleep_counter_{0};
+  // Cava method
+  void pause_resume();
+  // ModuleActionMap
+  static inline std::map<const std::string, void (waybar::modules::Cava::*const)()> actionMap_{
+      {"mode", &waybar::modules::Cava::pause_resume}};
+};
+}  // namespace waybar::modules
--- a/include/modules/clock.hpp
+++ b/include/modules/clock.hpp
@ -1,42 +1,79 @@
 #pragma once

-#include <fmt/format.h>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
-#include <fmt/chrono.h>
-#endif
-#include <date/tz.h>
 #include "ALabel.hpp"
+#include "util/date.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {

-struct waybar_time {
-  std::locale locale;
-  date::zoned_seconds ztime;
+const std::string kCalendarPlaceholder = "calendar";
+const std::string KTimezonedTimeListPlaceholder = "timezoned_time_list";
+
+enum class WeeksSide {
+  LEFT,
+  RIGHT,
+  HIDDEN,
 };

-class Clock : public ALabel {
+enum class CldMode { MONTH, YEAR };
+
+class Clock final : public ALabel {
 public:
  Clock(const std::string&, const Json::Value&);
-  ~Clock() = default;
-  auto update() -> void;
+  virtual ~Clock() = default;
+  auto update() -> void override;
+  auto doAction(const std::string& name) -> void override;

 private:
  util::SleeperThread thread_;
  std::locale locale_;
-  const date::time_zone* time_zone_;
-  bool fixed_time_zone_;
-  int time_zone_idx_;
-  date::year_month_day cached_calendar_ymd_ = date::January/1/0;
-  std::string cached_calendar_text_;
+  std::vector<const date::time_zone*> time_zones_;
+  int current_time_zone_idx_;
+  bool is_calendar_in_tooltip_;
+  bool is_timezoned_list_in_tooltip_;

-  bool handleScroll(GdkEventScroll* e);
-
-  auto calendar_text(const waybar_time& wtime) -> std::string;
-  auto weekdays_header(const date::weekday& first_dow, std::ostream& os) -> void;
  auto first_day_of_week() -> date::weekday;
-};
+  const date::time_zone* current_timezone();
+  auto timezones_text(std::chrono::system_clock::time_point now) -> std::string;

+  /*Calendar properties*/
+  WeeksSide cldWPos_{WeeksSide::HIDDEN};
+  /*
+    0 - calendar.format.months
+    1 - calendar.format.weekdays
+    2 - calendar.format.days
+    3 - calendar.format.today
+    4 - calendar.format.weeks
+    5 - tooltip-format
+   */
+  std::map<int, std::string const> fmtMap_;
+  CldMode cldMode_{CldMode::MONTH};
+  uint cldMonCols_{3};    // Count of the month in the row
+  int cldMonColLen_{20};  // Length of the month column
+  int cldWnLen_{3};       // Length of the week number
+  date::year_month_day cldYearShift_;
+  date::year_month cldMonShift_;
+  date::months cldCurrShift_{0};
+  date::months cldShift_{0};
+  std::string cldYearCached_{};
+  std::string cldMonCached_{};
+  date::day cldBaseDay_{0};
+  /*Calendar functions*/
+  auto get_calendar(const date::year_month_day& today, const date::year_month_day& ymd,
+                    const date::time_zone* tz) -> const std::string;
+  /*Clock actions*/
+  void cldModeSwitch();
+  void cldShift_up();
+  void cldShift_down();
+  void tz_up();
+  void tz_down();
+
+  // ModuleActionMap
+  static inline std::map<const std::string, void (waybar::modules::Clock::*const)()> actionMap_{
+      {"mode", &waybar::modules::Clock::cldModeSwitch},
+      {"shift_up", &waybar::modules::Clock::cldShift_up},
+      {"shift_down", &waybar::modules::Clock::cldShift_down},
+      {"tz_up", &waybar::modules::Clock::tz_up},
+      {"tz_down", &waybar::modules::Clock::tz_down}};
+};
 }  // namespace waybar::modules
--- a/include/modules/cpu.hpp
+++ b/include/modules/cpu.hpp
@ -1,12 +1,14 @@
 #pragma once

 #include <fmt/format.h>
+
 #include <cstdint>
 #include <fstream>
 #include <numeric>
 #include <string>
 #include <utility>
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

@ -15,12 +17,12 @@ namespace waybar::modules {
 class Cpu : public ALabel {
 public:
  Cpu(const std::string&, const Json::Value&);
-  ~Cpu() = default;
-  auto update() -> void;
+  virtual ~Cpu() = default;
+  auto update() -> void override;

 private:
  double getCpuLoad();
-  std::tuple<uint16_t, std::string>       getCpuUsage();
+  std::tuple<std::vector<uint16_t>, std::string> getCpuUsage();
  std::tuple<float, float, float> getCpuFrequency();
  std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
  std::vector<float> parseCpuFrequencies();
--- a/include/modules/custom.hpp
+++ b/include/modules/custom.hpp
@ -1,8 +1,11 @@
 #pragma once

 #include <fmt/format.h>
+#include <fmt/args.h>
+
 #include <csignal>
 #include <string>
+
 #include "ALabel.hpp"
 #include "util/command.hpp"
 #include "util/json.hpp"
@ -13,9 +16,9 @@ namespace waybar::modules {
 class Custom : public ALabel {
 public:
  Custom(const std::string&, const std::string&, const Json::Value&);
-  ~Custom();
-  auto update() -> void;
-  void refresh(int /*signal*/);
+  virtual ~Custom();
+  auto update() -> void override;
+  void refresh(int /*signal*/) override;

 private:
  void delayWorker();
@ -23,14 +26,16 @@ class Custom : public ALabel {
  void parseOutputRaw();
  void parseOutputJson();
  void handleEvent();
-  bool handleScroll(GdkEventScroll* e);
-  bool handleToggle(GdkEventButton* const& e);
+  bool handleScroll(GdkEventScroll* e) override;
+  bool handleToggle(GdkEventButton* const& e) override;

  const std::string name_;
  std::string text_;
+  std::string id_;
  std::string alt_;
  std::string tooltip_;
  std::vector<std::string> class_;
+  fmt::dynamic_format_arg_store<fmt::format_context> fields_;
  int percentage_;
  FILE* fp_;
  int pid_;
--- a/include/modules/disk.hpp
+++ b/include/modules/disk.hpp
@ -1,19 +1,21 @@
 #pragma once

 #include <fmt/format.h>
-#include <fstream>
 #include <sys/statvfs.h>
+
+#include <fstream>
+
 #include "ALabel.hpp"
-#include "util/sleeper_thread.hpp"
 #include "util/format.hpp"
+#include "util/sleeper_thread.hpp"

 namespace waybar::modules {

 class Disk : public ALabel {
 public:
  Disk(const std::string&, const Json::Value&);
-  ~Disk() = default;
-  auto update() -> void;
+  virtual ~Disk() = default;
+  auto update() -> void override;

 private:
  util::SleeperThread thread_;
--- a/include/modules/dwl/tags.hpp
+++ b/include/modules/dwl/tags.hpp
@ -0,0 +1,34 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <wayland-client.h>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "dwl-ipc-unstable-v2-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::dwl {
+
+class Tags : public waybar::AModule {
+ public:
+  Tags(const std::string &, const waybar::Bar &, const Json::Value &);
+  virtual ~Tags();
+
+  // Handlers for wayland events
+  void handle_view_tags(uint32_t tag, uint32_t state, uint32_t clients, uint32_t focused);
+
+  void handle_primary_clicked(uint32_t tag);
+  bool handle_button_press(GdkEventButton *event_button, uint32_t tag);
+
+  struct zdwl_ipc_manager_v2 *status_manager_;
+  struct wl_seat *seat_;
+
+ private:
+  const waybar::Bar &bar_;
+  Gtk::Box box_;
+  std::vector<Gtk::Button> buttons_;
+  struct zdwl_ipc_output_v2 *output_status_;
+};
+
+} /* namespace waybar::modules::dwl */
--- a/include/modules/gamemode.hpp
+++ b/include/modules/gamemode.hpp
@ -0,0 +1,77 @@
+#pragma once
+
+#include <iostream>
+#include <map>
+#include <string>
+
+#include "ALabel.hpp"
+#include "giomm/dbusconnection.h"
+#include "giomm/dbusproxy.h"
+#include "glibconfig.h"
+#include "gtkmm/box.h"
+#include "gtkmm/image.h"
+#include "gtkmm/label.h"
+#include "gtkmm/overlay.h"
+
+namespace waybar::modules {
+
+class Gamemode : public AModule {
+ public:
+  Gamemode(const std::string &, const Json::Value &);
+  virtual ~Gamemode();
+  auto update() -> void override;
+
+ private:
+  const std::string DEFAULT_ICON_NAME = "input-gaming-symbolic";
+  const std::string DEFAULT_FORMAT = "{glyph}";
+  const std::string DEFAULT_FORMAT_ALT = "{glyph} {count}";
+  const std::string DEFAULT_TOOLTIP_FORMAT = "Games running: {count}";
+  const std::string DEFAULT_GLYPH = "";
+
+  void appear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name,
+              const Glib::ustring &name_owner);
+  void disappear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name);
+  void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection> &connection,
+                          const Glib::ustring &sender_name, const Glib::ustring &object_path,
+                          const Glib::ustring &interface_name, const Glib::ustring &signal_name,
+                          const Glib::VariantContainerBase &parameters);
+  void notify_cb(const Glib::ustring &sender_name, const Glib::ustring &signal_name,
+                 const Glib::VariantContainerBase &arguments);
+
+  void getData();
+  bool handleToggle(GdkEventButton *const &) override;
+
+  // Config
+  std::string format = DEFAULT_FORMAT;
+  std::string format_alt = DEFAULT_FORMAT_ALT;
+  std::string tooltip_format = DEFAULT_TOOLTIP_FORMAT;
+  std::string glyph = DEFAULT_GLYPH;
+  bool tooltip = true;
+  bool hideNotRunning = true;
+  bool useIcon = true;
+  uint iconSize = 20;
+  uint iconSpacing = 4;
+  std::string iconName = DEFAULT_ICON_NAME;
+
+  Gtk::Box box_;
+  Gtk::Image icon_;
+  Gtk::Label label_;
+
+  const std::string dbus_name = "com.feralinteractive.GameMode";
+  const std::string dbus_obj_path = "/com/feralinteractive/GameMode";
+  const std::string dbus_interface = "org.freedesktop.DBus.Properties";
+  const std::string dbus_get_interface = "com.feralinteractive.GameMode";
+
+  uint gameCount = 0;
+
+  std::string lastStatus;
+  bool showAltText = false;
+
+  guint login1_id;
+  Glib::RefPtr<Gio::DBus::Proxy> gamemode_proxy;
+  Glib::RefPtr<Gio::DBus::Connection> system_connection;
+  bool gamemodeRunning;
+  guint gamemodeWatcher_id;
+};
+
+}  // namespace waybar::modules
--- a/include/modules/hyprland/backend.hpp
+++ b/include/modules/hyprland/backend.hpp
@ -0,0 +1,40 @@
+#pragma once
+#include <functional>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+
+#include "util/json.hpp"
+
+namespace waybar::modules::hyprland {
+
+class EventHandler {
+ public:
+  virtual void onEvent(const std::string& ev) = 0;
+  virtual ~EventHandler() = default;
+};
+
+class IPC {
+ public:
+  IPC() { startIPC(); }
+
+  void registerForIPC(const std::string&, EventHandler*);
+  void unregisterForIPC(EventHandler*);
+
+  std::string getSocket1Reply(const std::string& rq);
+  Json::Value getSocket1JsonReply(const std::string& rq);
+
+ private:
+  void startIPC();
+  void parseIPC(const std::string&);
+
+  std::mutex callbackMutex;
+  util::JsonParser parser_;
+  std::list<std::pair<std::string, EventHandler*>> callbacks;
+};
+
+inline std::unique_ptr<IPC> gIPC;
+inline bool modulesReady = false;
+};  // namespace waybar::modules::hyprland
--- a/include/modules/hyprland/language.hpp
+++ b/include/modules/hyprland/language.hpp
@ -0,0 +1,38 @@
+#include <fmt/format.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::hyprland {
+
+class Language : public waybar::ALabel, public EventHandler {
+ public:
+  Language(const std::string&, const waybar::Bar&, const Json::Value&);
+  virtual ~Language();
+
+  auto update() -> void override;
+
+ private:
+  void onEvent(const std::string&) override;
+
+  void initLanguage();
+
+  struct Layout {
+    std::string full_name;
+    std::string short_name;
+    std::string variant;
+    std::string short_description;
+  };
+
+  auto getLayout(const std::string&) -> Layout;
+
+  std::mutex mutex_;
+  const Bar& bar_;
+  util::JsonParser parser_;
+
+  Layout layout_;
+};
+
+}  // namespace waybar::modules::hyprland
--- a/include/modules/hyprland/submap.hpp
+++ b/include/modules/hyprland/submap.hpp
@ -0,0 +1,26 @@
+#include <fmt/format.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::hyprland {
+
+class Submap : public waybar::ALabel, public EventHandler {
+ public:
+  Submap(const std::string&, const waybar::Bar&, const Json::Value&);
+  virtual ~Submap();
+
+  auto update() -> void override;
+
+ private:
+  void onEvent(const std::string&) override;
+
+  std::mutex mutex_;
+  const Bar& bar_;
+  util::JsonParser parser_;
+  std::string submap_;
+};
+
+}  // namespace waybar::modules::hyprland
--- a/include/modules/hyprland/window.hpp
+++ b/include/modules/hyprland/window.hpp
@ -0,0 +1,60 @@
+#include <fmt/format.h>
+
+#include "AAppIconLabel.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::hyprland {
+
+class Window : public waybar::AAppIconLabel, public EventHandler {
+ public:
+  Window(const std::string&, const waybar::Bar&, const Json::Value&);
+  virtual ~Window();
+
+  auto update() -> void override;
+
+ private:
+  struct Workspace {
+    int id;
+    int windows;
+    std::string last_window;
+    std::string last_window_title;
+
+    static auto parse(const Json::Value&) -> Workspace;
+  };
+
+  struct WindowData {
+    bool floating;
+    int monitor = -1;
+    std::string class_name;
+    std::string initial_class_name;
+    std::string title;
+    std::string initial_title;
+    bool fullscreen;
+    bool grouped;
+
+    static auto parse(const Json::Value&) -> WindowData;
+  };
+
+  auto getActiveWorkspace(const std::string&) -> Workspace;
+  auto getActiveWorkspace() -> Workspace;
+  void onEvent(const std::string&) override;
+  void queryActiveWorkspace();
+  void setClass(const std::string&, bool enable);
+
+  bool separate_outputs;
+  std::mutex mutex_;
+  const Bar& bar_;
+  util::JsonParser parser_;
+  WindowData window_data_;
+  Workspace workspace_;
+  std::string solo_class_;
+  std::string last_solo_class_;
+  bool solo_;
+  bool all_floating_;
+  bool swallowing_;
+  bool fullscreen_;
+};
+
+}  // namespace waybar::modules::hyprland
--- a/include/modules/hyprland/workspaces.hpp
+++ b/include/modules/hyprland/workspaces.hpp
@ -0,0 +1,91 @@
+#include <gtkmm/button.h>
+#include <gtkmm/label.h>
+
+#include <memory>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+
+namespace waybar::modules::hyprland {
+
+class Workspace {
+ public:
+  Workspace(const Json::Value& workspace_data);
+  std::string& select_icon(std::map<std::string, std::string>& icons_map);
+  Gtk::Button& button() { return button_; };
+
+  int id() const { return id_; };
+  std::string name() const { return name_; };
+  std::string output() const { return output_; };
+  bool active() const { return active_; };
+  bool is_special() const { return is_special_; };
+  bool is_persistent() const { return is_persistent_; };
+  bool is_empty() const { return windows_ == 0; };
+  bool is_urgent() const { return is_urgent_; };
+
+  auto handle_clicked(GdkEventButton* bt) -> bool;
+  void set_active(bool value = true) { active_ = value; };
+  void set_persistent(bool value = true) { is_persistent_ = value; };
+  void set_urgent(bool value = true) { is_urgent_ = value; };
+  void set_windows(uint value) { windows_ = value; };
+
+  void update(const std::string& format, const std::string& icon);
+
+ private:
+  int id_;
+  std::string name_;
+  std::string output_;
+  uint windows_;
+  bool active_ = false;
+  bool is_special_ = false;
+  bool is_persistent_ = false;
+  bool is_urgent_ = false;
+
+  Gtk::Button button_;
+  Gtk::Box content_;
+  Gtk::Label label_;
+};
+
+class Workspaces : public AModule, public EventHandler {
+ public:
+  Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Workspaces() override;
+  void update() override;
+  void init();
+
+  auto all_outputs() const -> bool { return all_outputs_; }
+  auto show_special() const -> bool { return show_special_; }
+
+  auto get_bar_output() const -> std::string { return bar_.output->name; }
+
+ private:
+  void onEvent(const std::string&) override;
+  void update_window_count();
+  void sort_workspaces();
+  void create_workspace(Json::Value& value);
+  void remove_workspace(std::string name);
+  void set_urgent_workspace(std::string windowaddress);
+
+  bool all_outputs_ = false;
+  bool show_special_ = false;
+
+  void fill_persistent_workspaces();
+  void create_persistent_workspaces();
+  std::vector<std::string> persistent_workspaces_to_create_;
+  bool persistent_created_ = false;
+
+  std::string format_;
+  std::map<std::string, std::string> icons_map_;
+  bool with_icon_;
+  uint64_t monitor_id_;
+  std::string active_workspace_name_;
+  std::vector<std::unique_ptr<Workspace>> workspaces_;
+  std::vector<Json::Value> workspaces_to_create_;
+  std::vector<std::string> workspaces_to_remove_;
+  std::mutex mutex_;
+  const Bar& bar_;
+  Gtk::Box box_;
+};
+
+}  // namespace waybar::modules::hyprland
--- a/include/modules/idle_inhibitor.hpp
+++ b/include/modules/idle_inhibitor.hpp
@ -1,6 +1,7 @@
 #pragma once

 #include <fmt/format.h>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@ -8,15 +9,18 @@
 namespace waybar::modules {

 class IdleInhibitor : public ALabel {
+  sigc::connection timeout_;
+
 public:
  IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~IdleInhibitor();
-  auto update() -> void;
+  virtual ~IdleInhibitor();
+  auto update() -> void override;
  static std::list<waybar::AModule*> modules;
  static bool status;

 private:
-  bool handleToggle(GdkEventButton* const& e);
+  bool handleToggle(GdkEventButton* const& e) override;
+  void toggleStatus();

  const Bar& bar_;
  struct zwp_idle_inhibitor_v1* idle_inhibitor_;
--- a/include/modules/image.hpp
+++ b/include/modules/image.hpp
@ -0,0 +1,40 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <gtkmm/image.h>
+
+#include <csignal>
+#include <string>
+
+#include "ALabel.hpp"
+#include "gtkmm/box.h"
+#include "util/command.hpp"
+#include "util/json.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class Image : public AModule {
+ public:
+  Image(const std::string&, const Json::Value&);
+  virtual ~Image() = default;
+  auto update() -> void override;
+  void refresh(int /*signal*/) override;
+
+ private:
+  void delayWorker();
+  void handleEvent();
+  void parseOutputRaw();
+
+  Gtk::Box box_;
+  Gtk::Image image_;
+  std::string path_;
+  std::string tooltip_;
+  int size_;
+  int interval_;
+  util::command::res output_;
+
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules
--- a/include/modules/inhibitor.hpp
+++ b/include/modules/inhibitor.hpp
@ -0,0 +1,27 @@
+#pragma once
+
+#include <gio/gio.h>
+
+#include <memory>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+
+namespace waybar::modules {
+
+class Inhibitor : public ALabel {
+ public:
+  Inhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
+  virtual ~Inhibitor();
+  auto update() -> void override;
+  auto activated() -> bool;
+
+ private:
+  auto handleToggle(::GdkEventButton* const& e) -> bool override;
+
+  const std::unique_ptr<::GDBusConnection, void (*)(::GDBusConnection*)> dbus_;
+  const std::string inhibitors_;
+  int handle_ = -1;
+};
+
+}  // namespace waybar::modules
--- a/include/modules/jack.hpp
+++ b/include/modules/jack.hpp
@ -0,0 +1,44 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <jack/jack.h>
+#include <jack/thread.h>
+
+#include <fstream>
+
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class JACK : public ALabel {
+ public:
+  JACK(const std::string &, const Json::Value &);
+  virtual ~JACK() = default;
+  auto update() -> void override;
+
+  int bufSize(jack_nframes_t size);
+  int sampleRate(jack_nframes_t rate);
+  int xrun();
+  void shutdown();
+
+ private:
+  std::string JACKState();
+
+  jack_client_t *client_;
+  jack_nframes_t bufsize_;
+  jack_nframes_t samplerate_;
+  unsigned int xruns_;
+  float load_;
+  bool running_;
+  std::mutex mutex_;
+  std::string state_;
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules
+
+int bufSizeCallback(jack_nframes_t size, void *obj);
+int sampleRateCallback(jack_nframes_t rate, void *obj);
+int xrunCallback(void *obj);
+void shutdownCallback(void *obj);
--- a/include/modules/keyboard_state.hpp
+++ b/include/modules/keyboard_state.hpp
@ -1,18 +1,18 @@
 #pragma once

-#include <fmt/format.h>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
 #include <fmt/chrono.h>
-#endif
+#include <gtkmm/label.h>
+
+#include <set>
+#include <unordered_map>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "util/sleeper_thread.hpp"
-#include <gtkmm/label.h>

 extern "C" {
 #include <libevdev/libevdev.h>
+#include <libinput.h>
 }

 namespace waybar::modules {
@ -20,11 +20,11 @@ namespace waybar::modules {
 class KeyboardState : public AModule {
 public:
  KeyboardState(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~KeyboardState();
-  auto update() -> void;
+  virtual ~KeyboardState();
+  auto update() -> void override;

 private:
-  static auto openDevice(const std::string&) -> std::pair<int, libevdev*>;
+  auto tryAddDevice(const std::string&) -> void;

  Gtk::Box box_;
  Gtk::Label numlock_label_;
@ -37,11 +37,13 @@ class KeyboardState : public AModule {
  const std::chrono::seconds interval_;
  std::string icon_locked_;
  std::string icon_unlocked_;
+  std::string devices_path_;

-  int         fd_;
-  libevdev*   dev_;
+  struct libinput* libinput_;
+  std::unordered_map<std::string, struct libinput_device*> libinput_devices_;
+  std::set<int> binding_keys;

-  util::SleeperThread thread_;
+  util::SleeperThread libinput_thread_, hotplug_thread_;
 };

 }  // namespace waybar::modules
--- a/include/modules/memory.hpp
+++ b/include/modules/memory.hpp
@ -1,8 +1,10 @@
 #pragma once

 #include <fmt/format.h>
+
 #include <fstream>
 #include <unordered_map>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

@ -11,8 +13,8 @@ namespace waybar::modules {
 class Memory : public ALabel {
 public:
  Memory(const std::string&, const Json::Value&);
-  ~Memory() = default;
-  auto update() -> void;
+  virtual ~Memory() = default;
+  auto update() -> void override;

 private:
  void parseMeminfo();
--- a/include/modules/mpd/mpd.hpp
+++ b/include/modules/mpd/mpd.hpp
@ -37,10 +37,11 @@ class MPD : public ALabel {
 public:
  MPD(const std::string&, const Json::Value&);
  virtual ~MPD() noexcept = default;
-  auto update() -> void;
+  auto update() -> void override;

 private:
  std::string getTag(mpd_tag_type type, unsigned idx = 0) const;
+  std::string getFilename() const;
  void setLabel();
  std::string getStateIcon() const;
  std::string getOptionIcon(std::string optionName, bool activated) const;
--- a/include/modules/mpd/state.hpp
+++ b/include/modules/mpd/state.hpp
@ -1,7 +1,7 @@
 #pragma once

-#include <mpd/client.h>
 #include <fmt/format.h>
+#include <mpd/client.h>
 #include <spdlog/spdlog.h>

 #include <condition_variable>
--- a/include/modules/mpd/state.inl.hpp
+++ b/include/modules/mpd/state.inl.hpp
@ -12,9 +12,7 @@ inline void                  Context::tryConnect() const { mpd_module_->tryConne
 inline unique_connection& Context::connection() { return mpd_module_->connection_; }
 constexpr inline mpd_state Context::state() const { return mpd_module_->state_; }

-inline void Context::do_update() {
-  mpd_module_->setLabel();
-}
+inline void Context::do_update() { mpd_module_->setLabel(); }

 inline void Context::checkErrors(mpd_connection* conn) const { mpd_module_->checkErrors(conn); }
 inline void Context::queryMPD() const { mpd_module_->queryMPD(); }
--- a/include/modules/mpris/mpris.hpp
+++ b/include/modules/mpris/mpris.hpp
@ -0,0 +1,88 @@
+#pragma once
+
+#include <iostream>
+#include <optional>
+#include <string>
+
+#include "gtkmm/box.h"
+#include "gtkmm/label.h"
+
+extern "C" {
+#include <playerctl/playerctl.h>
+}
+
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules::mpris {
+
+class Mpris : public ALabel {
+ public:
+  Mpris(const std::string&, const Json::Value&);
+  virtual ~Mpris();
+  auto update() -> void override;
+  bool handleToggle(GdkEventButton* const&) override;
+
+ private:
+  static auto onPlayerNameAppeared(PlayerctlPlayerManager*, PlayerctlPlayerName*, gpointer) -> void;
+  static auto onPlayerNameVanished(PlayerctlPlayerManager*, PlayerctlPlayerName*, gpointer) -> void;
+  static auto onPlayerPlay(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerPause(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerStop(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerMetadata(PlayerctlPlayer*, GVariant*, gpointer) -> void;
+
+  struct PlayerInfo {
+    std::string name;
+    PlayerctlPlaybackStatus status;
+    std::string status_string;
+
+    std::optional<std::string> artist;
+    std::optional<std::string> album;
+    std::optional<std::string> title;
+    std::optional<std::string> length;    // as HH:MM:SS
+    std::optional<std::string> position;  // same format
+  };
+
+  auto getPlayerInfo() -> std::optional<PlayerInfo>;
+  auto getIconFromJson(const Json::Value&, const std::string&) -> std::string;
+  auto getArtistStr(const PlayerInfo&, bool) -> std::string;
+  auto getAlbumStr(const PlayerInfo&, bool) -> std::string;
+  auto getTitleStr(const PlayerInfo&, bool) -> std::string;
+  auto getLengthStr(const PlayerInfo&, bool) -> std::string;
+  auto getPositionStr(const PlayerInfo&, bool) -> std::string;
+  auto getDynamicStr(const PlayerInfo&, bool, bool) -> std::string;
+
+  // config
+  std::string format_playing_;
+  std::string format_paused_;
+  std::string format_stopped_;
+
+  std::string tooltip_;
+  std::string tooltip_playing_;
+  std::string tooltip_paused_;
+  std::string tooltip_stopped_;
+
+  int artist_len_;
+  int album_len_;
+  int title_len_;
+  int dynamic_len_;
+  std::vector<std::string> dynamic_prio_;
+  std::vector<std::string> dynamic_order_;
+  std::string dynamic_separator_;
+  bool truncate_hours_;
+  bool tooltip_len_limits_;
+  std::string ellipsis_;
+
+  std::string player_;
+  std::vector<std::string> ignored_players_;
+
+  PlayerctlPlayerManager* manager;
+  PlayerctlPlayer* player;
+  std::string lastStatus;
+  std::string lastPlayer;
+
+  util::SleeperThread thread_;
+  std::chrono::time_point<std::chrono::system_clock> last_update_;
+};
+
+}  // namespace waybar::modules::mpris
--- a/include/modules/network.hpp
+++ b/include/modules/network.hpp
@ -7,6 +7,9 @@
 #include <netlink/genl/genl.h>
 #include <netlink/netlink.h>
 #include <sys/epoll.h>
+
+#include <optional>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 #ifdef WANT_RFKILL
@ -18,8 +21,8 @@ namespace waybar::modules {
 class Network : public ALabel {
 public:
  Network(const std::string&, const Json::Value&);
-  ~Network();
-  auto update() -> void;
+  virtual ~Network();
+  auto update() -> void override;

 private:
  static const uint8_t MAX_RETRY = 5;
@ -43,6 +46,7 @@ class Network : public ALabel {
  const std::string getNetworkState() const;
  void clearIface();
  bool wildcardMatch(const std::string& pattern, const std::string& text) const;
+  std::optional<std::pair<unsigned long long, unsigned long long>> readBandwidthUsage();

  int ifid_;
  sa_family_t family_;
@ -58,6 +62,7 @@ class Network : public ALabel {
  bool want_link_dump_;
  bool want_addr_dump_;
  bool dump_in_progress_;
+  bool is_p2p_;

  unsigned long long bandwidth_down_total_;
  unsigned long long bandwidth_up_total_;
@ -67,11 +72,12 @@ class Network : public ALabel {
  bool carrier_;
  std::string ifname_;
  std::string ipaddr_;
+  std::string gwaddr_;
  std::string netmask_;
  int cidr_;
  int32_t signal_strength_dbm_;
  uint8_t signal_strength_;
-  uint32_t    frequency_;
+  std::string signal_strength_app_;
  uint32_t route_priority;

  util::SleeperThread thread_;
@ -79,6 +85,7 @@ class Network : public ALabel {
 #ifdef WANT_RFKILL
  util::Rfkill rfkill_;
 #endif
+  float frequency_;
 };

 }  // namespace waybar::modules
--- a/include/modules/pulseaudio.hpp
+++ b/include/modules/pulseaudio.hpp
@ -3,8 +3,10 @@
 #include <fmt/format.h>
 #include <pulse/pulseaudio.h>
 #include <pulse/volume.h>
+
 #include <algorithm>
 #include <array>
+
 #include "ALabel.hpp"

 namespace waybar::modules {
@ -12,8 +14,8 @@ namespace waybar::modules {
 class Pulseaudio : public ALabel {
 public:
  Pulseaudio(const std::string&, const Json::Value&);
-  ~Pulseaudio();
-  auto update() -> void;
+  virtual ~Pulseaudio();
+  auto update() -> void override;

 private:
  static void subscribeCb(pa_context*, pa_subscription_event_type_t, uint32_t, void*);
@ -23,7 +25,7 @@ class Pulseaudio : public ALabel {
  static void serverInfoCb(pa_context*, const pa_server_info*, void*);
  static void volumeModifyCb(pa_context*, int, void*);

-  bool              handleScroll(GdkEventScroll* e);
+  bool handleScroll(GdkEventScroll* e) override;
  const std::vector<std::string> getPulseIcon() const;

  pa_threaded_mainloop* mainloop_;
--- a/include/modules/river/layout.hpp
+++ b/include/modules/river/layout.hpp
@ -0,0 +1,33 @@
+#pragma once
+
+#include <wayland-client.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "river-status-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::river {
+
+class Layout : public waybar::ALabel {
+ public:
+  Layout(const std::string &, const waybar::Bar &, const Json::Value &);
+  virtual ~Layout();
+
+  // Handlers for wayland events
+  void handle_name(const char *name);
+  void handle_clear();
+  void handle_focused_output(struct wl_output *output);
+  void handle_unfocused_output(struct wl_output *output);
+
+  struct zriver_status_manager_v1 *status_manager_;
+  struct wl_seat *seat_;
+
+ private:
+  const waybar::Bar &bar_;
+  struct wl_output *output_;          // stores the output this module belongs to
+  struct wl_output *focused_output_;  // stores the currently focused output
+  struct zriver_output_status_v1 *output_status_;
+  struct zriver_seat_status_v1 *seat_status_;
+};
+
+} /* namespace waybar::modules::river */
--- a/include/modules/river/mode.hpp
+++ b/include/modules/river/mode.hpp
@ -0,0 +1,28 @@
+#pragma once
+
+#include <wayland-client.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "river-status-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::river {
+
+class Mode : public waybar::ALabel {
+ public:
+  Mode(const std::string &, const waybar::Bar &, const Json::Value &);
+  virtual ~Mode();
+
+  // Handlers for wayland events
+  void handle_mode(const char *mode);
+
+  struct zriver_status_manager_v1 *status_manager_;
+  struct wl_seat *seat_;
+
+ private:
+  const waybar::Bar &bar_;
+  std::string mode_;
+  struct zriver_seat_status_v1 *seat_status_;
+};
+
+} /* namespace waybar::modules::river */
--- a/include/modules/river/tags.hpp
+++ b/include/modules/river/tags.hpp
@ -5,6 +5,7 @@

 #include "AModule.hpp"
 #include "bar.hpp"
+#include "river-control-unstable-v1-client-protocol.h"
 #include "river-status-unstable-v1-client-protocol.h"
 #include "xdg-output-unstable-v1-client-protocol.h"

@ -13,13 +14,19 @@ namespace waybar::modules::river {
 class Tags : public waybar::AModule {
 public:
  Tags(const std::string &, const waybar::Bar &, const Json::Value &);
-  ~Tags();
+  virtual ~Tags();

  // Handlers for wayland events
  void handle_focused_tags(uint32_t tags);
  void handle_view_tags(struct wl_array *tags);
+  void handle_urgent_tags(uint32_t tags);
+
+  void handle_primary_clicked(uint32_t tag);
+  bool handle_button_press(GdkEventButton *event_button, uint32_t tag);

  struct zriver_status_manager_v1 *status_manager_;
+  struct zriver_control_v1 *control_;
+  struct wl_seat *seat_;

 private:
  const waybar::Bar &bar_;
--- a/include/modules/river/window.hpp
+++ b/include/modules/river/window.hpp
@ -0,0 +1,33 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <wayland-client.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "river-status-unstable-v1-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::river {
+
+class Window : public waybar::ALabel {
+ public:
+  Window(const std::string &, const waybar::Bar &, const Json::Value &);
+  virtual ~Window();
+
+  // Handlers for wayland events
+  void handle_focused_view(const char *title);
+  void handle_focused_output(struct wl_output *output);
+  void handle_unfocused_output(struct wl_output *output);
+
+  struct zriver_status_manager_v1 *status_manager_;
+  struct wl_seat *seat_;
+
+ private:
+  const waybar::Bar &bar_;
+  struct wl_output *output_;          // stores the output this module belongs to
+  struct wl_output *focused_output_;  // stores the currently focused output
+  struct zriver_seat_status_v1 *seat_status_;
+};
+
+} /* namespace waybar::modules::river */
--- a/include/modules/simpleclock.hpp
+++ b/include/modules/simpleclock.hpp
@ -1,11 +1,7 @@
 #pragma once

-#include <fmt/format.h>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
 #include <fmt/chrono.h>
-#endif
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

@ -14,8 +10,8 @@ namespace waybar::modules {
 class Clock : public ALabel {
 public:
  Clock(const std::string&, const Json::Value&);
-  ~Clock() = default;
-  auto update() -> void;
+  virtual ~Clock() = default;
+  auto update() -> void override;

 private:
  util::SleeperThread thread_;
--- a/include/modules/sndio.hpp
+++ b/include/modules/sndio.hpp
@ -1,7 +1,9 @@
 #pragma once

 #include <sndio.h>
+
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

@ -10,12 +12,12 @@ namespace waybar::modules {
 class Sndio : public ALabel {
 public:
  Sndio(const std::string &, const Json::Value &);
-  ~Sndio();
-  auto update() -> void;
+  virtual ~Sndio();
+  auto update() -> void override;
  auto set_desc(struct sioctl_desc *, unsigned int) -> void;
  auto put_val(unsigned int, unsigned int) -> void;
-  bool handleScroll(GdkEventScroll *);
-  bool handleToggle(GdkEventButton* const&);
+  bool handleScroll(GdkEventScroll *) override;
+  bool handleToggle(GdkEventButton *const &) override;

 private:
  auto connect_to_sndio() -> void;
--- a/include/modules/sni/host.hpp
+++ b/include/modules/sni/host.hpp
@ -4,14 +4,18 @@
 #include <giomm.h>
 #include <glibmm/refptr.h>
 #include <json/json.h>
+
 #include <tuple>
+
+#include "bar.hpp"
 #include "modules/sni/item.hpp"

 namespace waybar::modules::SNI {

 class Host {
 public:
-  Host(const std::size_t id, const Json::Value&, const std::function<void(std::unique_ptr<Item>&)>&,
+  Host(const std::size_t id, const Json::Value&, const Bar&,
+       const std::function<void(std::unique_ptr<Item>&)>&,
       const std::function<void(std::unique_ptr<Item>&)>&);
  ~Host();

@ -36,6 +40,7 @@ class Host {
  GCancellable* cancellable_ = nullptr;
  SnWatcher* watcher_ = nullptr;
  const Json::Value& config_;
+  const Bar& bar_;
  const std::function<void(std::unique_ptr<Item>&)> on_add_;
  const std::function<void(std::unique_ptr<Item>&)> on_remove_;
 };
--- a/include/modules/sni/item.hpp
+++ b/include/modules/sni/item.hpp
@ -14,6 +14,8 @@
 #include <set>
 #include <string_view>

+#include "bar.hpp"
+
 namespace waybar::modules::SNI {

 struct ToolTip {
@ -23,7 +25,7 @@ struct ToolTip {

 class Item : public sigc::trackable {
 public:
-  Item(const std::string&, const std::string&, const Json::Value&);
+  Item(const std::string&, const std::string&, const Json::Value&, const Bar&);
  ~Item() = default;

  std::string bus_name;
@ -56,6 +58,7 @@ class Item : public sigc::trackable {
  bool item_is_menu = true;

 private:
+  void onConfigure(GdkEventConfigure* ev);
  void proxyReady(Glib::RefPtr<Gio::AsyncResult>& result);
  void setProperty(const Glib::ustring& name, Glib::VariantBase& value);
  void setStatus(const Glib::ustring& value);
--- a/include/modules/sni/tray.hpp
+++ b/include/modules/sni/tray.hpp
@ -1,6 +1,7 @@
 #pragma once

 #include <fmt/format.h>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "modules/sni/host.hpp"
@ -12,8 +13,8 @@ namespace waybar::modules::SNI {
 class Tray : public AModule {
 public:
  Tray(const std::string&, const Bar&, const Json::Value&);
-  ~Tray() = default;
-  auto update() -> void;
+  virtual ~Tray() = default;
+  auto update() -> void override;

 private:
  void onAdd(std::unique_ptr<Item>& item);
--- a/include/modules/sway/bar.hpp
+++ b/include/modules/sway/bar.hpp
@ -0,0 +1,60 @@
+#pragma once
+#include <atomic>
+#include <string>
+
+#include "modules/sway/ipc/client.hpp"
+#include "util/SafeSignal.hpp"
+#include "util/json.hpp"
+
+namespace waybar {
+
+class Bar;
+
+namespace modules::sway {
+
+/*
+ * Supported subset of i3/sway IPC barconfig object
+ */
+struct swaybar_config {
+  std::string id;
+  std::string mode;
+  std::string hidden_state;
+};
+
+/**
+ * swaybar IPC client
+ */
+class BarIpcClient {
+ public:
+  BarIpcClient(waybar::Bar& bar);
+
+ private:
+  void onInitialConfig(const struct Ipc::ipc_response& res);
+  void onIpcEvent(const struct Ipc::ipc_response&);
+  void onCmd(const struct Ipc::ipc_response&);
+  void onConfigUpdate(const swaybar_config& config);
+  void onVisibilityUpdate(bool visible_by_modifier);
+  void onModeUpdate(bool visible_by_modifier);
+  void onUrgencyUpdate(bool visible_by_urgency);
+  void update();
+  bool isModuleEnabled(std::string name);
+
+  Bar& bar_;
+  util::JsonParser parser_;
+  Ipc ipc_;
+
+  swaybar_config bar_config_;
+  std::string modifier_reset_;
+  bool visible_by_mode_ = false;
+  bool visible_by_modifier_ = false;
+  bool visible_by_urgency_ = false;
+  std::atomic<bool> modifier_no_action_ = false;
+
+  SafeSignal<bool> signal_mode_;
+  SafeSignal<bool> signal_visible_;
+  SafeSignal<bool> signal_urgency_;
+  SafeSignal<swaybar_config> signal_config_;
+};
+
+}  // namespace modules::sway
+}  // namespace waybar
--- a/include/modules/sway/ipc/client.hpp
+++ b/include/modules/sway/ipc/client.hpp
@ -4,9 +4,13 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <unistd.h>
+
 #include <cstring>
 #include <memory>
 #include <mutex>
+#include <stdexcept>
+#include <string>
+
 #include "ipc.hpp"
 #include "util/sleeper_thread.hpp"

--- a/include/modules/sway/ipc/ipc.hpp
+++ b/include/modules/sway/ipc/ipc.hpp
@ -1,8 +1,10 @@
 #pragma once

+#include <cstdint>
+
 #define event_mask(ev) (1u << (ev & 0x7F))

-enum ipc_command_type {
+enum ipc_command_type : uint32_t {
  // i3 command types - see i3's I3_REPLY_TYPE constants
  IPC_COMMAND = 0,
  IPC_GET_WORKSPACES = 1,
@ -21,16 +23,16 @@ enum ipc_command_type {
  IPC_GET_SEATS = 101,

  // Events sent from sway to clients. Events have the highest bits set.
-  IPC_EVENT_WORKSPACE = ((1 << 31) | 0),
-  IPC_EVENT_OUTPUT = ((1 << 31) | 1),
-  IPC_EVENT_MODE = ((1 << 31) | 2),
-  IPC_EVENT_WINDOW = ((1 << 31) | 3),
-  IPC_EVENT_BARCONFIG_UPDATE = ((1 << 31) | 4),
-  IPC_EVENT_BINDING = ((1 << 31) | 5),
-  IPC_EVENT_SHUTDOWN = ((1 << 31) | 6),
-  IPC_EVENT_TICK = ((1 << 31) | 7),
+  IPC_EVENT_WORKSPACE = ((1U << 31) | 0),
+  IPC_EVENT_OUTPUT = ((1U << 31) | 1),
+  IPC_EVENT_MODE = ((1U << 31) | 2),
+  IPC_EVENT_WINDOW = ((1U << 31) | 3),
+  IPC_EVENT_BARCONFIG_UPDATE = ((1U << 31) | 4),
+  IPC_EVENT_BINDING = ((1U << 31) | 5),
+  IPC_EVENT_SHUTDOWN = ((1U << 31) | 6),
+  IPC_EVENT_TICK = ((1U << 31) | 7),

  // sway-specific event types
-	IPC_EVENT_BAR_STATE_UPDATE = ((1<<31) | 20),
-	IPC_EVENT_INPUT = ((1<<31) | 21),
+  IPC_EVENT_BAR_STATE_UPDATE = ((1U << 31) | 20),
+  IPC_EVENT_INPUT = ((1U << 31) | 21),
 };
--- a/include/modules/sway/language.hpp
+++ b/include/modules/sway/language.hpp
@ -17,14 +17,18 @@ namespace waybar::modules::sway {
 class Language : public ALabel, public sigc::trackable {
 public:
  Language(const std::string& id, const Json::Value& config);
-  ~Language() = default;
-  auto update() -> void;
+  virtual ~Language() = default;
+  auto update() -> void override;

 private:
+  enum class DispayedShortFlag { None = 0, ShortName = 1, ShortDescription = 1 << 1 };
+
  struct Layout {
    std::string full_name;
    std::string short_name;
    std::string variant;
+    std::string short_description;
+    std::string country_flag() const;
  };

  class XKBContext {
@ -32,10 +36,12 @@ class Language : public ALabel, public sigc::trackable {
    XKBContext();
    ~XKBContext();
    auto next_layout() -> Layout*;
+
   private:
    rxkb_context* context_ = nullptr;
    rxkb_layout* xkb_layout_ = nullptr;
    Layout* layout_ = nullptr;
+    std::map<std::string, rxkb_layout*> base_layouts_by_name_;
  };

  void onEvent(const struct Ipc::ipc_response&);
@ -50,8 +56,8 @@ class Language : public ALabel, public sigc::trackable {
  Layout layout_;
  std::string tooltip_format_ = "";
  std::map<std::string, Layout> layouts_map_;
-  XKBContext xkb_context_;
  bool is_variant_displayed;
+  std::byte displayed_short_flag = static_cast<std::byte>(DispayedShortFlag::None);

  util::JsonParser parser_;
  std::mutex mutex_;
--- a/include/modules/sway/mode.hpp
+++ b/include/modules/sway/mode.hpp
@ -1,6 +1,7 @@
 #pragma once

 #include <fmt/format.h>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@ -12,8 +13,8 @@ namespace waybar::modules::sway {
 class Mode : public ALabel, public sigc::trackable {
 public:
  Mode(const std::string&, const Json::Value&);
-  ~Mode() = default;
-  auto update() -> void;
+  virtual ~Mode() = default;
+  auto update() -> void override;

 private:
  void onEvent(const struct Ipc::ipc_response&);
--- a/include/modules/sway/scratchpad.hpp
+++ b/include/modules/sway/scratchpad.hpp
@ -0,0 +1,35 @@
+#pragma once
+
+#include <gtkmm/label.h>
+
+#include <mutex>
+#include <string>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "client.hpp"
+#include "modules/sway/ipc/client.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::sway {
+class Scratchpad : public ALabel {
+ public:
+  Scratchpad(const std::string&, const Json::Value&);
+  virtual ~Scratchpad() = default;
+  auto update() -> void override;
+
+ private:
+  auto getTree() -> void;
+  auto onCmd(const struct Ipc::ipc_response&) -> void;
+  auto onEvent(const struct Ipc::ipc_response&) -> void;
+
+  std::string tooltip_format_;
+  bool show_empty_;
+  bool tooltip_enabled_;
+  std::string tooltip_text_;
+  int count_;
+  std::mutex mutex_;
+  Ipc ipc_;
+  util::JsonParser parser_;
+};
+}  // namespace waybar::modules::sway
--- a/include/modules/sway/window.hpp
+++ b/include/modules/sway/window.hpp
@ -1,8 +1,10 @@
 #pragma once

 #include <fmt/format.h>
+
 #include <tuple>
-#include "ALabel.hpp"
+
+#include "AAppIconLabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
@ -10,26 +12,30 @@

 namespace waybar::modules::sway {

-class Window : public ALabel, public sigc::trackable {
+class Window : public AAppIconLabel, public sigc::trackable {
 public:
  Window(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~Window() = default;
-  auto update() -> void;
+  virtual ~Window() = default;
+  auto update() -> void override;

 private:
+  void setClass(std::string classname, bool enable);
  void onEvent(const struct Ipc::ipc_response&);
  void onCmd(const struct Ipc::ipc_response&);
-  std::tuple<std::size_t, int, std::string, std::string> getFocusedNode(const Json::Value& nodes,
-                                                                        std::string&       output);
+  std::tuple<std::size_t, int, int, std::string, std::string, std::string, std::string, std::string>
+  getFocusedNode(const Json::Value& nodes, std::string& output);
  void getTree();
-  std::string                                            rewriteTitle(const std::string& title);

  const Bar& bar_;
  std::string window_;
  int windowId_;
  std::string app_id_;
+  std::string app_class_;
+  std::string layout_;
  std::string old_app_id_;
  std::size_t app_nb_;
+  std::string shell_;
+  int floating_count_;
  util::JsonParser parser_;
  std::mutex mutex_;
  Ipc ipc_;
--- a/include/modules/sway/workspaces.hpp
+++ b/include/modules/sway/workspaces.hpp
@ -1,10 +1,12 @@
 #pragma once

-#include <unordered_map>
 #include <fmt/format.h>
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>
+
+#include <string_view>
 #include <unordered_map>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@ -16,11 +18,13 @@ namespace waybar::modules::sway {
 class Workspaces : public AModule, public sigc::trackable {
 public:
  Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~Workspaces() = default;
-  auto update() -> void;
+  virtual ~Workspaces() = default;
+  auto update() -> void override;

 private:
-  static inline const std::string workspace_switch_cmd_ = "workspace {} \"{}\"";
+  static constexpr std::string_view workspace_switch_cmd_ = "workspace {} \"{}\"";
+  static constexpr std::string_view persistent_workspace_switch_cmd_ =
+      R"(workspace {} "{}"; move workspace to output "{}"; workspace {} "{}")";

  static int convertWorkspaceNameToNum(std::string name);

@ -33,10 +37,11 @@ class Workspaces : public AModule, public sigc::trackable {
  const std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
  uint16_t getWorkspaceIndex(const std::string& name) const;
  std::string trimWorkspaceName(std::string);
-  bool              handleScroll(GdkEventScroll*);
+  bool handleScroll(GdkEventScroll*) override;

  const Bar& bar_;
  std::vector<Json::Value> workspaces_;
+  std::vector<std::string> high_priority_named_;
  std::vector<std::string> workspaces_order_;
  Gtk::Box box_;
  util::JsonParser parser_;
--- a/include/modules/temperature.hpp
+++ b/include/modules/temperature.hpp
@ -1,7 +1,9 @@
 #pragma once

 #include <fmt/format.h>
+
 #include <fstream>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

@ -10,8 +12,8 @@ namespace waybar::modules {
 class Temperature : public ALabel {
 public:
  Temperature(const std::string&, const Json::Value&);
-  ~Temperature() = default;
-  auto update() -> void;
+  virtual ~Temperature() = default;
+  auto update() -> void override;

 private:
  float getTemperature();
--- a/include/modules/upower/upower.hpp
+++ b/include/modules/upower/upower.hpp
@ -0,0 +1,80 @@
+#pragma once
+
+#include <libupower-glib/upower.h>
+
+#include <iostream>
+#include <map>
+#include <string>
+#include <unordered_map>
+
+#include "ALabel.hpp"
+#include "glibconfig.h"
+#include "gtkmm/box.h"
+#include "gtkmm/image.h"
+#include "gtkmm/label.h"
+#include "modules/upower/upower_tooltip.hpp"
+
+namespace waybar::modules::upower {
+
+class UPower : public AModule {
+ public:
+  UPower(const std::string &, const Json::Value &);
+  virtual ~UPower();
+  auto update() -> void override;
+
+ private:
+  typedef std::unordered_map<std::string, UpDevice *> Devices;
+
+  const std::string DEFAULT_FORMAT = "{percentage}";
+  const std::string DEFAULT_FORMAT_ALT = "{percentage} {time}";
+
+  static void deviceAdded_cb(UpClient *client, UpDevice *device, gpointer data);
+  static void deviceRemoved_cb(UpClient *client, const gchar *objectPath, gpointer data);
+  static void deviceNotify_cb(UpDevice *device, GParamSpec *pspec, gpointer user_data);
+  static void prepareForSleep_cb(GDBusConnection *system_bus, const gchar *sender_name,
+                                 const gchar *object_path, const gchar *interface_name,
+                                 const gchar *signal_name, GVariant *parameters,
+                                 gpointer user_data);
+  static void upowerAppear(GDBusConnection *conn, const gchar *name, const gchar *name_owner,
+                           gpointer data);
+  static void upowerDisappear(GDBusConnection *connection, const gchar *name, gpointer user_data);
+
+  void removeDevice(const gchar *objectPath);
+  void addDevice(UpDevice *device);
+  void setDisplayDevice();
+  void resetDevices();
+  void removeDevices();
+  bool show_tooltip_callback(int, int, bool, const Glib::RefPtr<Gtk::Tooltip> &tooltip);
+  bool handleToggle(GdkEventButton *const &) override;
+  std::string timeToString(gint64 time);
+
+  const std::string getDeviceStatus(UpDeviceState &state);
+
+  Gtk::Box box_;
+  Gtk::Image icon_;
+  Gtk::Label label_;
+
+  // Config
+  bool hideIfEmpty = true;
+  bool tooltip_enabled = true;
+  uint tooltip_spacing = 4;
+  uint tooltip_padding = 4;
+  uint iconSize = 20;
+  std::string format = DEFAULT_FORMAT;
+  std::string format_alt = DEFAULT_FORMAT_ALT;
+
+  Devices devices;
+  std::mutex m_Mutex;
+  UpClient *client;
+  UpDevice *displayDevice;
+  guint login1_id;
+  GDBusConnection *login1_connection;
+  UPowerTooltip *upower_tooltip;
+  std::string lastStatus;
+  bool showAltText;
+  bool upowerRunning;
+  guint upowerWatcher_id;
+  std::string nativePath_;
+};
+
+}  // namespace waybar::modules::upower
--- a/include/modules/upower/upower_tooltip.hpp
+++ b/include/modules/upower/upower_tooltip.hpp
@ -0,0 +1,32 @@
+#pragma once
+
+#include <libupower-glib/upower.h>
+
+#include <unordered_map>
+
+#include "gtkmm/box.h"
+#include "gtkmm/label.h"
+#include "gtkmm/window.h"
+
+namespace waybar::modules::upower {
+
+class UPowerTooltip : public Gtk::Window {
+ private:
+  typedef std::unordered_map<std::string, UpDevice*> Devices;
+
+  const std::string getDeviceIcon(UpDeviceKind& kind);
+
+  Gtk::Box* contentBox;
+
+  uint iconSize;
+  uint tooltipSpacing;
+  uint tooltipPadding;
+
+ public:
+  UPowerTooltip(uint iconSize, uint tooltipSpacing, uint tooltipPadding);
+  virtual ~UPowerTooltip();
+
+  uint updateTooltip(Devices& devices);
+};
+
+}  // namespace waybar::modules::upower
--- a/include/modules/user.hpp
+++ b/include/modules/user.hpp
@ -0,0 +1,34 @@
+#pragma once
+
+#include <fmt/chrono.h>
+#include <gdkmm/pixbuf.h>
+#include <glibmm/refptr.h>
+
+#include "AIconLabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+class User : public AIconLabel {
+ public:
+  User(const std::string&, const Json::Value&);
+  virtual ~User() = default;
+  auto update() -> void override;
+
+  bool handleToggle(GdkEventButton* const& e) override;
+
+ private:
+  util::SleeperThread thread_;
+
+  static constexpr inline int defaultUserImageWidth_ = 20;
+  static constexpr inline int defaultUserImageHeight_ = 20;
+
+  long uptime_as_seconds();
+  std::string get_user_login() const;
+  std::string get_user_home_dir() const;
+  std::string get_default_user_avatar_path() const;
+  void init_default_user_avatar(int width, int height);
+  void init_user_avatar(const std::string& path, int width, int height);
+  void init_avatar(const Json::Value& config);
+  void init_update_worker();
+};
+}  // namespace waybar::modules
--- a/include/modules/wireplumber.hpp
+++ b/include/modules/wireplumber.hpp
@ -0,0 +1,46 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <wp/wp.h>
+
+#include <algorithm>
+#include <array>
+
+#include "ALabel.hpp"
+
+namespace waybar::modules {
+
+class Wireplumber : public ALabel {
+ public:
+  Wireplumber(const std::string&, const Json::Value&);
+  virtual ~Wireplumber();
+  auto update() -> void override;
+
+ private:
+  void loadRequiredApiModules();
+  void prepare();
+  void activatePlugins();
+  static void updateVolume(waybar::modules::Wireplumber* self, uint32_t id);
+  static void updateNodeName(waybar::modules::Wireplumber* self, uint32_t id);
+  static void onPluginActivated(WpObject* p, GAsyncResult* res, waybar::modules::Wireplumber* self);
+  static void onObjectManagerInstalled(waybar::modules::Wireplumber* self);
+  static void onMixerChanged(waybar::modules::Wireplumber* self, uint32_t id);
+  static void onDefaultNodesApiChanged(waybar::modules::Wireplumber* self);
+
+  bool handleScroll(GdkEventScroll* e) override;
+
+  WpCore* wp_core_;
+  GPtrArray* apis_;
+  WpObjectManager* om_;
+  WpPlugin* mixer_api_;
+  WpPlugin* def_nodes_api_;
+  gchar* default_node_name_;
+  uint32_t pending_plugins_;
+  bool muted_;
+  double volume_;
+  double min_step_;
+  uint32_t node_id_{0};
+  std::string node_name_;
+};
+
+}  // namespace waybar::modules
--- a/include/modules/wlr/taskbar.hpp
+++ b/include/modules/wlr/taskbar.hpp
@ -1,35 +1,32 @@
 #pragma once

+#include <gdk/gdk.h>
+#include <glibmm/refptr.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/icontheme.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+#include <wayland-client.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
+#include "giomm/desktopappinfo.h"
 #include "util/json.hpp"
-
-#include <memory>
-#include <string>
-#include <vector>
-#include <unordered_set>
-
-#include <gdk/gdk.h>
-
-#include <glibmm/refptr.h>
-
-#include <gtkmm/box.h>
-#include <gtkmm/button.h>
-#include <gtkmm/image.h>
-#include <gtkmm/label.h>
-#include <gtkmm/icontheme.h>
-
-#include <wayland-client.h>
 #include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"

-
 namespace waybar::modules::wlr {

 class Taskbar;

-class Task
-{
+class Task {
 public:
  Task(const waybar::Bar &, const Json::Value &, Taskbar *,
       struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *);
@ -43,6 +40,8 @@ class Task
    FULLSCREEN = (1 << 3),
    INVALID = (1 << 4)
  };
+  // made public so TaskBar can reorder based on configuration.
+  Gtk::Button button;

 private:
  static uint32_t global_id;
@ -56,27 +55,37 @@ class Task

  uint32_t id_;

-    Gtk::Button button_;
  Gtk::Box content_;
  Gtk::Image icon_;
  Gtk::Label text_before_;
  Gtk::Label text_after_;
-    bool button_visible_;
-    bool ignored_;
+  Glib::RefPtr<Gio::DesktopAppInfo> app_info_;
+  bool button_visible_ = false;
+  bool ignored_ = false;

-    bool with_icon_;
+  bool with_icon_ = false;
+  bool with_name_ = false;
  std::string format_before_;
  std::string format_after_;

  std::string format_tooltip_;

+  std::string name_;
  std::string title_;
  std::string app_id_;
  uint32_t state_ = 0;

+  int32_t drag_start_x;
+  int32_t drag_start_y;
+  int32_t drag_start_button = -1;
+
 private:
  std::string repr() const;
  std::string state_string(bool = false) const;
+  void set_app_info_from_app_id_list(const std::string &app_id_list);
+  bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
+                       Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
+  void hide_if_ignored();

 public:
  /* Getter functions */
@ -101,6 +110,12 @@ class Task

  /* Callbacks for Gtk events */
  bool handle_clicked(GdkEventButton *);
+  bool handle_button_release(GdkEventButton *);
+  bool handle_motion_notify(GdkEventMotion *);
+  void handle_drag_data_get(const Glib::RefPtr<Gdk::DragContext> &context,
+                            Gtk::SelectionData &selection_data, guint info, guint time);
+  void handle_drag_data_received(const Glib::RefPtr<Gdk::DragContext> &context, int x, int y,
+                                 Gtk::SelectionData selection_data, guint info, guint time);

 public:
  bool operator==(const Task &) const;
@ -120,9 +135,7 @@ class Task

 using TaskPtr = std::unique_ptr<Task>;

-
-class Taskbar : public waybar::AModule
-{
+class Taskbar : public waybar::AModule {
 public:
  Taskbar(const std::string &, const waybar::Bar &, const Json::Value &);
  ~Taskbar();
@ -135,6 +148,7 @@ class Taskbar : public waybar::AModule

  std::vector<Glib::RefPtr<Gtk::IconTheme>> icon_themes_;
  std::unordered_set<std::string> ignore_list_;
+  std::map<std::string, std::string> app_ids_replace_map_;

  struct zwlr_foreign_toplevel_manager_v1 *manager_;
  struct wl_seat *seat_;
@ -157,8 +171,9 @@ class Taskbar : public waybar::AModule
  bool show_output(struct wl_output *) const;
  bool all_outputs() const;

-    std::vector<Glib::RefPtr<Gtk::IconTheme>> icon_themes() const;
+  const std::vector<Glib::RefPtr<Gtk::IconTheme>> &icon_themes() const;
  const std::unordered_set<std::string> &ignore_list() const;
+  const std::map<std::string, std::string> &app_ids_replace_map() const;
 };

 } /* namespace waybar::modules::wlr */
--- a/include/modules/wlr/workspace_manager.hpp
+++ b/include/modules/wlr/workspace_manager.hpp
@ -0,0 +1,172 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <gtkmm/button.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "ext-workspace-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::wlr {
+
+class WorkspaceManager;
+class WorkspaceGroup;
+
+class Workspace {
+ public:
+  Workspace(const waybar::Bar &bar, const Json::Value &config, WorkspaceGroup &workspace_group,
+            zext_workspace_handle_v1 *workspace, uint32_t id, std::string name);
+  ~Workspace();
+  auto update() -> void;
+
+  auto id() const -> uint32_t { return id_; }
+  auto is_active() const -> bool { return state_ & static_cast<uint32_t>(State::ACTIVE); }
+  auto is_urgent() const -> bool { return state_ & static_cast<uint32_t>(State::URGENT); }
+  auto is_hidden() const -> bool { return state_ & static_cast<uint32_t>(State::HIDDEN); }
+  auto is_empty() const -> bool { return state_ & static_cast<uint32_t>(State::EMPTY); }
+  auto is_persistent() const -> bool { return persistent_; }
+  // wlr stuff
+  auto handle_name(const std::string &name) -> void;
+  auto handle_coordinates(const std::vector<uint32_t> &coordinates) -> void;
+  auto handle_state(const std::vector<uint32_t> &state) -> void;
+  auto handle_remove() -> void;
+  auto make_persistent() -> void;
+  auto handle_duplicate() -> void;
+
+  auto handle_done() -> void;
+  auto handle_clicked(GdkEventButton *bt) -> bool;
+  auto show() -> void;
+  auto hide() -> void;
+  auto get_button_ref() -> Gtk::Button & { return button_; }
+  auto get_name() -> std::string & { return name_; }
+  auto get_coords() -> std::vector<uint32_t> & { return coordinates_; }
+
+  enum class State {
+    ACTIVE = (1 << 0),
+    URGENT = (1 << 1),
+    HIDDEN = (1 << 2),
+    EMPTY = (1 << 3),
+  };
+
+ private:
+  auto get_icon() -> std::string;
+
+  const Bar &bar_;
+  const Json::Value &config_;
+  WorkspaceGroup &workspace_group_;
+
+  // wlr stuff
+  zext_workspace_handle_v1 *workspace_handle_;
+  uint32_t state_ = 0;
+
+  uint32_t id_;
+  std::string name_;
+  std::vector<uint32_t> coordinates_;
+  static std::map<std::string, std::string> icons_map_;
+  std::string format_;
+  bool with_icon_ = false;
+  bool persistent_ = false;
+
+  Gtk::Button button_;
+  Gtk::Box content_;
+  Gtk::Label label_;
+};
+
+class WorkspaceGroup {
+ public:
+  WorkspaceGroup(const waybar::Bar &bar, Gtk::Box &box, const Json::Value &config,
+                 WorkspaceManager &manager, zext_workspace_group_handle_v1 *workspace_group_handle,
+                 uint32_t id);
+  ~WorkspaceGroup();
+  auto update() -> void;
+
+  auto id() const -> uint32_t { return id_; }
+  auto is_visible() const -> bool;
+  auto remove_workspace(uint32_t id_) -> void;
+  auto active_only() const -> bool;
+  auto creation_delayed() const -> bool;
+  auto workspaces() -> std::vector<std::unique_ptr<Workspace>> & { return workspaces_; }
+  auto persistent_workspaces() -> std::vector<std::string> & { return persistent_workspaces_; }
+
+  auto sort_workspaces() -> void;
+  auto set_need_to_sort() -> void { need_to_sort = true; }
+  auto add_button(Gtk::Button &button) -> void;
+  auto remove_button(Gtk::Button &button) -> void;
+  auto fill_persistent_workspaces() -> void;
+  auto create_persistent_workspaces() -> void;
+
+  // wlr stuff
+  auto handle_workspace_create(zext_workspace_handle_v1 *workspace_handle) -> void;
+  auto handle_remove() -> void;
+  auto handle_output_enter(wl_output *output) -> void;
+  auto handle_output_leave() -> void;
+  auto handle_done() -> void;
+  auto commit() -> void;
+
+ private:
+  static uint32_t workspace_global_id;
+  const waybar::Bar &bar_;
+  Gtk::Box &box_;
+  const Json::Value &config_;
+  WorkspaceManager &workspace_manager_;
+
+  // wlr stuff
+  zext_workspace_group_handle_v1 *workspace_group_handle_;
+  wl_output *output_ = nullptr;
+
+  uint32_t id_;
+  std::vector<std::unique_ptr<Workspace>> workspaces_;
+  bool need_to_sort = false;
+  std::vector<std::string> persistent_workspaces_;
+  bool persistent_created_ = false;
+};
+
+class WorkspaceManager : public AModule {
+ public:
+  WorkspaceManager(const std::string &id, const waybar::Bar &bar, const Json::Value &config);
+  ~WorkspaceManager() override;
+  auto update() -> void override;
+
+  auto all_outputs() const -> bool { return all_outputs_; }
+  auto active_only() const -> bool { return active_only_; }
+  auto workspace_comparator() const
+      -> std::function<bool(std::unique_ptr<Workspace> &, std::unique_ptr<Workspace> &)>;
+  auto creation_delayed() const -> bool { return creation_delayed_; }
+
+  auto sort_workspaces() -> void;
+  auto remove_workspace_group(uint32_t id_) -> void;
+
+  // wlr stuff
+  auto register_manager(wl_registry *registry, uint32_t name, uint32_t version) -> void;
+  auto handle_workspace_group_create(zext_workspace_group_handle_v1 *workspace_group_handle)
+      -> void;
+  auto handle_done() -> void;
+  auto handle_finished() -> void;
+  auto commit() -> void;
+
+ private:
+  const waybar::Bar &bar_;
+  Gtk::Box box_;
+  std::vector<std::unique_ptr<WorkspaceGroup>> groups_;
+
+  // wlr stuff
+  zext_workspace_manager_v1 *workspace_manager_ = nullptr;
+
+  static uint32_t group_global_id;
+
+  bool sort_by_name_ = true;
+  bool sort_by_coordinates_ = true;
+  bool sort_by_number_ = false;
+  bool all_outputs_ = false;
+  bool active_only_ = false;
+  bool creation_delayed_ = false;
+};
+
+}  // namespace waybar::modules::wlr
--- a/include/modules/wlr/workspace_manager_binding.hpp
+++ b/include/modules/wlr/workspace_manager_binding.hpp
@ -0,0 +1,10 @@
+#include "ext-workspace-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::wlr {
+void add_registry_listener(void *data);
+void add_workspace_listener(zext_workspace_handle_v1 *workspace_handle, void *data);
+void add_workspace_group_listener(zext_workspace_group_handle_v1 *workspace_group_handle,
+                                  void *data);
+zext_workspace_manager_v1 *workspace_manager_bind(wl_registry *registry, uint32_t name,
+                                                  uint32_t version, void *data);
+}  // namespace waybar::modules::wlr
--- a/include/util/SafeSignal.hpp
+++ b/include/util/SafeSignal.hpp
@ -0,0 +1,75 @@
+#pragma once
+
+#include <glibmm/dispatcher.h>
+#include <sigc++/signal.h>
+
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace waybar {
+
+/**
+ * Thread-safe signal wrapper.
+ * Uses Glib::Dispatcher to pass events to another thread and locked queue to pass the arguments.
+ */
+template <typename... Args>
+struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
+ public:
+  SafeSignal() { dp_.connect(sigc::mem_fun(*this, &SafeSignal::handle_event)); }
+
+  template <typename... EmitArgs>
+  void emit(EmitArgs&&... args) {
+    if (main_tid_ == std::this_thread::get_id()) {
+      /*
+       * Bypass the queue if the method is called the main thread.
+       * Ensures that events emitted from the main thread are processed synchronously and saves a
+       * few CPU cycles on locking/queuing.
+       * As a downside, this makes main thread events prioritized over the other threads and
+       * disrupts chronological order.
+       */
+      signal_t::emit(std::forward<EmitArgs>(args)...);
+    } else {
+      {
+        std::unique_lock lock(mutex_);
+        queue_.emplace(std::forward<EmitArgs>(args)...);
+      }
+      dp_.emit();
+    }
+  }
+
+  template <typename... EmitArgs>
+  inline void operator()(EmitArgs&&... args) {
+    emit(std::forward<EmitArgs>(args)...);
+  }
+
+ protected:
+  using signal_t = sigc::signal<void(std::decay_t<Args>...)>;
+  using slot_t = decltype(std::declval<signal_t>().make_slot());
+  using arg_tuple_t = std::tuple<std::decay_t<Args>...>;
+  // ensure that unwrapped methods are not accessible
+  using signal_t::emit_reverse;
+  using signal_t::make_slot;
+
+  void handle_event() {
+    for (std::unique_lock lock(mutex_); !queue_.empty(); lock.lock()) {
+      auto args = queue_.front();
+      queue_.pop();
+      lock.unlock();
+      std::apply(cached_fn_, args);
+    }
+  }
+
+  Glib::Dispatcher dp_;
+  std::mutex mutex_;
+  std::queue<arg_tuple_t> queue_;
+  const std::thread::id main_tid_ = std::this_thread::get_id();
+  // cache functor for signal emission to avoid recreating it on each event
+  const slot_t cached_fn_ = make_slot();
+};
+
+}  // namespace waybar
--- a/include/util/clara.hpp
+++ b/include/util/clara.hpp
@ -27,7 +27,6 @@
 #endif
 #endif

-
 // ----------- #included from clara_textflow.hpp -----------

 // TextFlowCpp
@ -51,8 +50,8 @@
 #define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
 #endif

-
-namespace clara { namespace TextFlow {
+namespace clara {
+namespace TextFlow {

 inline auto isWhitespace(char c) -> bool {
  static std::string chars = " \t\n\r";
@ -88,9 +87,7 @@ namespace clara { namespace TextFlow {
    bool m_suffix = false;

    iterator(Column const &column, size_t stringIndex)
-            :   m_column( column ),
-                m_stringIndex( stringIndex )
-            {}
+        : m_column(column), m_stringIndex(stringIndex) {}

    auto line() const -> std::string const & { return m_column.m_strings[m_stringIndex]; }

@ -98,10 +95,8 @@ namespace clara { namespace TextFlow {
      assert(at > 0);
      assert(at <= line().size());

-                return at == line().size() ||
-                       ( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
-                       isBreakableBefore( line()[at] ) ||
-                       isBreakableAfter( line()[at-1] );
+      return at == line().size() || (isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+             isBreakableBefore(line()[at]) || isBreakableAfter(line()[at - 1]);
    }

    void calcLength() {
@ -110,18 +105,14 @@ namespace clara { namespace TextFlow {
      m_suffix = false;
      auto width = m_column.m_width - indent();
      m_end = m_pos;
-                while( m_end < line().size() && line()[m_end] != '\n' )
-                    ++m_end;
+      while (m_end < line().size() && line()[m_end] != '\n') ++m_end;

      if (m_end < m_pos + width) {
        m_len = m_end - m_pos;
-                }
-                else {
+      } else {
        size_t len = width;
-                    while (len > 0 && !isBoundary(m_pos + len))
-                        --len;
-                    while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
-                        --len;
+        while (len > 0 && !isBoundary(m_pos + len)) --len;
+        while (len > 0 && isWhitespace(line()[m_pos + len - 1])) --len;

        if (len > 0) {
          m_len = len;
@ -133,7 +124,8 @@ namespace clara { namespace TextFlow {
    }

    auto indent() const -> size_t {
-                auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+      auto initial =
+          m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
      return initial == std::string::npos ? m_column.m_indent : initial;
    }

@ -150,10 +142,10 @@ namespace clara { namespace TextFlow {

    explicit iterator(Column const &column) : m_column(column) {
      assert(m_column.m_width > m_column.m_indent);
-                assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
+      assert(m_column.m_initialIndent == std::string::npos ||
+             m_column.m_width > m_column.m_initialIndent);
      calcLength();
-                if( m_len == 0 )
-                    m_stringIndex++; // Empty string
+      if (m_len == 0) m_stringIndex++;  // Empty string
    }

    auto operator*() const -> std::string {
@ -167,15 +159,13 @@ namespace clara { namespace TextFlow {
      if (m_pos < line().size() && line()[m_pos] == '\n')
        m_pos += 1;
      else
-                    while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
-                        ++m_pos;
+        while (m_pos < line().size() && isWhitespace(line()[m_pos])) ++m_pos;

      if (m_pos == line().size()) {
        m_pos = 0;
        ++m_stringIndex;
      }
-                if( m_stringIndex < m_column.m_strings.size() )
-                    calcLength();
+      if (m_stringIndex < m_column.m_strings.size()) calcLength();
      return *this;
    }
    auto operator++(int) -> iterator {
@ -185,14 +175,10 @@ namespace clara { namespace TextFlow {
    }

    auto operator==(iterator const &other) const -> bool {
-                return
-                    m_pos == other.m_pos &&
-                    m_stringIndex == other.m_stringIndex &&
+      return m_pos == other.m_pos && m_stringIndex == other.m_stringIndex &&
             &m_column == &other.m_column;
    }
-            auto operator !=( iterator const& other ) const -> bool {
-                return !operator==( other );
-            }
+    auto operator!=(iterator const &other) const -> bool { return !operator==(other); }
  };
  using const_iterator = iterator;

@ -238,18 +224,14 @@ namespace clara { namespace TextFlow {
 };

 class Spacer : public Column {
-
 public:
-        explicit Spacer( size_t spaceWidth ) : Column( "" ) {
-            width( spaceWidth );
-        }
+  explicit Spacer(size_t spaceWidth) : Column("") { width(spaceWidth); }
 };

 class Columns {
  std::vector<Column> m_columns;

 public:
-
  class iterator {
    friend Columns;
    struct EndTag {};
@ -258,14 +240,10 @@ namespace clara { namespace TextFlow {
    std::vector<Column::iterator> m_iterators;
    size_t m_activeIterators;

-            iterator( Columns const& columns, EndTag )
-            :   m_columns( columns.m_columns ),
-                m_activeIterators( 0 )
-            {
+    iterator(Columns const &columns, EndTag) : m_columns(columns.m_columns), m_activeIterators(0) {
      m_iterators.reserve(m_columns.size());

-                for( auto const& col : m_columns )
-                    m_iterators.push_back( col.end() );
+      for (auto const &col : m_columns) m_iterators.push_back(col.end());
    }

   public:
@ -276,13 +254,10 @@ namespace clara { namespace TextFlow {
    using iterator_category = std::forward_iterator_tag;

    explicit iterator(Columns const &columns)
-            :   m_columns( columns.m_columns ),
-                m_activeIterators( m_columns.size() )
-            {
+        : m_columns(columns.m_columns), m_activeIterators(m_columns.size()) {
      m_iterators.reserve(m_columns.size());

-                for( auto const& col : m_columns )
-                    m_iterators.push_back( col.begin() );
+      for (auto const &col : m_columns) m_iterators.push_back(col.begin());
    }

    auto operator==(iterator const &other) const -> bool {
@ -303,8 +278,7 @@ namespace clara { namespace TextFlow {
            padding = std::string(width - col.size(), ' ');
          else
            padding = "";
-                    }
-                    else {
+        } else {
          padding += std::string(width, ' ');
        }
      }
@ -312,8 +286,7 @@ namespace clara { namespace TextFlow {
    }
    auto operator++() -> iterator & {
      for (size_t i = 0; i < m_columns.size(); ++i) {
-                    if (m_iterators[i] != m_columns[i].end())
-                        ++m_iterators[i];
+        if (m_iterators[i] != m_columns[i].end()) ++m_iterators[i];
      }
      return *this;
    }
@ -339,7 +312,6 @@ namespace clara { namespace TextFlow {
  }

  inline friend std::ostream &operator<<(std::ostream &os, Columns const &cols) {
-
    bool first = true;
    for (auto line : cols) {
      if (first)
@ -364,19 +336,20 @@ namespace clara { namespace TextFlow {
  cols += other;
  return cols;
 }
-}}
+}  // namespace TextFlow
+}  // namespace clara

 #endif  // CLARA_TEXTFLOW_HPP_INCLUDED

 // ----------- end of #include from clara_textflow.hpp -----------
 // ........... back in clara.hpp

-
+#include <algorithm>
 #include <memory>
 #include <set>
-#include <algorithm>

-#if !defined(CLARA_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#if !defined(CLARA_PLATFORM_WINDOWS) && \
+    (defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER))
 #define CLARA_PLATFORM_WINDOWS
 #endif

@ -408,25 +381,17 @@ namespace detail {
  std::vector<std::string> m_args;

 public:
-        Args( int argc, char const* const* argv )
-            : m_exeName(argv[0]),
-              m_args(argv + 1, argv + argc) {}
+  Args(int argc, char const *const *argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}

  Args(std::initializer_list<std::string> args)
-        :   m_exeName( *args.begin() ),
-            m_args( args.begin()+1, args.end() )
-        {}
+      : m_exeName(*args.begin()), m_args(args.begin() + 1, args.end()) {}

-        auto exeName() const -> std::string {
-            return m_exeName;
-        }
+  auto exeName() const -> std::string { return m_exeName; }
 };

-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
-    // may encode an option + its argument if the : or = form is used
-    enum class TokenType {
-        Option, Argument
-    };
+// Wraps a token coming from a token stream. These may not directly correspond to strings as a
+// single string may encode an option + its argument if the : or = form is used
+enum class TokenType { Option, Argument };
 struct Token {
  TokenType type;
  std::string token;
@ -451,8 +416,7 @@ namespace detail {
    m_tokenBuffer.resize(0);

    // Skip any empty strings
-            while( it != itEnd && it->empty() )
-                ++it;
+    while (it != itEnd && it->empty()) ++it;

    if (it != itEnd) {
      auto const &next = *it;
@ -481,13 +445,9 @@ namespace detail {
 public:
  explicit TokenStream(Args const &args) : TokenStream(args.m_args.begin(), args.m_args.end()) {}

-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
-            loadBuffer();
-        }
+  TokenStream(Iterator it, Iterator itEnd) : it(it), itEnd(itEnd) { loadBuffer(); }

-        explicit operator bool() const {
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
+  explicit operator bool() const { return !m_tokenBuffer.empty() || it != itEnd; }

  auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }

@ -505,20 +465,16 @@ namespace detail {
    if (m_tokenBuffer.size() >= 2) {
      m_tokenBuffer.erase(m_tokenBuffer.begin());
    } else {
-                if( it != itEnd )
-                    ++it;
+      if (it != itEnd) ++it;
      loadBuffer();
    }
    return *this;
  }
 };

-
 class ResultBase {
 public:
-        enum Type {
-            Ok, LogicError, RuntimeError
-        };
+  enum Type { Ok, LogicError, RuntimeError };

 protected:
  ResultBase(Type type) : m_type(type) {}
@ -541,26 +497,20 @@ namespace detail {
  ResultValueBase(Type type) : ResultBase(type) {}

  ResultValueBase(ResultValueBase const &other) : ResultBase(other) {
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
+    if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
  }

-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
-            new( &m_value ) T( value );
-        }
+  ResultValueBase(Type, T const &value) : ResultBase(Ok) { new (&m_value) T(value); }

  auto operator=(ResultValueBase const &other) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
-                m_value.~T();
+    if (m_type == ResultBase::Ok) m_value.~T();
    ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
+    if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
    return *this;
  }

  ~ResultValueBase() override {
-            if( m_type == Ok )
-                m_value.~T();
+    if (m_type == Ok) m_value.~T();
  }

  union {
@ -579,17 +529,21 @@ namespace detail {
 public:
  template <typename U>
  explicit BasicResult(BasicResult<U> const &other)
-        :   ResultValueBase<T>( other.type() ),
-            m_errorMessage( other.errorMessage() )
-        {
+      : ResultValueBase<T>(other.type()), m_errorMessage(other.errorMessage()) {
    assert(type() != ResultBase::Ok);
  }

  template <typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+  static auto ok(U const &value) -> BasicResult {
+    return {ResultBase::Ok, value};
+  }
  static auto ok() -> BasicResult { return {ResultBase::Ok}; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+  static auto logicError(std::string const &message) -> BasicResult {
+    return {ResultBase::LogicError, message};
+  }
+  static auto runtimeError(std::string const &message) -> BasicResult {
+    return {ResultBase::RuntimeError, message};
+  }

  explicit operator bool() const { return m_type == ResultBase::Ok; }
  auto type() const -> ResultBase::Type { return m_type; }
@ -597,21 +551,17 @@ namespace detail {

 protected:
  void enforceOk() const override {
-
    // Errors shouldn't reach this point, but if they do
    // the actual error message will be in m_errorMessage
    assert(m_type != ResultBase::LogicError);
    assert(m_type != ResultBase::RuntimeError);
-            if( m_type != ResultBase::Ok )
-                std::abort();
+    if (m_type != ResultBase::Ok) std::abort();
  }

  std::string m_errorMessage;  // Only populated if resultType is an error

  BasicResult(ResultBase::Type type, std::string const &message)
-        :   ResultValueBase<T>(type),
-            m_errorMessage(message)
-        {
+      : ResultValueBase<T>(type), m_errorMessage(message) {
    assert(m_type != ResultBase::Ok);
  }

@ -619,17 +569,12 @@ namespace detail {
  using ResultBase::m_type;
 };

-    enum class ParseResultType {
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
+enum class ParseResultType { Matched, NoMatch, ShortCircuitAll, ShortCircuitSame };

 class ParseState {
 public:
-
  ParseState(ParseResultType type, TokenStream const &remainingTokens)
-        : m_type(type),
-          m_remainingTokens( remainingTokens )
-        {}
+      : m_type(type), m_remainingTokens(remainingTokens) {}

  auto type() const -> ParseResultType { return m_type; }
  auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
@ -664,22 +609,24 @@ namespace detail {
 }
 inline auto convertInto(std::string const &source, bool &target) -> ParserResult {
  std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
+  std::transform(srcLC.begin(), srcLC.end(), srcLC.begin(),
+                 [](char c) { return static_cast<char>(::tolower(c)); });
  if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
    target = true;
  else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
    target = false;
  else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+    return ParserResult::runtimeError("Expected a boolean value but did not recognise: '" + source +
+                                      "'");
  return ParserResult::ok(ParseResultType::Matched);
 }
 #ifdef CLARA_CONFIG_OPTIONAL_TYPE
 template <typename T>
-    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
+inline auto convertInto(std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T> &target)
+    -> ParserResult {
  T temp;
  auto result = convertInto(source, temp);
-        if( result )
-            target = std::move(temp);
+  if (result) target = std::move(temp);
  return result;
 }
 #endif  // CLARA_CONFIG_OPTIONAL_TYPE
@ -711,9 +658,7 @@ namespace detail {

  explicit BoundValueRef(T &ref) : m_ref(ref) {}

-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return convertInto( arg, m_ref );
-        }
+  auto setValue(std::string const &arg) -> ParserResult override { return convertInto(arg, m_ref); }
 };

 template <typename T>
@ -727,8 +672,7 @@ namespace detail {
  auto setValue(std::string const &arg) -> ParserResult override {
    T temp;
    auto result = convertInto(arg, temp);
-            if( result )
-                m_ref.push_back( temp );
+    if (result) m_ref.push_back(temp);
    return result;
  }
 };
@ -746,7 +690,8 @@ namespace detail {

 template <typename ReturnType>
 struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+  static_assert(std::is_same<ReturnType, ParserResult>::value,
+                "Lambda must return void or clara::ParserResult");

  template <typename L, typename ArgType>
  static auto invoke(L const &lambda, ArgType const &arg) -> ParserResult {
@ -767,12 +712,10 @@ namespace detail {
 inline auto invokeLambda(L const &lambda, std::string const &arg) -> ParserResult {
  ArgType temp{};
  auto result = convertInto(arg, temp);
-        return !result
-           ? result
+  return !result ? result
                 : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke(lambda, temp);
 }

-
 template <typename L>
 struct BoundLambda : BoundValueRefBase {
  L m_lambda;
@ -790,7 +733,8 @@ namespace detail {
  L m_lambda;

  static_assert(UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument");
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+  static_assert(std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value,
+                "flags must be boolean");

  explicit BoundFlagLambda(L const &lambda) : m_lambda(lambda) {}

@ -807,7 +751,8 @@ namespace detail {
 public:
  virtual ~ParserBase() = default;
  virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+  virtual auto parse(std::string const &exeName, TokenStream const &tokens) const
+      -> InternalParseResult = 0;
  virtual auto cardinality() const -> size_t { return 1; }

  auto parse(Args const &args) const -> InternalParseResult {
@ -839,15 +784,11 @@ namespace detail {
 public:
  template <typename T>
  ParserRefImpl(T &ref, std::string const &hint)
-        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
-            m_hint( hint )
-        {}
+      : m_ref(std::make_shared<BoundValueRef<T>>(ref)), m_hint(hint) {}

  template <typename LambdaT>
  ParserRefImpl(LambdaT const &ref, std::string const &hint)
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-            m_hint(hint)
-        {}
+      : m_ref(std::make_shared<BoundLambda<LambdaT>>(ref)), m_hint(hint) {}

  auto operator()(std::string const &description) -> DerivedT & {
    m_description = description;
@ -864,9 +805,7 @@ namespace detail {
    return static_cast<DerivedT &>(*this);
  };

-        auto isOptional() const -> bool {
-            return m_optionality == Optionality::Optional;
-        }
+  auto isOptional() const -> bool { return m_optionality == Optionality::Optional; }

  auto cardinality() const -> size_t override {
    if (m_ref->isContainer())
@ -906,11 +845,8 @@ namespace detail {

  auto name() const -> std::string { return *m_name; }
  auto set(std::string const &newName) -> ParserResult {
-
    auto lastSlash = newName.find_last_of("\\/");
-            auto filename = ( lastSlash == std::string::npos )
-                    ? newName
-                    : newName.substr( lastSlash+1 );
+    auto filename = (lastSlash == std::string::npos) ? newName : newName.substr(lastSlash + 1);

    *m_name = filename;
    if (m_ref)
@ -926,8 +862,7 @@ namespace detail {

  auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
    auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
+    if (!validationResult) return InternalParseResult(validationResult);

    auto remainingTokens = tokens;
    auto const &token = *remainingTokens;
@ -960,7 +895,8 @@ namespace detail {

 public:
  template <typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+  explicit Opt(LambdaT const &ref)
+      : ParserRefImpl(std::make_shared<BoundFlagLambda<LambdaT>>(ref)) {}

  explicit Opt(bool &ref) : ParserRefImpl(std::make_shared<BoundFlagRef>(ref)) {}

@ -985,16 +921,14 @@ namespace detail {
        oss << ", ";
      oss << opt;
    }
-            if( !m_hint.empty() )
-                oss << " <" << m_hint << ">";
+    if (!m_hint.empty()) oss << " <" << m_hint << ">";
    return {{oss.str(), m_description}};
  }

  auto isMatch(std::string const &optToken) const -> bool {
    auto normalisedToken = normaliseOpt(optToken);
    for (auto const &name : m_optNames) {
-                if( normaliseOpt( name ) == normalisedToken )
-                    return true;
+      if (normaliseOpt(name) == normalisedToken) return true;
    }
    return false;
  }
@ -1003,8 +937,7 @@ namespace detail {

  auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
    auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
+    if (!validationResult) return InternalParseResult(validationResult);

    auto remainingTokens = tokens;
    if (remainingTokens && remainingTokens->type == TokenType::Option) {
@ -1013,8 +946,7 @@ namespace detail {
        if (m_ref->isFlag()) {
          auto flagRef = static_cast<detail::BoundFlagRefBase *>(m_ref.get());
          auto result = flagRef->setFlag(true);
-                        if( !result )
-                            return InternalParseResult( result );
+          if (!result) return InternalParseResult(result);
          if (result.value() == ParseResultType::ShortCircuitAll)
            return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
        } else {
@ -1026,8 +958,7 @@ namespace detail {
          if (argToken.type != TokenType::Argument)
            return InternalParseResult::runtimeError("Expected argument following " + token.token);
          auto result = valueRef->setValue(argToken.token);
-                        if( !result )
-                            return InternalParseResult( result );
+          if (!result) return InternalParseResult(result);
          if (result.value() == ParseResultType::ShortCircuitAll)
            return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
        }
@ -1038,17 +969,14 @@ namespace detail {
  }

  auto validate() const -> Result override {
-            if( m_optNames.empty() )
-                return Result::logicError( "No options supplied to Opt" );
+    if (m_optNames.empty()) return Result::logicError("No options supplied to Opt");
    for (auto const &name : m_optNames) {
-                if( name.empty() )
-                    return Result::logicError( "Option name cannot be empty" );
+      if (name.empty()) return Result::logicError("Option name cannot be empty");
 #ifdef CLARA_PLATFORM_WINDOWS
      if (name[0] != '-' && name[0] != '/')
        return Result::logicError("Option name must begin with '-' or '/'");
 #else
-                if( name[0] != '-' )
-                    return Result::logicError( "Option name must begin with '-'" );
+      if (name[0] != '-') return Result::logicError("Option name must begin with '-'");
 #endif
    }
    return ParserRefImpl::validate();
@ -1060,18 +988,12 @@ namespace detail {
      : Opt([&](bool flag) {
          showHelpFlag = flag;
          return ParserResult::ok(ParseResultType::ShortCircuitAll);
-            })
-        {
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
+        }) {
+    static_cast<Opt &>(*this)("display usage information")["-?"]["-h"]["--help"].optional();
  }
 };

-
 struct Parser : ParserBase {
-
  mutable ExeName m_exeName;
  std::vector<Opt> m_options;
  std::vector<Arg> m_args;
@ -1104,9 +1026,13 @@ namespace detail {

  // Forward deprecated interface with '+' instead of '|'
  template <typename T>
-        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+  auto operator+=(T const &other) -> Parser & {
+    return operator|=(other);
+  }
  template <typename T>
-        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+  auto operator+(T const &other) const -> Parser {
+    return operator|(other);
+  }

  auto getHelpColumns() const -> std::vector<HelpColumns> {
    std::vector<HelpColumns> cols;
@ -1119,7 +1045,8 @@ namespace detail {

  void writeToStream(std::ostream &os) const {
    if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
+      os << "usage:\n"
+         << "  " << m_exeName.name() << " ";
      bool required = true, first = true;
      for (auto const &arg : m_args) {
        if (first)
@ -1131,28 +1058,22 @@ namespace detail {
          required = false;
        }
        os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
-                        os << " ... ";
+        if (arg.cardinality() == 0) os << " ... ";
      }
-                if( !required )
-                    os << "]";
-                if( !m_options.empty() )
-                    os << " options";
+      if (!required) os << "]";
+      if (!m_options.empty()) os << " options";
      os << "\n\nwhere options are:" << std::endl;
    }

    auto rows = getHelpColumns();
    size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
    size_t optWidth = 0;
-            for( auto const &cols : rows )
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
+    for (auto const &cols : rows) optWidth = (std::max)(optWidth, cols.left.size() + 2);

    optWidth = (std::min)(optWidth, consoleWidth / 2);

    for (auto const &cols : rows) {
-                auto row =
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
+      auto row = TextFlow::Column(cols.left).width(optWidth).indent(2) + TextFlow::Spacer(4) +
                 TextFlow::Column(cols.right).width(consoleWidth - 7 - optWidth);
      os << row << std::endl;
    }
@ -1166,21 +1087,19 @@ namespace detail {
  auto validate() const -> Result override {
    for (auto const &opt : m_options) {
      auto result = opt.validate();
-                if( !result )
-                    return result;
+      if (!result) return result;
    }
    for (auto const &arg : m_args) {
      auto result = arg.validate();
-                if( !result )
-                    return result;
+      if (!result) return result;
    }
    return Result::ok();
  }

  using ParserBase::parse;

-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
-
+  auto parse(std::string const &exeName, TokenStream const &tokens) const
+      -> InternalParseResult override {
    struct ParserInfo {
      ParserBase const *parser = nullptr;
      size_t count = 0;
@ -1204,10 +1123,10 @@ namespace detail {

      for (size_t i = 0; i < totalParsers; ++i) {
        auto &parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+        if (parseInfo.parser->cardinality() == 0 ||
+            parseInfo.count < parseInfo.parser->cardinality()) {
          result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
-                            return result;
+          if (!result) return result;
          if (result.value().type() != ParseResultType::NoMatch) {
            tokenParsed = true;
            ++parseInfo.count;
@ -1216,10 +1135,10 @@ namespace detail {
        }
      }

-                if( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
+      if (result.value().type() == ParseResultType::ShortCircuitAll) return result;
      if (!tokenParsed)
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+        return InternalParseResult::runtimeError("Unrecognised token: " +
+                                                 result.value().remainingTokens()->token);
    }
    // !TBD Check missing required options
    return result;
@ -1233,7 +1152,6 @@ namespace detail {
 }
 }  // namespace detail

-
 // A Combined parser
 using detail::Parser;

@ -1258,7 +1176,6 @@ using detail::ParseResultType;
 // Result type for parser operation
 using detail::ParserResult;

-
 }  // namespace clara

 #endif  // CLARA_HPP_INCLUDED
--- a/include/util/command.hpp
+++ b/include/util/command.hpp
@ -1,5 +1,6 @@
 #pragma once

+#include <fcntl.h>
 #include <giomm.h>
 #include <spdlog/spdlog.h>
 #include <sys/wait.h>
@ -68,12 +69,21 @@ inline int close(FILE* fp, pid_t pid) {
 inline FILE* open(const std::string& cmd, int& pid) {
  if (cmd == "") return nullptr;
  int fd[2];
-  pipe(fd);
+  // Open the pipe with the close-on-exec flag set, so it will not be inherited
+  // by any other subprocesses launched by other threads (which could result in
+  // the pipe staying open after this child dies, causing us to hang when trying
+  // to read from it)
+  if (pipe2(fd, O_CLOEXEC) != 0) {
+    spdlog::error("Unable to pipe fd");
+    return nullptr;
+  }

  pid_t child_pid = fork();

  if (child_pid < 0) {
    spdlog::error("Unable to exec cmd {}, error {}", cmd.c_str(), strerror(errno));
+    ::close(fd[0]);
+    ::close(fd[1]);
    return nullptr;
  }

--- a/include/util/date.hpp
+++ b/include/util/date.hpp
@ -0,0 +1,60 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#if HAVE_CHRONO_TIMEZONES
+#include <chrono>
+#include <format>
+
+/* Compatibility layer for <date/tz.h> on top of C++20 <chrono> */
+namespace date {
+
+using namespace std::chrono;
+
+namespace literals {
+using std::chrono::last;
+}
+
+inline auto format(const std::string& spec, const auto& ztime) {
+  return spec.empty() ? "" : std::vformat("{:L" + spec + "}", std::make_format_args(ztime));
+}
+
+inline auto format(const std::locale& loc, const std::string& spec, const auto& ztime) {
+  return spec.empty() ? "" : std::vformat(loc, "{:L" + spec + "}", std::make_format_args(ztime));
+}
+
+}  // namespace date
+
+#else
+#include <date/tz.h>
+#endif
+
+template <typename Duration, typename TimeZonePtr>
+struct fmt::formatter<date::zoned_time<Duration, TimeZonePtr>> {
+  std::string_view specs;
+
+  template <typename ParseContext>
+  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it == ':') {
+      ++it;
+    }
+    auto end = it;
+    while (end != ctx.end() && *end != '}') {
+      ++end;
+    }
+    if (end != it) {
+      specs = {it, std::string_view::size_type(end - it)};
+    }
+    return end;
+  }
+
+  template <typename FormatContext>
+  auto format(const date::zoned_time<Duration, TimeZonePtr>& ztime, FormatContext& ctx) {
+    if (ctx.locale()) {
+      const auto loc = ctx.locale().template get<std::locale>();
+      return fmt::format_to(ctx.out(), "{}", date::format(loc, fmt::to_string(specs), ztime));
+    }
+    return fmt::format_to(ctx.out(), "{}", date::format(fmt::to_string(specs), ztime));
+  }
+};
--- a/include/util/format.hpp
+++ b/include/util/format.hpp
@ -1,18 +1,18 @@
 #pragma once

 #include <fmt/format.h>
+#include <glibmm/ustring.h>

 class pow_format {
 public:
-    pow_format(long long val, std::string&& unit, bool binary = false):
-      val_(val), unit_(unit), binary_(binary) { };
+  pow_format(long long val, std::string&& unit, bool binary = false)
+      : val_(val), unit_(unit), binary_(binary){};

  long long val_;
  std::string unit_;
  bool binary_;
 };

-
 namespace fmt {
 template <>
 struct formatter<pow_format> {
@ -56,8 +56,9 @@ namespace fmt {
      fraction /= base;
    }

-          auto max_width = 4                  // coeff in {:.3g} format
-                         + 1                  // prefix from units array
+    auto number_width = 5              // coeff in {:.1f} format
+                        + s.binary_;   // potential 4th digit before the decimal point
+    auto max_width = number_width + 1  // prefix from units array
                     + s.binary_       // for the 'i' in GiB.
                     + s.unit_.length();

@ -65,24 +66,34 @@ namespace fmt {
    std::string string;
    switch (spec) {
      case '>':
-              return format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
+        return fmt::format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
      case '<':
-              return format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
+        return fmt::format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
      case '=':
-              format = "{coefficient:<4.3g}{padding}{prefix}{unit}";
+        format = "{coefficient:<{number_width}.1f}{padding}{prefix}{unit}";
        break;
      case 0:
      default:
-              format = "{coefficient:.3g}{prefix}{unit}";
+        format = "{coefficient:.1f}{prefix}{unit}";
        break;
    }
-          return format_to(ctx.out(), format
-              , fmt::arg("coefficient", fraction)
-              , fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : ""))
-              , fmt::arg("unit", s.unit_)
-              , fmt::arg("padding", pow ? "" : s.binary_ ? "  " : " ")
-            );
+    return fmt::format_to(
+        ctx.out(), fmt::runtime(format), fmt::arg("coefficient", fraction),
+        fmt::arg("number_width", number_width),
+        fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : "")),
+        fmt::arg("unit", s.unit_),
+        fmt::arg("padding", pow         ? ""
+                            : s.binary_ ? "  "
+                                        : " "));
  }
 };
-}

+// Glib ustirng support
+template <>
+struct formatter<Glib::ustring> : formatter<std::string> {
+  template <typename FormatContext>
+  auto format(const Glib::ustring& value, FormatContext& ctx) {
+    return formatter<std::string>::format(static_cast<std::string>(value), ctx);
+  }
+};
+}  // namespace fmt
--- a/include/util/gtk_icon.hpp
+++ b/include/util/gtk_icon.hpp
@ -0,0 +1,14 @@
+#pragma once
+#include <gtkmm/icontheme.h>
+
+#include <mutex>
+#include <string>
+
+class DefaultGtkIconThemeWrapper {
+ private:
+  static std::mutex default_theme_mutex;
+
+ public:
+  static bool has_icon(const std::string&);
+  static Glib::RefPtr<Gdk::Pixbuf> load_icon(const char*, int, Gtk::IconLookupFlags);
+};
--- a/include/util/json.hpp
+++ b/include/util/json.hpp
@ -1,7 +1,15 @@
 #pragma once

+#include <fmt/ostream.h>
 #include <json/json.h>

+#if (FMT_VERSION >= 90000)
+
+template <>
+struct fmt::formatter<Json::Value> : ostream_formatter {};
+
+#endif
+
 namespace waybar::util {

 struct JsonParser {
--- a/include/util/prepare_for_sleep.h
+++ b/include/util/prepare_for_sleep.h
@ -0,0 +1,9 @@
+#pragma once
+
+#include "SafeSignal.hpp"
+
+namespace waybar::util {
+
+// Get a signal emited with value true when entering sleep, and false when exiting
+SafeSignal<bool>& prepare_for_sleep();
+}  // namespace waybar::util
--- a/include/util/rewrite_string.hpp
+++ b/include/util/rewrite_string.hpp
@ -0,0 +1,8 @@
+#pragma once
+#include <json/json.h>
+
+#include <string>
+
+namespace waybar::util {
+std::string rewriteString(const std::string&, const Json::Value&);
+}
--- a/include/util/sanitize_str.hpp
+++ b/include/util/sanitize_str.hpp
@ -0,0 +1,6 @@
+#pragma once
+#include <string>
+
+namespace waybar::util {
+std::string sanitize_string(std::string str);
+}  // namespace waybar::util
--- a/include/util/sleeper_thread.hpp
+++ b/include/util/sleeper_thread.hpp
@ -6,6 +6,8 @@
 #include <functional>
 #include <thread>

+#include "prepare_for_sleep.h"
+
 namespace waybar::util {

 /**
@ -17,6 +19,7 @@ namespace waybar::util {
 */
 class CancellationGuard {
  int oldstate;
+
 public:
  CancellationGuard() { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate); }
  ~CancellationGuard() { pthread_setcancelstate(oldstate, &oldstate); }
@ -32,7 +35,11 @@ class SleeperThread {
            signal_ = false;
            func();
          }
-        }} {}
+        }} {
+    connection_ = prepare_for_sleep().connect([this](bool sleep) {
+      if (not sleep) wake_up();
+    });
+  }

  SleeperThread& operator=(std::function<void()> func) {
    thread_ = std::thread([this, func] {
@ -41,6 +48,11 @@ class SleeperThread {
        func();
      }
    });
+    if (connection_.empty()) {
+      connection_ = prepare_for_sleep().connect([this](bool sleep) {
+        if (not sleep) wake_up();
+      });
+    }
    return *this;
  }

@ -60,7 +72,7 @@ class SleeperThread {
    return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; });
  }

-  auto wake_up() {
+  void wake_up() {
    {
      std::lock_guard<std::mutex> lck(mutex_);
      signal_ = true;
@ -83,6 +95,7 @@ class SleeperThread {
  }

  ~SleeperThread() {
+    connection_.disconnect();
    stop();
    if (thread_.joinable()) {
      thread_.join();
@ -95,6 +108,7 @@ class SleeperThread {
  std::mutex mutex_;
  bool do_run_ = true;
  bool signal_ = false;
+  sigc::connection connection_;
 };

 }  // namespace waybar::util
--- a/include/util/string.hpp
+++ b/include/util/string.hpp
@ -1,15 +1,17 @@
+#pragma once
+
 #include <string>

 const std::string WHITESPACE = " \n\r\t\f\v";

-std::string ltrim(const std::string s) {
+inline std::string ltrim(const std::string& s) {
  size_t begin = s.find_first_not_of(WHITESPACE);
  return (begin == std::string::npos) ? "" : s.substr(begin);
 }

-std::string rtrim(const std::string s) {
+inline std::string rtrim(const std::string& s) {
  size_t end = s.find_last_not_of(WHITESPACE);
  return (end == std::string::npos) ? "" : s.substr(0, end + 1);
 }

-std::string trim(const std::string& s) { return rtrim(ltrim(s)); }
+inline std::string trim(const std::string& s) { return rtrim(ltrim(s)); }
--- a/man/waybar-backlight.5.scd
+++ b/man/waybar-backlight.5.scd
@ -37,8 +37,8 @@ The *backlight* module displays the current backlight level.
 	Positive value to rotate the text label.

 *states*: ++
-	typeof: array ++
-	A number of backlight states which get activated on certain brightness levels.
+	typeof: object ++
+	A number of backlight states which get activated on certain brightness levels. See *waybar-states(5)*.

 *on-click*: ++
 	typeof: string ++
@ -58,16 +58,25 @@ The *backlight* module displays the current backlight level.

 *on-scroll-up*: ++
 	typeof: string ++
-	Command to execute when performing a scroll up on the module.
+	Command to execute when performing a scroll up on the module. This replaces the default behaviour of brightness control.

 *on-scroll-down*: ++
 	typeof: string
-	Command to execute when performing a scroll down on the module.
+	Command to execute when performing a scroll down on the module. This replaces the default behaviour of brightness control.

 *smooth-scrolling-threshold*: ++
 	typeof: double
 	Threshold to be used when scrolling.

+*reverse-scrolling*: ++
+	typeof: bool ++
+	Option to reverse the scroll direction.
+
+*scroll-step*: ++
+	typeof: float ++
+	default: 1.0 ++
+	The speed in which to change the brightness when scrolling.
+
 # EXAMPLE:

 ```
--- a/man/waybar-battery.5.scd
+++ b/man/waybar-battery.5.scd
@ -33,13 +33,13 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 	The interval in which the information gets polled.

 *states*: ++
-	typeof: array ++
+	typeof: object ++
 	A number of battery states which get activated on certain capacity levels. See *waybar-states(5)*.

 *format*: ++
 	typeof: string ++
 	default: {capacity}% ++
-	The format, how the time should be displayed.
+	The format, how information should be displayed.

 *format-time*: ++
 	typeof: string ++
@ -114,13 +114,14 @@ The *battery* module displays the current capacity and state (eg. charging) of y

 The *battery* module allows you to define how time should be formatted via *format-time*.

-The two arguments are:
+The three arguments are:
 *{H}*: Hours
 *{M}*: Minutes
+*{m}*: Zero-padded minutes

 # CUSTOM FORMATS

-The *battery* module allows to define custom formats based on up to two factors. The best fitting format will be selected.
+The *battery* module allows one to define custom formats based on up to two factors. The best fitting format will be selected.

 *format-<state>*: With *states*, a custom format can be set depending on the capacity of your battery.

--- a/man/waybar-bluetooth.5.scd
+++ b/man/waybar-bluetooth.5.scd
@ -6,21 +6,51 @@ waybar - bluetooth module

 # DESCRIPTION

-The *bluetooth* module displays information about the status of the device's bluetooth device.
+The *bluetooth* module displays information about a bluetooth controller and its connections.

 # CONFIGURATION

 Addressed by *bluetooth*

+*controller*: ++
+	typeof: string ++
+	Use the controller with the defined alias. Otherwise a random controller is used. Recommended to define when there is more than 1 controller available to the system.
+
+*format-device-preference*: ++
+	typeof: array ++
+	A ranking of bluetooth devices, addressed by their alias. The order is from *first displayed* to *last displayed*. ++
+	If this config option is not defined or none of the devices in the list are connected, it will fall back to showing the last connected device.
+
 *format*: ++
 	typeof: string  ++
-	default: *{icon}* ++
+	default: * {status}* ++
 	The format, how information should be displayed. This format is used when other formats aren't specified.

+*format-disabled*: ++
+	typeof: string ++
+	This format is used when the displayed controller is disabled.
+
+*format-off*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned off.
+
+*format-on*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned on with no devices connected.
+
+*format-connected*: ++
+	typeof: string ++
+	This format is used when the displayed controller is connected to at least 1 device.
+
+*format-no-controller*: ++
+	typeof: string ++
+	This format is used when no bluetooth controller could be found
+
 *format-icons*: ++
 	typeof: array/object ++
-	Based on the device status, the corresponding icon gets selected. ++
-	The order is *low* to *high*. Or by the state if it is an object.
+	Based on the current battery percentage (see section *EXPERIMENTAL BATTERY PERCENTAGE FEATURE*), the corresponding icon gets selected. ++
+	The order is *low* to *high*. Will only show the current battery percentage icon in the *\*-connected-battery* config options. ++
+	Or by the state if it is an object. It will fall back to the enabled state if its derivatives are not defined (on, off, connected).

 *rotate*: ++
 	typeof: integer ++
@ -71,26 +101,110 @@ Addressed by *bluetooth*
 	typeof: string ++
 	The format, how information should be displayed in the tooltip. This format is used when other formats aren't specified.

+*tooltip-format-disabled*: ++
+	typeof: string ++
+	This format is used when the displayed controller is disabled.
+
+*tooltip-format-off*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned off.
+
+*tooltip-format-on*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned on with no devices connected.
+
+*tooltip-format-connected*: ++
+	typeof: string ++
+	This format is used when the displayed controller is connected to at least 1 device.
+
+*tooltip-format-no-controller*: ++
+	typeof: string ++
+	This format is used when no bluetooth controller could be found
+
+*tooltip-format-enumerate-connected*: ++
+	typeof: string ++
+	This format is used to define how each connected device should be displayed within the *device_enumerate* format replacement in the tooltip menu.
+
 # FORMAT REPLACEMENTS

 *{status}*: Status of the bluetooth device.

 *{icon}*: Icon, as defined in *format-icons*.

+*{num_connections}*: Number of connections the displayed controller has.
+
+*{controller_address}*: Address of the displayed controller.
+
+*{controller_address_type}*: Address type of the displayed controller.
+
+*{controller_alias}*: Alias of the displayed controller.
+
+*{device_address}*: Address of the displayed device.
+
+*{device_address_type}*: Address type of the displayed device.
+
+*{device_alias}*: Alias of the displayed device.
+
+*{device_enumerate}*: Show a list of all connected devices, each on a separate line. Define the format of each device with the *tooltip-format-enumerate-connected* ++
+and/or *tooltip-format-enumerate-connected-battery* config options. Can only be used in the tooltip related format options.
+
+# EXPERIMENTAL BATTERY PERCENTAGE FEATURE
+
+At the time of writing, the experimental features of BlueZ need to be turned on, for the battery percentage options listed below to work.
+
+## FORMAT REPLACEMENT
+
+*{device_battery_percentage}*: Battery percentage of the displayed device if available. Use only in the config options defined below.
+
+## CONFIGURATION
+
+*format-connected-battery*: ++
+	typeof: string ++
+	This format is used when the displayed device provides its battery percentage.
+
+*tooltip-format-connected-battery*: ++
+	typeof: string ++
+	This format is used when the displayed device provides its battery percentage.
+
+*tooltip-format-enumerate-connected-battery*: ++
+	typeof: string ++
+	This format is used to define how each connected device with a battery should be displayed within the *device_enumerate* format replacement option. ++
+	When this config option is not defined, it will fall back on the *tooltip-format-enumerate-connected* config option.
+
 # EXAMPLES

 ```
 "bluetooth": {
-	"format": "{icon}",
-	"format-alt": "bluetooth: {status}",
-	"format-icons": {
-		"enabled": "",
-		"disabled": ""
-	},
-	"tooltip-format": "{}"
+	// "controller": "controller1", // specify the alias of the controller if there are more than 1 on the system
+	"format": " {status}",
+	"format-disabled": "", // an empty format will hide the module
+	"format-connected": " {num_connections} connected",
+	"tooltip-format": "{controller_alias}\\t{controller_address}",
+	"tooltip-format-connected": "{controller_alias}\\t{controller_address}\\n\\n{device_enumerate}",
+	"tooltip-format-enumerate-connected": "{device_alias}\\t{device_address}"
+}
+```
+
+```
+"bluetooth": {
+	"format": " {status}",
+	"format-connected": " {device_alias}",
+	"format-connected-battery": " {device_alias} {device_battery_percentage}%",
+	// "format-device-preference": [ "device1", "device2" ], // preference list deciding the displayed device
+	"tooltip-format": "{controller_alias}\\t{controller_address}\\n\\n{num_connections} connected",
+	"tooltip-format-connected": "{controller_alias}\\t{controller_address}\\n\\n{num_connections} connected\\n\\n{device_enumerate}",
+	"tooltip-format-enumerate-connected": "{device_alias}\\t{device_address}",
+	"tooltip-format-enumerate-connected-battery": "{device_alias}\\t{device_address}\\t{device_battery_percentage}%"
 }
 ```

 # STYLE

 - *#bluetooth*
+- *#bluetooth.disabled*
+- *#bluetooth.off*
+- *#bluetooth.on*
+- *#bluetooth.connected*
+- *#bluetooth.discoverable*
+- *#bluetooth.discovering*
+- *#bluetooth.pairable*
--- a/man/waybar-cava.5.scd
+++ b/man/waybar-cava.5.scd
@ -0,0 +1,182 @@
+waybar-cava(5) "waybar-cava" "User Manual"
+
+# NAME
+
+waybar - cava module
+
+# DESCRIPTION
+
+*cava* module for karlstav/cava project. See it on github: https://github.com/karlstav/cava.
+
+
+# FILES
+
+$XDG_CONFIG_HOME/waybar/config ++
+	Per user configuration file
+
+# ADDITIONAL FILES
+
+libcava lives in:
+
+. /usr/lib/libcava.so or /usr/lib64/libcava.so
+. /usr/lib/pkgconfig/cava.pc or /usr/lib64/pkgconfig/cava.pc
+. /usr/include/cava
+
+# CONFIGURATION
+
+[- *Option*
+:- *Typeof*
+:- *Default*
+:- *Description*
+|[ *cava_config*
+:[ string
+:[
+:< Path where cava configuration file is placed to
+|[ *framerate*
+:[ integer
+:[ 30
+:[ rames per second. Is used as a replacement for *interval*
+|[ *autosens*
+:[ integer
+:[ 1
+:[ Will attempt to decrease sensitivity if the bars peak
+|[ *sensitivity*
+:[ integer
+:[ 100
+:[ Manual sensitivity in %. It's recommended to be omitted when *autosens* = 1
+|[ *bars*
+:[ integer
+:[ 12
+:[ The number of bars
+|[ *lower_cutoff_freq*
+:[ long integer
+:[ 50
+:[ Lower cutoff frequencies for lowest bars the bandwidth of the visualizer
+|[ *higher_cutoff_freq*
+:[ long integer
+:[ 10000
+:[ Higher cutoff frequencies for highest bars the bandwidth of the visualizer
+|[ *sleep_timer*
+:[ integer
+:[ 5
+:[ Seconds with no input before cava main thread goes to sleep mode
+|[ *method*
+:[ string
+:[ pulse
+:[ Audio capturing method. Possible methods are: pipewire, pulse, alsa, fifo, sndio or shmem
+|[ *source*
+:[ string
+:[ auto
+:[ See cava configuration
+|[ *sample_rate*
+:[ long integer
+:[ 44100
+:[ See cava configuration
+|[ *sample_bits*
+:[ integer
+:[ 16
+:[ See cava configuration
+|[ *stereo*
+:[ bool
+:[ true
+:[ Visual channels
+|[ *reverse*
+:[ bool
+:[ false
+:[ Displays frequencies the other way around
+|[ *bar_delimiter*
+:[ integer
+:[ 0
+:[ Each bar is separated by a delimiter. Use decimal value in ascii table(i.e. 59 = ";"). 0 means no delimiter
+|[ *monstercat*
+:[ bool
+:[ false
+:[ Disables or enables the so-called "Monstercat smoothing" with of without "waves"
+|[ *waves*
+:[ bool
+:[ false
+:[ Disables or enables the so-called "Monstercat smoothing" with of without "waves"
+|[ *noise_reduction*
+:[ double
+:[ 0.77
+:[ Range between 0 - 1. The raw visualization is very noisy, this factor adjust the integral and gravity filters to keep the signal smooth. 1 - will be very slow and smooth, 0 - will be fast but noisy
+|[ *input_delay*
+:[ integer
+:[ 2
+:[ Sets the delay before fetching audio source thread start working. On author machine Waybar starts much faster then pipewire audio server, and without a little delay cava module fails due to pipewire is not ready
+|[ *ascii_max_range*
+:[ integer
+:[ 7
+:[ It's impossible to set it directly. The value is dictated by the number of icons in the array *format-icons*
+|[ *data_format*
+:[ string
+:[ asci
+:[ It's impossible to set it. Waybar sets it to = asci for internal needs
+|[ *raw_target*
+:[ string
+:[ /dev/stdout
+:[ It's impossible to set it. Waybar sets it to = /dev/stdout for internal needs
+
+Configuration can be provided as:
+- The only cava configuration file which is provided through *cava_config*. The rest configuration can be skipped
+- Without cava configuration file. In such case cava should be configured through provided list of the configuration option
+- Mix. When provided both And cava configuration file And configuration options. In such case waybar applies configuration file first then overrides particular options by the provided list of configuration options
+
+# ACTIONS
+
+[- *String*
+:- *Action*
+|[ *mode*
+:< Switch main cava thread and fetching audio source thread from/to pause/resume
+
+# DEPENDENCIES
+
+- iniparser
+- fftw3
+
+# SOLVING ISSUES
+
+. On start Waybar throws an exception "error while loading shared libraries: libcava.so: cannot open shared object file: No such file or directory".
+  It might happen when libcava for some reason hasn't been registered in the system. sudo ldconfig should help
+. Waybar is starting but cava module doesn't react on the music
+	1. In such case for at first need to make sure usual cava application is working as well
+	2. If so, need to comment all configuration options. Uncomment cava_config and provide the path to the working cava config
+	3. You might set too huge or too small input_delay. Try to setup to 4 seconds, restart waybar and check again 4 seconds past. Usual even on weak machines it should be enough
+	4. You might accidentally switched action mode to pause mode
+
+# RISING ISSUES
+
+For clear understanding: this module is a cava API's consumer. So for any bugs related to cava engine you should contact to Cava upstream(https://github.com/karlstav/cava) ++
+with the one Exception. Cava upstream doesn't provide cava as a shared library. For that this module author made a fork libcava(https://github.com/LukashonakV/cava). ++
+So the order is:
+. cava upstream
+. libcava upstream.
+In case when cava releases new version and you're wanna get it, it should be raised an issue to libcava(https://github.com/LukashonakV/cava) with title ++
+\[Bump\]x.x.x where x.x.x is cava release version.
+
+# EXAMPLES
+
+```
+"cava": {
+	//"cava_config": "$XDG_CONFIG_HOME/cava/cava.conf",
+	"framerate": 30,
+	"autosens": 1,
+	//"sensitivity": 100,
+	"bars": 14,
+	"lower_cutoff_freq": 50,
+	"higher_cutoff_freq": 10000,
+	"method": "pulse",
+	"source": "auto",
+	"stereo": true,
+	"reverse": false,
+	"bar_delimiter": 0,
+	"monstercat": false,
+	"waves": false,
+	"noise_reduction": 0.77,
+	"input_delay": 2,
+	"format-icons" : ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█" ],
+	"actions": {
+		"on-click-right": "mode"
+	}
+},
+```
--- a/man/waybar-clock.5.scd
+++ b/man/waybar-clock.5.scd
@ -1,4 +1,4 @@
-waybar-clock(5)
+waybar-clock(5) "waybar-clock" "User Manual"

 # NAME

@ -6,93 +6,162 @@ waybar - clock module

 # DESCRIPTION

-The *clock* module displays the current date and time.
+*clock* module displays current date and time
+
+# FILES
+
+$XDG_CONFIG_HOME/waybar/config ++
+	Per user configuration file

 # CONFIGURATION

-*interval*: ++
-	typeof: integer ++
-	default: 60 ++
-	The interval in which the information gets polled.
+1. Addressed by *clock*
+[- *Option*
+:- *Typeof*
+:- *Default*
+:- *Description*
+|[ *interval*
+:[ integer
+:[ 60
+:[ The interval in which the information gets polled
+|[ *format*
+:[ string
+:[ *{:%H:%M}*
+:[ The format, how the date and time should be displayed. See format options below
+|[ *timezone*
+:[ string
+:[
+:[ The timezone to display the time in, e.g. America/New_York. "" represents
+   the system's local timezone. See Wikipedia's unofficial list of timezones <https://en.wikipedia.org/wiki/List_of_tz_database_time_zones>
+|[ *timezones*
+:[ list of strings
+:[
+:[ A list of timezones (as in *timezone*) to use for time display, changed using
+   the scroll wheel. Do not specify *timezone* option when *timezones* is specified.
+   "" represents the system's local timezone
+|[ *locale*
+:[ string
+:[
+:[ A locale to be used to display the time. Intended to render times in custom
+   timezones with the proper language and format
+|[ *max-length*
+:[ integer
+:[
+:[ The maximum length in character the module should display
+|[ *rotate*
+:[ integer
+:[
+:[ Positive value to rotate the text label
+|[ *on-click*
+:[ string
+:[
+:[ Command to execute when clicked on the module
+|[ *on-click-middle*
+:[ string
+:[
+:[ Command to execute when you middle clicked on the module using mousewheel
+|[ *on-click-right*
+:[ string
+:[
+:[ Command to execute when you right clicked on the module
+|[ *on-scroll-up*
+:[ string
+:[
+:[ Command to execute when scrolling up on the module
+|[ *on-scroll-down*
+:[ string
+:[
+:[ Command to execute when scrolling down on the module
+|[ *smooth-scrolling-threshold*
+:[ double
+:[
+:[ Threshold to be used when scrolling
+|[ *tooltip*
+:[ bool
+:[ true
+:[ Option to enable tooltip on hover
+|[ *tooltip-format*
+:[ string
+:[ same as format
+:[ Tooltip on hover

-*format*: ++
-	typeof: string ++
-	default: {:%H:%M} ++
-	The format, how the date and time should be displayed. ++
-	It uses the format of the date library. See https://howardhinnant.github.io/date/date.html#to_stream_formatting for details.
+View all valid format options in *strftime(3)* or have a look <https://fmt.dev/latest/syntax.html#chrono-specs>

-*timezone*: ++
-	typeof: string ++
-	default: inferred local timezone ++
-	The timezone to display the time in, e.g. America/New_York.
+2. Addressed by *clock: calendar*
+[- *Option*
+:- *Typeof*
+:- *Default*
+:- *Description*
+|[ *mode*
+:[ string
+:[ month
+:[ Calendar view mode. Possible values: year|month
+|[ *mode-mon-col*
+:[ integer
+:[ 3
+:[ Relevant for *mode=year*. Count of months per row
+|[ *weeks-pos*
+:[ integer
+:[
+:[ The position where week numbers should be displayed. Disabled when is empty.
+   Possible values: left|right
+|[ *on-scroll*
+:[ integer
+:[ 1
+:[ Value to scroll months/years forward/backward. Can be negative. Is
+   configured under *on-scroll* option

-*timezones*: ++
-	typeof: list of strings ++
-	A list of timezones to use for time display, changed using the scroll wheel. ++
-	Use "" to represent the system's local timezone.  Using %Z in the format or tooltip format is useful to track which time zone is currently displayed.
+3. Addressed by *clock: calendar: format*
+[- *Option*
+:- *Typeof*
+:- *Default*
+:- *Description*
+|[ *months*
+:[ string
+:[
+:[ Format is applied to months header(January, February,...etc.)
+|[ *days*
+:[ string
+:[
+:[ Format is applied to days
+|[ *weeks*
+:[ string
+:[ *{:%U}*
+:[ Format is applied to week numbers. When weekday format is not provided then
+   is used default format: '{:%W}' when week starts with Monday, '{:%U}' otherwise
+|[ *weekdays*
+:[ string
+:[
+:[ Format is applied to weeks header(Su,Mo,...etc.)
+|[ *today*
+:[ string
+:[ *<b><u>{}</u></b>*
+:[ Format is applied to Today

-*locale*: ++
-	typeof: string ++
-	default: inferred from current locale ++
-	A locale to be used to display the time. Intended to render times in custom timezones with the proper language and format.
+## Actions

-*today-format*: ++
-	typeof: string ++
-	default: <b><u>{}</u></b> ++
-	The format of today's date in the calendar.
-
-*max-length*: ++
-	typeof: integer ++
-	The maximum length in character the module should display.
-
-*min-length*: ++
-    typeof: integer ++
-    The minimum length in characters the module should take up.
-
-*align*: ++
-    typeof: float ++
-    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
-
-*rotate*: ++
-	typeof: integer ++
-	Positive value to rotate the text label.
-
-*on-click*: ++
-	typeof: string ++
-	Command to execute when clicked on the module.
-
-*on-click-middle*: ++
-	typeof: string ++
-	Command to execute when middle-clicked on the module using mousewheel.
-
-*on-click-right*: ++
-	typeof: string ++
-	Command to execute when you right clicked on the module.
-
-*on-update*: ++
-	typeof: string ++
-	Command to execute when the module is updated.
-
-*on-scroll-up*: ++
-	typeof: string ++
-	Command to execute when scrolling up on the module.
-
-*on-scroll-down*: ++
-	typeof: string ++
-	Command to execute when scrolling down on the module.
-
-*smooth-scrolling-threshold*: ++
-	typeof: double ++
-	Threshold to be used when scrolling.
-
-View all valid format options in *strftime(3)*.
+[- *String*
+:- *Action*
+|[ *mode*
+:[ Switch calendar mode between year/month
+|[ *tz_up*
+:[ Switch to the next provided time zone
+|[ *tz_down*
+:[ Switch to the previous provided time zone
+|[ *shift_up*
+:[ Switch to the next calendar month/year
+|[ *shift_down*
+:[ Switch to the previous calendar month/year

 # FORMAT REPLACEMENTS

-*{calendar}*: Current month calendar
+- *{calendar}*: Current month calendar
+- *{timezoned_time_list}*: List of time in the rest timezones, if more than one timezone is set in the config

 # EXAMPLES

+1. General
+
 ```
 "clock": {
 	"interval": 60,
@ -101,6 +170,101 @@ View all valid format options in *strftime(3)*.
 }
 ```

+2. Calendar
+
+```
+"clock": {
+	"format": "{:%H:%M}  ",
+	"format-alt": "{:%A, %B %d, %Y (%R)}  ",
+	"tooltip-format": "<tt><small>{calendar}</small></tt>",
+	"calendar": {
+		"mode"          : "year",
+		"mode-mon-col"  : 3,
+		"weeks-pos"     : "right",
+		"on-scroll"     : 1,
+		"on-click-right": "mode",
+		"format": {
+			"months":     "<span color='#ffead3'><b>{}</b></span>",
+			"days":       "<span color='#ecc6d9'><b>{}</b></span>",
+			"weeks":      "<span color='#99ffdd'><b>W{}</b></span>",
+			"weekdays":   "<span color='#ffcc66'><b>{}</b></span>",
+			"today":      "<span color='#ff6699'><b><u>{}</u></b></span>"
+		}
+	},
+	"actions": {
+		"on-click-right": "mode",
+		"on-click-forward": "tz_up",
+		"on-click-backward": "tz_down",
+		"on-scroll-up": "shift_up",
+		"on-scroll-down": "shift_down"
+	}
+},
+```
+
+3. Full date on hover
+
+```
+"clock": {
+	"interval": 60,
+	"tooltip": true,
+	"format": "{:%H.%M}",
+	"tooltip-format": "{:%Y-%m-%d}",
+}
+```
+
 # STYLE

 - *#clock*
+
+# Troubleshooting
+
+If clock module is disabled at startup with locale::facet::\_S\_create\_c\_locale ++
+name not valid error message try one of the followings:
+
+- check if LC_TIME is set properly (glibc)
+- set locale to C in the config file (musl)
+
+The locale option must be set for {calendar} to use the correct start-of-week, regardless of system locale.
+
+## Calendar in Chinese. Alignment
+
+In order to have aligned Chinese calendar there are some useful recommendations:
+
+. Use "WenQuanYi Zen Hei Mono" which is provided in most Linux distributions
+. Try different font sizes and find best for you. size = 9pt should be fine
+. In case when "WenQuanYi Zen Hei Mono" font is used disable monospace font pango tag
+
+Example of working config
+
+```
+"clock": {
+	"format": "{:%H:%M}  ",
+	"format-alt": "{:%A, %B %d, %Y (%R)}  ",
+	"tooltip-format": "\n<span size='9pt' font='WenQuanYi Zen Hei Mono'>{calendar}</span>",
+	"calendar": {
+		"mode"          : "year",
+		"mode-mon-col"  : 3,
+		"weeks-pos"     : "right",
+		"on-scroll"     : 1,
+		"on-click-right": "mode",
+		"format": {
+			"months":     "<span color='#ffead3'><b>{}</b></span>",
+			"days":       "<span color='#ecc6d9'><b>{}</b></span>",
+			"weeks":      "<span color='#99ffdd'><b>W{}</b></span>",
+			"weekdays":   "<span color='#ffcc66'><b>{}</b></span>",
+			"today":      "<span color='#ff6699'><b><u>{}</u></b></span>"
+		}
+	},
+	"actions": {
+		"on-click-right": "mode",
+		"on-click-forward": "tz_up",
+		"on-click-backward": "tz_down",
+		"on-scroll-up": "shift_up",
+		"on-scroll-down": "shift_down"
+	}
+},
+```
+
+# AUTHOR
+
+Alexis Rouillard <contact@arouillard.fr>
--- a/man/waybar-cpu.5.scd
+++ b/man/waybar-cpu.5.scd
@ -20,6 +20,11 @@ The *cpu* module displays the current cpu utilization.
 	default: {usage}% ++
 	The format, how information should be displayed. On {} data gets inserted.

+*format-icons*: ++
+	typeof: array/object ++
+	Based on the current usage, the corresponding icon gets selected. ++
+	The order is *low* to *high*. Or by the state if it is an object.
+
 *max-length*: ++
 	typeof: integer ++
 	The maximum length in character the module should display.
@ -37,7 +42,7 @@ The *cpu* module displays the current cpu utilization.
 	Positive value to rotate the text label.

 *states*: ++
-	typeof: array ++
+	typeof: object ++
 	A number of cpu usage states which get activated on certain usage levels. See *waybar-states(5)*.

 *on-click*: ++
@ -77,7 +82,9 @@ The *cpu* module displays the current cpu utilization.

 *{load}*: Current cpu load.

-*{usage}*: Current cpu usage.
+*{usage}*: Current overall cpu usage.
+
+*{usage*{n}*}*: Current cpu core n usage. Cores are numbered from zero, so first core will be {usage0} and 4th will be {usage3}.

 *{avg_frequency}*: Current cpu average frequency (based on all cores) in GHz.

@ -85,7 +92,13 @@ The *cpu* module displays the current cpu utilization.

 *{min_frequency}*: Current cpu min frequency (based on the core with the lowest frequency) in GHz.

-# EXAMPLE
+*{icon}*: Icon for overall cpu usage.
+
+*{icon*{n}*}*: Icon for cpu core n usage. Use like {icon0}.
+
+# EXAMPLES
+
+Basic configuration:

 ```
 "cpu": {
@ -95,6 +108,16 @@ The *cpu* module displays the current cpu utilization.
 }
 ```

+Cpu usage per core rendered as icons:
+
+```
+"cpu": {
+	"interval": 1,
+	"format": "{icon0}{icon1}{icon2}{icon3} {usage:>2}% ",
+	"format-icons": ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"],
+},
+```
+
 # STYLE

 - *#cpu*
--- a/man/waybar-custom.5.scd
+++ b/man/waybar-custom.5.scd
@ -1,5 +1,4 @@
 waybar-custom(5)
-
 # NAME

 waybar - custom module
@ -19,14 +18,13 @@ Addressed by *custom/<name>*

 *exec-if*: ++
 	typeof: string ++
-	The path to a script, which determines if the script in *exec* should be executed.
+	The path to a script, which determines if the script in *exec* should be executed. ++
 	*exec* will be executed if the exit code of *exec-if* equals 0.

 *exec-on-event*: ++
 	typeof: bool ++
 	default: true ++
-	If an event command is set (e.g. *on-click* or *on-scroll-up*) then re-execute the script after
-	executing the event command.
+	If an event command is set (e.g. *on-click* or *on-scroll-up*) then re-execute the script after executing the event command.

 *return-type*: ++
 	typeof: string ++
@ -34,20 +32,19 @@ Addressed by *custom/<name>*

 *interval*: ++
 	typeof: integer ++
-	The interval (in seconds) in which the information gets polled.
-	Use *once* if you want to execute the module only on startup.
-	You can update it manually with a signal. If no *interval* is defined,
-	it is assumed that the out script loops it self.
+	The interval (in seconds) in which the information gets polled. ++
+	Use *once* if you want to execute the module only on startup. ++
+	You can update it manually with a signal. If no *interval* is defined, it is assumed that the out script loops it self.

 *restart-interval*: ++
 	typeof: integer ++
-	The restart interval (in seconds).
-	Can't be used with the *interval* option, so only with continuous scripts.
+	The restart interval (in seconds). ++
+	Can't be used with the *interval* option, so only with continuous scripts. ++
 	Once the script exit, it'll be re-executed after the *restart-interval*.

 *signal*: ++
 	typeof: integer ++
-	The signal number used to update the module.
+	The signal number used to update the module. ++
 	The number is valid between 1 and N, where *SIGRTMIN+N* = *SIGRTMAX*.

 *format*: ++
@ -151,7 +148,8 @@ $text\\n$tooltip\\n$class*
 	"max-length": 40,
 	"interval": 30, // Remove this if your script is endless and write in loop
 	"exec": "$HOME/.config/waybar/mediaplayer.sh 2> /dev/null", // Script in resources folder
-	"exec-if": "pgrep spotify"
+	"exec-if": "pgrep spotify",
+	"return-type": "json"
 }
 ```

--- a/man/waybar-disk.5.scd
+++ b/man/waybar-disk.5.scd
@ -32,7 +32,7 @@ Addressed by *disk*
 	Positive value to rotate the text label.

 *states*: ++
-	typeof: array ++
+	typeof: object ++
 	A number of disk utilization states which get activated on certain percentage thresholds (percentage_used). See *waybar-states(5)*.

 *max-length*: ++
--- a/man/waybar-dwl-tags.5.scd
+++ b/man/waybar-dwl-tags.5.scd
@ -0,0 +1,49 @@
+waybar-dwl-tags(5)
+
+# NAME
+
+waybar - dwl tags module
+
+# DESCRIPTION
+
+The *tags* module displays the current state of tags in dwl.
+
+# CONFIGURATION
+
+Addressed by *dwl/tags*
+
+*num-tags*: ++
+	typeof: uint ++
+	default: 9 ++
+	The number of tags that should be displayed. Max 32.
+
+*tag-labels*: ++
+	typeof: array ++
+	The label to display for each tag.
+
+*disable-click*: ++
+	typeof: bool ++
+	default: false ++
+	If set to false, you can left click to set focused tag. Right click to toggle tag focus. If set to true this behaviour is disabled.
+
+# EXAMPLE
+
+```
+"dwl/tags": {
+	"num-tags": 5
+}
+```
+
+# STYLE
+
+- *#tags button*
+- *#tags button.occupied*
+- *#tags button.focused*
+- *#tags button.urgent*
+
+Note that occupied/focused/urgent status may overlap. That is, a tag may be
+both occupied and focused at the same time.
+
+# SEE ALSO
+
+waybar(5), dwl(1)
--- a/Show More
+++ b/Show More